clawvault 2.6.0 → 3.0.0

package/dist/index.d.cts

@@ -0,0 +1,858 @@
+import { Command } from 'commander';
+import { V as VaultConfig, S as StoreOptions, D as Document, a as SearchOptions, b as SearchResult, c as SyncOptions, d as SyncResult, C as Category, M as MemoryType, H as HandoffDocument, e as SessionRecap, E as ExtractedDate, f as ExtractedPreference } from './types-Y2_Um2Ls.cjs';
+export { g as DEFAULT_CATEGORIES, h as DEFAULT_CONFIG, i as MEMORY_TYPES, T as TYPE_TO_CATEGORY, j as VaultMeta } from './types-Y2_Um2Ls.cjs';
+export { setupCommand } from './commands/setup.cjs';
+export { CompatCheck, CompatCommandOptions, CompatReport, CompatStatus, checkOpenClawCompatibility, compatCommand, compatibilityExitCode } from './commands/compat.cjs';
+export { GraphSummary, graphCommand, graphSummary } from './commands/graph.cjs';
+export { KanbanGroupBy, KanbanImportChange, KanbanImportOptions, KanbanImportResult, KanbanLane, KanbanSyncOptions, KanbanSyncResult, ParsedKanbanBoard, ParsedKanbanLane, buildKanbanLanes, extractCardSlug, formatKanbanCard, generateKanbanMarkdown, importKanbanBoard, kanbanCommand, parseKanbanMarkdown, syncKanbanBoard } from './commands/kanban.cjs';
+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.cjs';
+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, L as LlmCompletionOptions, i as LlmProvider, 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-Bzi5E-By.cjs';
+export { ObserveCommandOptions, observeCommand, registerObserveCommand } from './commands/observe.cjs';
+export { ReflectCommandOptions, reflectCommand, registerReflectCommand } from './commands/reflect.cjs';
+export { ArchiveCommandOptions, archiveCommand, registerArchiveCommand } from './commands/archive.cjs';
+export { RebuildCommandOptions, rebuildCommand, registerRebuildCommand } from './commands/rebuild.cjs';
+export { DoctorCheck, DoctorReport, DoctorStatus, doctor } from './commands/doctor.cjs';
+export { EmbedCommandOptions, EmbedCommandResult, embedCommand, registerEmbedCommand } from './commands/embed.cjs';
+export { ReplayCommandOptions, registerReplayCommand, replayCommand } from './commands/replay.cjs';
+export { MigrateObservationsOptions, MigrateObservationsResult, migrateObservations, migrateObservationsCommand, registerMigrateObservationsCommand } from './commands/migrate-observations.cjs';
+export { SessionRecapFormat, SessionRecapOptions, SessionRecapResult, SessionTurn, buildSessionRecap, formatSessionRecapMarkdown, sessionRecapCommand } from './commands/session-recap.cjs';
+export { findNearestVaultPath, getVaultPath, resolveVaultPath } from './lib/config.cjs';
+export { registerCliCommands } from './cli/index.cjs';
+import { TaskStatus } from './lib/task-utils.cjs';
+export { completeTask, listDependentTasks, listSubtasks, updateTask } from './lib/task-utils.cjs';
+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.cjs';
+export { TailscaleDiscoverCommandOptions, TailscaleServeCommandOptions, TailscaleStatusCommandOptions, TailscaleSyncCommandOptions, registerTailscaleCommands, registerTailscaleDiscoverCommand, registerTailscaleServeCommand, registerTailscaleStatusCommand, registerTailscaleSyncCommand, tailscaleDiscoverCommand, tailscaleServeCommand, tailscaleStatusCommand, tailscaleSyncCommand } from './commands/tailscale.cjs';
+export { TemplateVariables, buildTemplateVariables, renderTemplate } from './lib/template-engine.cjs';
+export { Project, ProjectFrontmatter, ProjectStatus, archiveProject, createProject, getProjectActivity, getProjectTasks, listProjects, readProject, updateProject } from './lib/project-utils.cjs';
+import 'child_process';
+import 'http';
+
+/**
+ * ClawVault - The elephant's memory
+ */
+
+declare class ClawVault {
+    private config;
+    private search;
+    private initialized;
+    constructor(vaultPath: string);
+    /**
+     * Initialize a new vault
+     */
+    init(options?: Partial<VaultConfig>, initFlags?: {
+        skipBases?: boolean;
+        skipTasks?: boolean;
+        skipGraph?: boolean;
+    }): Promise<void>;
+    private createBasesFiles;
+    /**
+     * Load an existing vault
+     */
+    load(): Promise<void>;
+    /**
+     * Reindex all documents
+     */
+    reindex(): Promise<number>;
+    /**
+     * Load a document from disk
+     */
+    private loadDocument;
+    /**
+     * Store a new document
+     */
+    store(options: StoreOptions): Promise<Document>;
+    /**
+     * Quick store to inbox
+     */
+    capture(note: string, title?: string): Promise<Document>;
+    /**
+     * Search the vault (BM25 via qmd)
+     */
+    find(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Semantic/vector search (via qmd vsearch)
+     */
+    vsearch(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Combined search with query expansion (via qmd query)
+     */
+    query(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Get a document by ID or path
+     */
+    get(idOrPath: string): Promise<Document | null>;
+    /**
+     * List documents in a category
+     */
+    list(category?: string): Promise<Document[]>;
+    /**
+     * Sync vault to another location (for Obsidian on Windows, etc.)
+     */
+    sync(options: SyncOptions): Promise<SyncResult>;
+    /**
+     * Get vault statistics
+     */
+    stats(): Promise<{
+        documents: number;
+        categories: {
+            [key: string]: number;
+        };
+        links: number;
+        tags: string[];
+    }>;
+    /**
+     * Get all categories
+     */
+    getCategories(): Category[];
+    /**
+     * Check if vault is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get vault path
+     */
+    getPath(): string;
+    /**
+     * Get vault name
+     */
+    getName(): string;
+    /**
+     * Get qmd collection name
+     */
+    getQmdCollection(): string;
+    /**
+     * Get qmd collection root
+     */
+    getQmdRoot(): string;
+    /**
+     * Store a memory with type classification
+     * Automatically routes to correct category based on type
+     */
+    remember(type: MemoryType, title: string, content: string, frontmatter?: Record<string, unknown>): Promise<Document>;
+    /**
+     * Create a session handoff document
+     * Call this before context death or long pauses
+     */
+    createHandoff(handoff: Omit<HandoffDocument, 'created'>): Promise<Document>;
+    /**
+     * Format handoff as readable markdown
+     */
+    private formatHandoff;
+    /**
+     * Generate a session recap - who I was
+     * Call this on bootstrap to restore context
+     */
+    generateRecap(options?: {
+        handoffLimit?: number;
+        brief?: boolean;
+    }): Promise<SessionRecap>;
+    /**
+     * Format recap as readable markdown for injection
+     */
+    formatRecap(recap: SessionRecap, options?: {
+        brief?: boolean;
+    }): string;
+    /**
+     * Parse a handoff document back into structured form
+     */
+    private parseHandoff;
+    private applyQmdConfig;
+    private slugify;
+    private saveIndex;
+    private createTemplates;
+    private createWelcomeNote;
+    private syncMemoryGraphIndex;
+    private generateReadme;
+    private getCategoryDescription;
+}
+/**
+ * Find and open the nearest vault (walks up directory tree)
+ */
+declare function findVault(startPath?: string): Promise<ClawVault | null>;
+/**
+ * Create a new vault
+ */
+declare function createVault(vaultPath: string, options?: Partial<VaultConfig>, initFlags?: {
+    skipBases?: boolean;
+    skipTasks?: boolean;
+    skipGraph?: boolean;
+}): Promise<ClawVault>;
+
+interface ReweaveCommandOptions {
+    vaultPath?: string;
+    since?: string;
+    dryRun?: boolean;
+    threshold?: number;
+}
+declare function reweaveCommand(options: ReweaveCommandOptions): Promise<void>;
+declare function registerReweaveCommand(program: Command): void;
+
+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;
+}
+
+/**
+ * Reweave — Backward memory consolidation for ClawVault
+ *
+ * When new observations are written, reweave performs a backward pass over
+ * existing observations to detect knowledge updates (same entity, new value).
+ * Older observations are marked as superseded so search always returns the
+ * latest version of a fact.
+ *
+ * Design inspired by Ars Contexta's "notes are hypotheses" philosophy —
+ * every observation is a claim that can be superseded by newer evidence.
+ */
+
+interface SupersessionRecord {
+    /** The older observation that was superseded */
+    oldObservation: ParsedObservationRecord;
+    /** The newer observation that supersedes it */
+    newObservation: ParsedObservationRecord;
+    /** File path of the older observation */
+    oldFile: string;
+    /** File path of the newer observation */
+    newFile: string;
+    /** Reason for supersession */
+    reason: string;
+    /** Timestamp of detection */
+    detectedAt: string;
+}
+interface ReweaveResult {
+    /** Number of observation files scanned */
+    filesScanned: number;
+    /** Number of individual observations checked */
+    observationsChecked: number;
+    /** Supersession records found/applied */
+    supersessions: SupersessionRecord[];
+    /** Whether this was a dry run */
+    dryRun: boolean;
+}
+interface ReweaveOptions {
+    vaultPath: string;
+    /** Only process observations since this date (YYYY-MM-DD) */
+    since?: string;
+    /** Dry run — report but don't write */
+    dryRun?: boolean;
+    /** Similarity threshold for entity matching (0-1). Default 0.6 */
+    similarityThreshold?: number;
+}
+declare function isSuperseded(line: string): boolean;
+declare function getSupersessionInfo(line: string): {
+    supersededBy: string;
+    detectedAt: string;
+} | null;
+/**
+ * Extract key entities/subjects from an observation for matching.
+ * Returns normalized tokens that represent the "what" of the observation.
+ */
+declare function extractEntities(content: string): string[];
+/**
+ * Compute similarity between two observations based on entity overlap.
+ * Returns 0-1 where 1 = identical entities.
+ */
+declare function entitySimilarity(a: string[], b: string[]): number;
+/**
+ * Check if two observations represent a knowledge update.
+ * Both must be about the same entity/subject but with different values.
+ *
+ * Heuristic: high entity overlap + different observation content = update.
+ * Same content = duplicate, not update.
+ */
+declare function isKnowledgeUpdate(older: ParsedObservationRecord, newer: ParsedObservationRecord, threshold?: number): {
+    isUpdate: boolean;
+    reason: string;
+};
+/**
+ * Run backward consolidation across observations.
+ *
+ * For each newer observation, check all older observations for knowledge updates.
+ * When found, mark the older one as superseded.
+ */
+declare function reweave(options: ReweaveOptions): ReweaveResult;
+/**
+ * Filter search results to prefer latest versions of superseded observations.
+ * When multiple observations cover the same entity, only keep the newest.
+ *
+ * This is called from the search pipeline to boost knowledge update accuracy.
+ */
+declare function filterSuperseded(lines: string[]): string[];
+/**
+ * Given observation markdown content, return only non-superseded lines.
+ * Preserves date headings and structure.
+ */
+declare function stripSupersededObservations(markdown: string): string;
+
+/**
+ * ClawVault Search Engine - qmd Backend
+ * Uses qmd CLI for BM25 and vector search
+ *
+ * v2.7.0 enhancements:
+ *   1. Chunk-level BM25 pre-filtering (from eval v4 adapter)
+ *   2. Exhaustive threshold-based retrieval (from eval v6 adapter)
+ *   3. Preference extraction pipeline (from eval v3 adapter)
+ *   4. Temporal date indexing at ingest time (from eval v8 design)
+ */
+
+declare const QMD_INSTALL_URL = "https://github.com/tobi/qmd";
+declare const QMD_INSTALL_COMMAND = "bun install -g github:tobi/qmd";
+declare class QmdUnavailableError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Check if qmd is available
+ */
+declare function hasQmd(): boolean;
+/**
+ * Trigger qmd update (reindex)
+ */
+declare function qmdUpdate(collection?: string, indexName?: string): void;
+/**
+ * Trigger qmd embed (create/update vector embeddings)
+ */
+declare function qmdEmbed(collection?: string, indexName?: string): void;
+/**
+ * Split text into ~maxChars sentence-aligned chunks with overlap.
+ */
+declare function sentenceChunk(text: string, maxChars?: number, overlapSentences?: number): string[];
+/**
+ * BM25-rank chunks within a document by keyword overlap.
+ * Returns the top `max` chunks sorted by relevance, always including the
+ * first chunk (session context) when available.
+ */
+declare function bm25RankChunks(chunks: string[], terms: string[], max?: number): {
+    text: string;
+    score: number;
+}[];
+/**
+ * Extract all date references from text content. Designed to run at ingest
+ * time so temporal queries can use structured dates + JS arithmetic instead
+ * of relying on LLM date math at query time.
+ */
+declare function extractDates(text: string, sessionDateStr?: string): ExtractedDate[];
+/**
+ * Extract user preferences from conversation text. Runs at ingest time to
+ * build a structured preference index for personalised recommendations.
+ */
+declare function extractPreferences(text: string, documentId?: string): ExtractedPreference[];
+declare function classifyQuestion(q: string): 'preference' | 'temporal' | 'aggregation' | 'default';
+/**
+ * QMD Search Engine - wraps qmd CLI
+ */
+declare class SearchEngine {
+    private documents;
+    private collection;
+    private vaultPath;
+    private collectionRoot;
+    private qmdIndexName?;
+    /** v2.7 — Per-document date index built at ingest time */
+    private dateIndex;
+    /** v2.7 — Per-document preference index built at ingest time */
+    private preferenceIndex;
+    /** v2.7 — Per-document chunk cache for BM25 pre-filtering */
+    private chunkCache;
+    /**
+     * Set the collection name (usually vault name)
+     */
+    setCollection(name: string): void;
+    /**
+     * Set the vault path for file resolution
+     */
+    setVaultPath(vaultPath: string): void;
+    /**
+     * Set the collection root for qmd:// URI resolution
+     */
+    setCollectionRoot(root: string): void;
+    /**
+     * Set qmd index name (defaults to qmd global default when omitted)
+     */
+    setIndexName(indexName?: string): void;
+    /**
+     * Add or update a document in the local cache.
+     * v2.7: also extracts dates, preferences, and chunks at ingest time.
+     * Note: qmd indexing happens via qmd update command
+     */
+    addDocument(doc: Document): void;
+    /**
+     * Remove a document from the local cache
+     */
+    removeDocument(id: string): void;
+    /**
+     * No-op for qmd - indexing is managed externally
+     */
+    rebuildIDF(): void;
+    /**
+     * BM25 search via qmd
+     */
+    search(query: string, options?: SearchOptions): SearchResult[];
+    /**
+     * Vector/semantic search via qmd vsearch
+     */
+    vsearch(query: string, options?: SearchOptions): SearchResult[];
+    /**
+     * Combined search with query expansion (qmd query command)
+     */
+    query(query: string, options?: SearchOptions): SearchResult[];
+    private runQmdQuery;
+    /**
+     * v2.7 — Chunk-level BM25 pre-filtered search. Ranks chunks within each
+     * document by keyword relevance before semantic ranking, so relevant
+     * content deep in long documents isn't missed.
+     *
+     * Returns results with snippets from the best-matching chunks.
+     */
+    chunkPrefilterSearch(query: string, options?: SearchOptions): SearchResult[];
+    /**
+     * v2.7 — Exhaustive threshold-based search for aggregation queries.
+     * Keeps pulling results until relevance drops below threshold.
+     */
+    exhaustiveSearch(query: string, threshold?: number, maxResults?: number): SearchResult[];
+    /**
+     * v2.7 — Get all extracted dates, optionally filtered by document ids.
+     */
+    getDates(documentIds?: string[]): ExtractedDate[];
+    /**
+     * v2.7 — Get all extracted preferences, optionally filtered by document ids.
+     */
+    getPreferences(documentIds?: string[]): ExtractedPreference[];
+    /**
+     * v2.7 — Search with automatic strategy selection based on question type.
+     * Classifies the query and routes to the appropriate pipeline.
+     */
+    smartQuery(query: string, options?: SearchOptions): SearchResult[];
+    /**
+     * Convert qmd results to ClawVault SearchResult format
+     */
+    private convertResults;
+    private resolveModifiedAt;
+    private getRecencyFactor;
+    /**
+     * Convert qmd:// URI to file path
+     */
+    private qmdUriToPath;
+    /**
+     * v2.8 — Filter superseded observation lines from snippet text.
+     * Ensures search results prefer the latest version of knowledge.
+     */
+    private stripSupersededFromSnippet;
+    /**
+     * Clean up qmd snippet format
+     */
+    private cleanSnippet;
+    /**
+     * Get all cached documents
+     */
+    getAllDocuments(): Document[];
+    /**
+     * Get document count
+     */
+    get size(): number;
+    /**
+     * Clear the local document cache and all v2.7 indices
+     */
+    clear(): void;
+    /**
+     * Export documents for persistence
+     */
+    export(): {
+        documents: Document[];
+    };
+    /**
+     * Import from persisted data
+     */
+    import(data: {
+        documents: Document[];
+    }): void;
+}
+/**
+ * Find wiki-links in content
+ */
+declare function extractWikiLinks(content: string): string[];
+/**
+ * Find tags in content (#tag format)
+ */
+declare function extractTags(content: string): string[];
+
+declare const OBSERVE_PROVIDERS: readonly ["anthropic", "openai", "gemini"];
+declare const OBSERVER_COMPRESSION_PROVIDERS: readonly ["anthropic", "openai", "gemini", "openai-compatible", "ollama"];
+declare const THEMES: readonly ["neural", "minimal", "none"];
+declare const CONTEXT_PROFILES: readonly ["default", "planning", "incident", "handoff", "auto"];
+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 ManagedConfigKey = 'name' | 'categories' | 'theme' | 'observe.model' | 'observe.provider' | 'observer.compression.provider' | 'observer.compression.model' | 'observer.compression.baseUrl' | 'observer.compression.apiKey' | 'context.maxResults' | 'context.defaultProfile' | 'graph.maxHops' | 'inject.maxResults' | 'inject.useLlm' | 'inject.scope';
+interface RouteRule {
+    pattern: string;
+    target: string;
+    priority: number;
+}
+declare const SUPPORTED_CONFIG_KEYS: ManagedConfigKey[];
+declare function listConfig(vaultPath: string): Record<string, unknown>;
+declare function getConfig(vaultPath: string): Record<string, unknown>;
+declare function getConfigValue(vaultPath: string, key: ManagedConfigKey): unknown;
+declare function setConfigValue(vaultPath: string, key: ManagedConfigKey, value: unknown): {
+    value: unknown;
+    config: Record<string, unknown>;
+};
+declare function resetConfig(vaultPath: string): Record<string, unknown>;
+declare function listRouteRules(vaultPath: string): RouteRule[];
+declare function addRouteRule(vaultPath: string, pattern: string, target: string): RouteRule;
+declare function removeRouteRule(vaultPath: string, pattern: string): boolean;
+declare function matchRouteRule(text: string, routes: RouteRule[]): RouteRule | null;
+declare function testRouteRule(vaultPath: string, text: string): RouteRule | null;
+
+/**
+ * Transition Ledger for ClawVault
+ * Logs task status transitions to JSONL files and supports querying.
+ */
+
+interface TransitionEvent {
+    task_id: string;
+    agent_id: string;
+    from_status: TaskStatus;
+    to_status: TaskStatus;
+    timestamp: string;
+    confidence: number;
+    cost_tokens: number | null;
+    reason: string | null;
+}
+declare function isRegression(from: TaskStatus, to: TaskStatus): boolean;
+/**
+ * Append a transition event to the ledger
+ */
+declare function appendTransition(vaultPath: string, event: TransitionEvent): void;
+/**
+ * Build a transition event from context
+ */
+declare function buildTransitionEvent(taskId: string, fromStatus: TaskStatus, toStatus: TaskStatus, options?: {
+    confidence?: number;
+    reason?: string;
+}): TransitionEvent;
+/**
+ * Read all transition events from all ledger files
+ */
+declare function readAllTransitions(vaultPath: string): TransitionEvent[];
+/**
+ * Query transitions with filters
+ */
+declare function queryTransitions(vaultPath: string, filters?: {
+    taskId?: string;
+    agent?: string;
+    failed?: boolean;
+}): TransitionEvent[];
+/**
+ * Count blocked transitions for a task
+ */
+declare function countBlockedTransitions(vaultPath: string, taskId: string): number;
+/**
+ * Format transitions as a table string
+ */
+declare function formatTransitionsTable(events: TransitionEvent[]): string;
+
+interface CompressorOptions {
+    provider?: CompressionProvider;
+    model?: string;
+    baseUrl?: string;
+    apiKey?: string;
+    now?: () => Date;
+    fetchImpl?: typeof fetch;
+}
+type CompressionProvider = 'anthropic' | 'openai' | 'gemini' | 'openai-compatible' | 'ollama';
+declare class Compressor {
+    private readonly provider?;
+    private readonly model?;
+    private readonly baseUrl?;
+    private readonly apiKey?;
+    private readonly now;
+    private readonly fetchImpl;
+    constructor(options?: CompressorOptions);
+    compress(messages: string[], existingObservations: string): Promise<string>;
+    private resolveProvider;
+    private resolveConfiguredProvider;
+    private resolveProviderFromEnv;
+    private resolveModel;
+    private resolveApiKey;
+    private resolveBaseUrl;
+    private readEnvValue;
+    private buildPrompt;
+    private buildOpenAICompatibleUrl;
+    private buildOpenAICompatibleHeaders;
+    private extractOpenAIContent;
+    private callAnthropic;
+    private callOpenAI;
+    private callOpenAICompatible;
+    private callGemini;
+    private normalizeLlmOutput;
+    /**
+     * Fix wiki-link corruption from LLM compression.
+     * LLMs often fuse preceding word fragments into wiki-links during rewriting:
+     *   "reque[[people/pedro]]" → "[[people/pedro]]"
+     *   "Linke[[agents/zeca]]" → "[[agents/zeca]]"
+     *   "taske[[people/pedro]]a" → "[[people/pedro]]"
+     * Also fixes trailing word fragments fused after closing brackets.
+     */
+    private sanitizeWikiLinks;
+    private enforceImportanceRules;
+    private enforceImportanceForRecord;
+    private fallbackCompression;
+    private mergeObservations;
+    private mergeRecord;
+    private renderSections;
+    private inferImportance;
+    private inferConfidence;
+    private isCriticalContent;
+    private isNotableContent;
+    private inferTaskType;
+    private normalizeText;
+    private extractDate;
+    private extractTime;
+    private formatDate;
+    private formatTime;
+    private clamp01;
+}
+
+interface ObserverCompressor {
+    compress(messages: string[], existingObservations: string): Promise<string>;
+}
+interface ObserverReflector {
+    reflect(observations: string): string;
+}
+interface ObserverOptions {
+    tokenThreshold?: number;
+    reflectThreshold?: number;
+    model?: string;
+    compressionProvider?: CompressionProvider;
+    compressionBaseUrl?: string;
+    compressionApiKey?: string;
+    compressor?: ObserverCompressor;
+    reflector?: ObserverReflector;
+    now?: () => Date;
+    rawCapture?: boolean;
+    extractTasks?: boolean;
+}
+interface ObserverProcessOptions {
+    source?: string;
+    sessionKey?: string;
+    transcriptId?: string;
+    timestamp?: Date;
+}
+declare class Observer {
+    private readonly vaultPath;
+    private readonly tokenThreshold;
+    private readonly reflectThreshold;
+    private readonly compressor;
+    private readonly reflector;
+    private readonly now;
+    private readonly rawCapture;
+    private readonly router;
+    private pendingMessages;
+    private pendingRouteContext;
+    private observationsCache;
+    private lastRoutingSummary;
+    constructor(vaultPath: string, options?: ObserverOptions);
+    processMessages(messages: string[], options?: ObserverProcessOptions): Promise<void>;
+    /**
+     * Force-flush pending messages regardless of threshold.
+     * Call this on session end to capture everything.
+     */
+    flush(): Promise<{
+        observations: string;
+        routingSummary: string;
+    }>;
+    getObservations(): string;
+    private estimateTokens;
+    private readTodayObservations;
+    private readObservationForDate;
+    private readObservationFile;
+    private writeObservationFile;
+    private deduplicateObservationMarkdown;
+    private persistRawMessages;
+    private sanitizeSource;
+    private mergeRouteContext;
+}
+
+interface ObserveCursorEntry {
+    lastObservedOffset: number;
+    lastObservedAt: string;
+    sessionKey: string;
+    lastFileSize: number;
+}
+type ObserveCursorStore = Record<string, ObserveCursorEntry>;
+interface ActiveObserveOptions {
+    vaultPath: string;
+    agentId?: string;
+    minNewBytes?: number;
+    sessionsDir?: string;
+    dryRun?: boolean;
+    threshold?: number;
+    reflectThreshold?: number;
+    model?: string;
+    extractTasks?: boolean;
+    maxSessions?: number;
+}
+interface ActiveObservationCandidate {
+    sessionId: string;
+    sessionKey: string;
+    sourceLabel: string;
+    filePath: string;
+    fileSize: number;
+    startOffset: number;
+    newBytes: number;
+    thresholdBytes: number;
+}
+interface ActiveObservationFailure {
+    sessionId: string;
+    sessionKey: string;
+    sourceLabel: string;
+    error: string;
+}
+interface ActiveObserveResult {
+    agentId: string;
+    sessionsDir: string;
+    checkedSessions: number;
+    candidateSessions: number;
+    observedSessions: number;
+    cursorUpdates: number;
+    dryRun: boolean;
+    totalNewBytes: number;
+    observedNewBytes: number;
+    routedCounts: Record<string, number>;
+    failedSessionCount: number;
+    failedSessions: ActiveObservationFailure[];
+    candidates: ActiveObservationCandidate[];
+}
+interface ObserverStalenessResult {
+    staleCount: number;
+    oldestMs: number;
+    newestMs: number;
+}
+type MinimalObserver = Pick<Observer, 'processMessages' | 'flush'>;
+type ObserverFactory = (vaultPath: string, options: ObserverOptions) => MinimalObserver;
+interface ActiveObserveDependencies {
+    createObserver?: ObserverFactory;
+    now?: () => Date;
+}
+interface ObserverStalenessOptions {
+    sessionsDir?: string;
+    now?: () => Date;
+}
+declare function getScaledObservationThresholdBytes(fileSizeBytes: number): number;
+declare function getObserverStaleness(vaultPath: string, options?: ObserverStalenessOptions): ObserverStalenessResult;
+declare function parseSessionSourceLabel(sessionKey: string): string;
+declare function observeActiveSessions(options: ActiveObserveOptions, dependencies?: ActiveObserveDependencies): Promise<ActiveObserveResult>;
+
+interface ReflectorOptions {
+    now?: () => Date;
+}
+declare class Reflector {
+    private readonly now;
+    constructor(options?: ReflectorOptions);
+    reflect(observations: string): string;
+    private buildCutoffDate;
+    private parseDate;
+    private parseSections;
+    private renderSections;
+    private normalizeText;
+    private isSimilar;
+}
+
+interface SessionWatcherOptions {
+    ignoreInitial?: boolean;
+    debounceMs?: number;
+    flushThresholdChars?: number;
+}
+declare class SessionWatcher {
+    private readonly watchPath;
+    private readonly observer;
+    private readonly ignoreInitial;
+    private readonly debounceMs;
+    private readonly flushThresholdChars;
+    private watcher;
+    private fileOffsets;
+    private pendingPaths;
+    private debounceTimer;
+    private processingQueue;
+    private bufferedChars;
+    constructor(watchPath: string, observer: Observer, options?: SessionWatcherOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private scheduleDrain;
+    private drainPendingPaths;
+    private consumeFile;
+    private primeInitialOffsets;
+    private collectFiles;
+}
+
+declare function parseSessionFile(filePath: string): string[];
+
+interface ArchiveObservationsOptions {
+    olderThanDays?: number;
+    dryRun?: boolean;
+    now?: () => Date;
+}
+interface ArchiveObservationsResult {
+    scanned: number;
+    archived: number;
+    skipped: number;
+    dryRun: boolean;
+    archivedDates: string[];
+}
+declare function archiveObservations(vaultPath: string, options?: ArchiveObservationsOptions): ArchiveObservationsResult;
+
+interface ReflectOptions {
+    vaultPath: string;
+    days?: number;
+    dryRun?: boolean;
+    now?: () => Date;
+}
+interface ReflectResult {
+    processedWeeks: number;
+    writtenWeeks: number;
+    dryRun: boolean;
+    files: string[];
+    archive: ArchiveObservationsResult | null;
+}
+declare function runReflection(options: ReflectOptions): Promise<ReflectResult>;
+
+/**
+ * ClawVault 🐘 — An Elephant Never Forgets
+ *
+ * Structured memory system for AI agents with Obsidian-compatible markdown
+ * and embedded semantic search.
+ *
+ * @example
+ * ```typescript
+ * import { ClawVault, createVault, findVault } from 'clawvault';
+ *
+ * // Create a new vault
+ * const vault = await createVault('./my-memory');
+ *
+ * // Store a memory
+ * await vault.store({
+ *   category: 'decisions',
+ *   title: 'Use ClawVault',
+ *   content: 'Decided to use ClawVault for memory management.'
+ * });
+ *
+ * // Search memories
+ * const results = await vault.find('memory management');
+ * console.log(results);
+ * ```
+ */
+
+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, ExtractedDate, ExtractedPreference, HandoffDocument, type ManagedConfigKey, MemoryType, type ObserveCursorEntry, type ObserveCursorStore, type ObserveProvider, Observer, type ObserverCompressionProvider, type ObserverCompressor, type ObserverOptions, type ObserverReflector, type ObserverStalenessResult, QMD_INSTALL_COMMAND, QMD_INSTALL_URL, QmdUnavailableError, type ReflectOptions, type ReflectResult, Reflector, type ReflectorOptions, type ReweaveOptions, type ReweaveResult, type RouteRule, SUPPORTED_CONFIG_KEYS, SearchEngine, SearchOptions, SearchResult, SessionRecap, SessionWatcher, type SessionWatcherOptions, StoreOptions, type SupersessionRecord, SyncOptions, SyncResult, type Theme, type TransitionEvent, VERSION, VaultConfig, addRouteRule, appendTransition, archiveObservations, bm25RankChunks, buildTransitionEvent, classifyQuestion, countBlockedTransitions, createVault, entitySimilarity, extractDates, extractEntities, extractPreferences, extractTags, extractWikiLinks, filterSuperseded, findVault, formatTransitionsTable, getConfig, getConfigValue, getObserverStaleness, getScaledObservationThresholdBytes, getSupersessionInfo, hasQmd, isKnowledgeUpdate, isRegression, isSuperseded, listConfig, listRouteRules, matchRouteRule, observeActiveSessions, parseSessionFile, parseSessionSourceLabel, qmdEmbed, qmdUpdate, queryTransitions, readAllTransitions, registerCommanderCommands, registerReweaveCommand, removeRouteRule, resetConfig, reweave, reweaveCommand, runReflection, sentenceChunk, setConfigValue, stripSupersededObservations, testRouteRule };