wotann 0.5.0

package/dist/memory/store.d.ts

@@ -0,0 +1,1090 @@
+/**
+ * SQLite memory store with FTS5 full-text search.
+ * 8-layer unified memory system per §14 and MEMORY_ARCHITECTURE.md.
+ *
+ * LAYERS:
+ * 1. Auto-Capture — every tool call, file read, command output
+ * 2. Core Blocks — user/feedback/project/reference/cases/patterns/decisions/issues
+ * 3. Working Memory — current session state, recent context
+ * 4. Knowledge Graph — entity relationships, bi-temporal facts
+ * 5. Archival — long-term storage with temporal decay
+ * 6. Recall — retrieval with skeptical verification
+ * 7. Team Memory — shared across agents/sessions
+ * 8. Proactive Context — anticipated context based on patterns
+ *
+ * FEATURES:
+ * - FTS5 full-text search across all layers
+ * - Skeptical memory: verify before acting on recalled memories
+ * - Consolidation lock: prevent concurrent autoDream sessions
+ * - Decision log: track architectural/design decisions with rationale
+ * - Temporal decay: older memories get lower relevance scores
+ * - Privacy tags: mark sensitive memories for restricted access
+ */
+import type { MemoryRelationship, MemoryRelationshipKind } from "./relationship-types.js";
+import { type ContextualChunkGenerator, type LlmQuery as ContextualLlmQuery, type BatchOptions as ContextualBatchOptions } from "./contextual-embeddings.js";
+import { type MemPalacePath, type MemPalaceQuery, type LevelCount as PalaceLevelCount } from "./mem-palace.js";
+import { type TemporalFilter } from "./extended-search-types.js";
+import { type Entity } from "./entity-types.js";
+import { type BiTemporalEdge, type BiTemporalInsertOptions, type SnapshotQuery } from "./bi-temporal-edges.js";
+import { type IndexerOptions } from "./incremental-indexer.js";
+import { type Retriever, type Reranker, type HybridRetrievalConfig, type HybridResult } from "./hybrid-retrieval.js";
+import { type MemvidFile, type MemvidExportOptions, type MemvidImportResult } from "./memvid-backend.js";
+import { type CacheStats as SemanticCacheStats, type SemanticCacheOptions } from "./semantic-cache.js";
+import { type BenchmarkSuite } from "./memory-benchmark.js";
+import { MemoryToolkit, type ToolDefinition, type ToolCallResult } from "./memory-tools.js";
+import { type TEMPRHit, type TEMPRCandidate } from "./tempr.js";
+import { type CrossEncoder } from "./cross-encoder.js";
+import { type SqliteVecBackend } from "./sqlite-vec-backend.js";
+import { type EmbeddingProfile } from "./embedding-profiles.js";
+import { type RetrievalMode, type RetrievalModeOptions, type RetrievalModeResult } from "./retrieval-registry.js";
+import type { MemoryProvider } from "./pluggable-provider.js";
+export type MemoryLayer = "auto_capture" | "core_blocks" | "working" | "knowledge_graph" | "archival" | "recall" | "team" | "proactive";
+export type MemoryBlockType = "user" | "feedback" | "project" | "reference" | "cases" | "patterns" | "decisions" | "issues";
+export type MemorySourceType = "user_input" | "tool_output" | "agent_decision" | "codebase_observation" | "auto_capture" | "team_sync" | "dream_cycle";
+export interface MemoryProvenance {
+    readonly sourceType: MemorySourceType;
+    readonly sourceFile?: string;
+    readonly sourceCommand?: string;
+    readonly sessionId?: string;
+    readonly verified: boolean;
+    readonly verifiedAt?: string;
+    readonly verifiedBy?: string;
+}
+export type VerificationStatus = "verified" | "stale" | "unverified" | "conflicting";
+export interface VerificationResult {
+    readonly entryId: string;
+    readonly previousStatus: VerificationStatus;
+    readonly newStatus: VerificationStatus;
+    readonly freshnessScore: number;
+    readonly confidenceLevel: number;
+    readonly reason: string;
+}
+export interface MemoryEntry {
+    readonly id: string;
+    readonly layer: MemoryLayer;
+    readonly blockType: MemoryBlockType;
+    readonly key: string;
+    readonly value: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly sessionId?: string;
+    readonly verified: boolean;
+    readonly confidence?: number;
+    readonly tags?: string;
+    readonly sourceType?: MemorySourceType;
+    readonly sourceFile?: string;
+    readonly freshnessScore: number;
+    readonly confidenceLevel: number;
+    readonly lastVerifiedAt?: string;
+    readonly verificationStatus: VerificationStatus;
+    /** MemPalace-style domain partition (wing). E.g., "memory", "auth", "deploy" */
+    readonly domain?: string;
+    /** MemPalace-style topic partition (room). E.g., "architecture", "bug-fix", "config" */
+    readonly topic?: string;
+    /**
+     * Dual-timestamp (Phase H) — when this memory was RECORDED (unix ms).
+     * Always present after ingest; populated by deriveIngestTimestamps.
+     */
+    readonly documentDate?: number;
+    /**
+     * Dual-timestamp (Phase H) — when the event the memory refers to
+     * HAPPENED (unix ms). May equal documentDate when no hint was parsed;
+     * check eventDateSource to distinguish extracted from fallback.
+     */
+    readonly eventDate?: number;
+    /** Uncertainty in eventDate as ±ms. */
+    readonly eventDateUncertaintyMs?: number;
+    /**
+     * How eventDate was derived. Honest values:
+     *   - "extracted: \"yesterday\""        (from content)
+     *   - "fallback-to-documentDate"        (no hint parsed)
+     *   - "user-supplied"                   (caller overrode)
+     *   - ""                                (legacy row, pre-Phase-H)
+     */
+    readonly eventDateSource?: string;
+}
+export interface MemorySearchResult {
+    readonly entry: MemoryEntry;
+    readonly score: number;
+    readonly snippet: string;
+    readonly matchType?: "fts" | "vector" | "hybrid";
+}
+export interface VectorSearchResult {
+    readonly entryId: string;
+    readonly similarity: number;
+    readonly entry: MemoryEntry;
+}
+export interface ContradictionResult {
+    readonly existingEntry: MemoryEntry;
+    readonly newValue: string;
+    readonly conflictType: "direct" | "indirect" | "temporal";
+    readonly confidence: number;
+}
+export interface KnowledgeNode {
+    readonly id: string;
+    readonly entity: string;
+    readonly entityType: string;
+    readonly properties: Record<string, string>;
+    readonly validFrom: string;
+    readonly validTo?: string;
+}
+export interface TeamMemoryRecord {
+    readonly id: string;
+    readonly agentId: string;
+    readonly key: string;
+    readonly value: string;
+    readonly shared: boolean;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export interface TeamMemorySnapshot {
+    readonly exportedAt: string;
+    readonly entries: readonly TeamMemoryRecord[];
+}
+export interface TeamMemorySyncResult {
+    readonly inserted: number;
+    readonly updated: number;
+    readonly skipped: number;
+    readonly conflicts: readonly string[];
+}
+export interface AutoCaptureEntry {
+    readonly id: number;
+    readonly eventType: string;
+    readonly toolName?: string;
+    readonly content: string;
+    readonly sessionId?: string;
+    readonly createdAt: string;
+}
+/**
+ * Result of a call to `MemoryStore.consolidateAutoCaptures`. Surfaces the
+ * work done in the last pass so callers (daemon heartbeat, close(), tests)
+ * can log/assert without re-querying the DB.
+ */
+export interface ConsolidationReport {
+    /** Auto-capture rows read in this pass. */
+    readonly read: number;
+    /** Rows that produced at least one observation and were routed to memory_entries. */
+    readonly routed: number;
+    /** Count by memory_entries block type. Keys: decisions/feedback/project/issues/cases. */
+    readonly byBlock: Readonly<Record<string, number>>;
+    /** Rows that matched no pattern and produced no observation. */
+    readonly classificationFailed: number;
+    /** Rows mirrored into the decision_log table. Sub-count of `byBlock.decisions`. */
+    readonly decisionLogged: number;
+}
+export declare class MemoryStore implements MemoryProvider {
+    /** MemoryProvider contract: stable identifier for the SQLite + FTS5 backend. */
+    readonly name = "sqlite";
+    /** MemoryProvider contract: semver of the MemoryStore implementation. */
+    readonly version = "1.0.0";
+    private readonly db;
+    private readonly dbPath;
+    /**
+     * Optional synchronous contextual-retrieval generator. When set, insert()
+     * prepends a ~50-token chunk-context to the FTS-indexed value per
+     * Anthropic's 2024 contextual retrieval (+30-50% recall on paraphrase).
+     * Pure sync — LLM-backed generators should pre-render async context and
+     * capture it in the closure. Null = disabled (honest pass-through).
+     */
+    private contextGenerator;
+    /** Install or clear the contextual-embedding generator used by insert(). */
+    setContextGenerator(gen: ((key: string, value: string) => string) | null): void;
+    /**
+     * V9 T1.3 — Optional sqlite-vec backend for native dense-vector
+     * retrieval in TEMPR's vector channel. Null until `attachVectorBackend()`
+     * lazy-initializes it (or if the native extension isn't loadable).
+     * When non-null, `temprSearch()` uses it as the default `opts.vectorBackend`
+     * instead of the FTS5+cosine fallback.
+     *
+     * Population is the caller's responsibility — use `upsertEmbedding()`
+     * below as new entries arrive with their embeddings. See V9 T1.3 for
+     * the full persistent-index design.
+     */
+    private vectorBackend;
+    /**
+     * V9 T1.4 — Optional ONNX-backed cross-encoder for TEMPR rerank.
+     * Upgraded from the heuristic baseline via `attachOnnxCrossEncoder()`
+     * (async — session load is async). `temprSearch()` uses this as the
+     * default `opts.crossEncoder` when caller doesn't override.
+     */
+    private defaultCrossEncoder;
+    constructor(dbPath: string);
+    /**
+     * MemoryProvider contract. Idempotent — schema is created in the
+     * constructor via `initializeSchema()`, so this is a no-op for
+     * already-constructed instances. Exposed for contract conformance
+     * with async backends that defer connection/table creation.
+     */
+    initialize(): void;
+    /**
+     * V9 T1.3 — Attach the sqlite-vec backend. Call once post-construction
+     * when the caller knows their embedding dimension. Safe to call
+     * multiple times — idempotent (attaches once). When sqlite-vec isn't
+     * available, silently keeps `vectorBackend: null` so `temprSearch`
+     * falls back to the FTS5+cosine path.
+     *
+     * @param dimensions Embedding dimension (384 for MiniLM-L-6, 768 for L-12).
+     * @param tableName Optional vec0 table name override.
+     * @returns true when the backend was attached; false on unavailability.
+     */
+    attachVectorBackend(dimensions: number, tableName?: string): boolean;
+    /**
+     * V9 T1.4 — Upgrade the default cross-encoder from heuristic to
+     * ONNX-backed MiniLM rerank. Async because `loadMiniLmSession`
+     * loads the native `onnxruntime-node` session asynchronously.
+     * Safe to call at any time — `temprSearch` reads `this.defaultCrossEncoder`
+     * per-call so the swap takes effect on the next invocation.
+     *
+     * @param modelPath Optional override for the MiniLM .onnx file.
+     * @returns true when ONNX was attached; false when runtime/model absent.
+     */
+    attachOnnxCrossEncoder(modelPath?: string): Promise<boolean>;
+    /**
+     * V9 T1.3 companion — push an embedding into the vec0 index for a
+     * given memory entry. No-op when the backend isn't attached. Caller
+     * generates the embedding using its chosen embedder so the store
+     * doesn't pull an embedder dependency. Idempotent on duplicate id.
+     *
+     * Asymmetric-prefix port (LightRAG `embedding-prefixes`): the caller
+     * is responsible for applying the doc prefix BEFORE generating the
+     * vector. A typical wiring looks like:
+     *
+     *   import { applyDocPrefix, getEmbeddingProfile,
+     *            isAsymmetricEmbeddingsEnabled } from "./embedding-profiles.js";
+     *   const profile = isAsymmetricEmbeddingsEnabled()
+     *     ? getEmbeddingProfile(modelName)
+     *     : null;
+     *   const vec = await embed(applyDocPrefix(profile, entry.value));
+     *   store.upsertEmbedding(entry.id, vec);
+     *
+     * NOTE: turning the env-var gate ON for an existing index that was
+     * built without prefixes will skew similarity scores at query time.
+     * Rebuild the vec_embeddings table after enabling. See
+     * embedding-profiles.ts header for the full rationale.
+     */
+    upsertEmbedding(id: string, vector: readonly number[]): boolean;
+    /**
+     * Accessor for the attached vectorBackend (null when not attached).
+     * Used by TEMPR-aware callers to pass `opts.vectorBackend` explicitly
+     * OR to confirm availability before generating an embedding. See
+     * `temprSearch()` for default-injection behavior.
+     */
+    getVectorBackend(): SqliteVecBackend | null;
+    /** Accessor for the default cross-encoder. Callers can override via
+     * `temprSearch`'s `opts.crossEncoder`. */
+    getDefaultCrossEncoder(): CrossEncoder;
+    private initializeSchema;
+    /** @internal Migration helper — ONLY called with hardcoded literals.
+     *
+     * Wave 6.5-UU (H-23) — wrap PRAGMA + ALTER inside an explicit transaction
+     * so a SIGKILL between the existence check and the column add can't
+     * leave the DB half-migrated (column added but no committed marker).
+     * SQLite is internally transactional per-statement, but the *combination*
+     * of PRAGMA table_info + ALTER TABLE is not — without the transaction
+     * wrapper a crash between the two could let the next call see an
+     * already-added column and skip a follow-up step that depends on the
+     * write being committed end-to-end.
+     *
+     * Identifier validation runs BEFORE entering the transaction so a bad
+     * identifier doesn't open and immediately roll back a tx for nothing.
+     */
+    private migrateAddColumn;
+    captureEvent(eventType: string, content: string, toolName?: string, sessionId?: string): void;
+    getRecentCaptures(sessionId: string, limit?: number): readonly Record<string, unknown>[];
+    getAutoCaptureEntries(limit?: number, sessionId?: string): readonly AutoCaptureEntry[];
+    /**
+     * Return auto_capture entries that have NOT yet been routed into the
+     * structured memory_entries / decision_log tables. Phase B Bug #1 fix.
+     *
+     * Consolidation uses `consolidated_at IS NULL` as the work-queue marker.
+     * Once a row has been processed by `consolidateAutoCaptures()`, its
+     * `consolidated_at` is stamped with the current ISO-8601 timestamp so
+     * it won't be re-read on the next pass.
+     */
+    getUnconsolidatedAutoCaptures(limit?: number): readonly AutoCaptureEntry[];
+    /**
+     * Mark a set of auto_capture rows as consolidated. Called by
+     * `consolidateAutoCaptures()` once their observations have been inserted
+     * into `memory_entries` / `decision_log`. Idempotent.
+     */
+    markAutoCapturesConsolidated(ids: readonly number[]): void;
+    /**
+     * Route unconsolidated auto_capture rows into structured memory tables
+     * (memory_entries + decision_log). Phase B Bug #1 fix.
+     *
+     * Bug: `.wotann/memory.db` showed 1,990 rows in `auto_capture` but 0
+     * in `memory_entries`, `knowledge_nodes`, and `decision_log` — every
+     * observation was silently dumped into the raw capture table with no
+     * structured routing. Session-end extraction ran from
+     * `session.messages` (not from the DB), so daemon lifecycle events
+     * never produced structured entries.
+     *
+     * This method reads from the auto_capture table itself, runs each row
+     * through the caller-supplied extractor (normally
+     * `ObservationExtractor.extractFromCaptures`), maps the observation
+     * type to the right MemoryBlockType, and inserts into memory_entries.
+     * Decisions are ALSO mirrored into decision_log for the decision
+     * ledger.
+     *
+     * Classification failures (row content matches no pattern) emit a
+     * `classification_failed` event via the optional callback — never
+     * silently swallowed. Quality bar from feedback_wotann_quality_bars.
+     *
+     * @returns a report: how many routed per bucket + how many failed classification.
+     */
+    consolidateAutoCaptures(extractFn: (captures: readonly AutoCaptureEntry[]) => readonly {
+        readonly type: "decision" | "preference" | "milestone" | "problem" | "discovery";
+        readonly assertion: string;
+        readonly confidence: number;
+        readonly sourceIds: readonly number[];
+        readonly domain?: string;
+        readonly topic?: string;
+    }[], options?: {
+        readonly batchSize?: number;
+        readonly onClassificationFailed?: (entry: AutoCaptureEntry, reason: string) => void;
+    }): ConsolidationReport;
+    /** Map observation type to the right memory block. Isolated for testability. */
+    private observationTypeToBlockType;
+    /** Store a raw verbatim chunk, optionally linked to a structured memory entry. */
+    storeVerbatim(rawContent: string, options?: {
+        readonly entryId?: string;
+        readonly contentType?: string;
+        readonly sessionId?: string;
+        readonly domain?: string;
+        readonly topic?: string;
+    }): string;
+    /** Search verbatim drawers via FTS5. Returns raw content with match scores. */
+    searchVerbatim(query: string, limit?: number): readonly {
+        id: string;
+        rawContent: string;
+        entryId: string | null;
+        score: number;
+        domain: string;
+        topic: string;
+    }[];
+    /** Get the raw verbatim content linked to a structured memory entry. */
+    getVerbatimForEntry(entryId: string): readonly {
+        id: string;
+        rawContent: string;
+        contentType: string;
+    }[];
+    /** Count of verbatim entries. */
+    getVerbatimCount(): number;
+    insert(entry: Omit<MemoryEntry, "createdAt" | "updatedAt">): void;
+    replace(id: string, key: string, value: string): void;
+    archive(id: string): void;
+    /**
+     * MemoryProvider contract: structured update of an existing entry.
+     * Builds a dynamic UPDATE with only the supplied fields, preserving
+     * every other column. Silent no-op when `updates` is empty or the id
+     * does not exist — matches `InMemoryProvider.update` semantics.
+     *
+     * NOTE: separate from `replace()` which is the legacy key/value-only
+     * mutation used by `memoryReplace()`. `update()` additionally supports
+     * `verified` and `confidence` columns required by the interface.
+     */
+    update(id: string, updates: {
+        key?: string;
+        value?: string;
+        verified?: boolean;
+        confidence?: number;
+    }): void;
+    /**
+     * MemoryProvider contract: hard-delete by id. Distinct from
+     * `archive()` (soft-delete via the `archived` column). Hard-delete
+     * cascades to FTS5 shadow table via SQLite foreign-key triggers.
+     */
+    delete(id: string): void;
+    /**
+     * MemoryProvider contract: total count of non-archived entries.
+     * Thin alias over `getEntryCount()` so conforming callers have a
+     * stable name across providers.
+     */
+    count(): number;
+    /**
+     * MemoryProvider contract: basic liveness probe. Issues a trivial
+     * `SELECT 1` to confirm the SQLite handle is open and responsive.
+     * Returns false on any exception rather than throwing.
+     */
+    healthCheck(): boolean;
+    getById(id: string): MemoryEntry | null;
+    getByLayer(layer: MemoryLayer): readonly MemoryEntry[];
+    getByBlock(blockType: MemoryBlockType): readonly MemoryEntry[];
+    setWorkingMemory(sessionId: string, key: string, value: string, importance?: number): void;
+    getWorkingMemory(sessionId: string): readonly {
+        key: string;
+        value: string;
+        importance: number;
+    }[];
+    clearWorkingMemory(sessionId: string): void;
+    /**
+     * Phase 2 P1-M7: typed-entity graph population.
+     *
+     * Validates a structured entity against `entity-types.EntitySchema`
+     * (person / project / file / concept / event / goal / skill / tool)
+     * and inserts it into `knowledge_nodes`. If a node with the same
+     * entity+type already exists, the existing id is returned rather
+     * than duplicated. Remaining fields are serialized into the
+     * properties JSON payload so downstream consumers can reconstruct
+     * the typed entity.
+     *
+     * Exists specifically to fix the "49-byte empty KG" bug: callers
+     * that already hold a validated Entity can push it to the graph
+     * without re-typing the free-form API.
+     */
+    recordEntity(entity: Entity): string;
+    /**
+     * Phase 2 P1-M7: batch entity population. Parses each entity, skips
+     * invalid rows (returning them in `skipped`), inserts the rest in a
+     * single transaction.
+     */
+    recordEntities(entities: readonly Entity[]): {
+        readonly inserted: readonly {
+            entity: Entity;
+            nodeId: string;
+        }[];
+        readonly skipped: readonly {
+            entity: Entity;
+            reason: string;
+        }[];
+    };
+    /**
+     * Phase 2 P1-M7: heuristic relationship materialization.
+     *
+     * Given two memory entries, classify the relationship between them
+     * using the heuristic classifier (no LLM call) and, when confident,
+     * insert a knowledge_edges row linking their knowledge_nodes.
+     *
+     * Returns the edge id when inserted, or null when the classifier
+     * emits no relationship (or confidence is below the threshold).
+     */
+    recordHeuristicRelationship(fromNodeId: string, toNodeId: string, predecessorContent: string, successorContent: string, minConfidence?: number): Promise<string | null>;
+    /**
+     * Phase 2 P1-M7: follow an `updates`-relationship chain from the
+     * given rootId and return the id of the most recent node in that
+     * chain. Delegates to relationship-types.resolveLatest so callers
+     * don't have to import both modules. Used for "what is the CURRENT
+     * version of fact X?" queries.
+     */
+    resolveLatestRelationship(rels: readonly MemoryRelationship[], rootId: string): string;
+    /**
+     * Phase 2 P1-M7: group the relationships attached to a node by kind
+     * (updates / extends / derives / unknown). Delegates to
+     * relationship-types.partitionByKind.
+     */
+    partitionRelationshipsByKind(rels: readonly MemoryRelationship[], nodeId: string): Readonly<Record<MemoryRelationshipKind, readonly MemoryRelationship[]>>;
+    addKnowledgeNode(entity: string, entityType: string, properties?: Record<string, string>): string;
+    addKnowledgeEdge(sourceId: string, targetId: string, relation: string, weight?: number, validFrom?: string): string;
+    /**
+     * Insert a bi-temporal knowledge edge. Both axes are independent:
+     *   - valid_from / valid_to:     when the fact is true in the world
+     *   - recorded_from / recorded_to: when WOTANN knew the fact
+     *
+     * Defaults:
+     *   - valid_from     = options.validFrom ?? now
+     *   - valid_to       = options.validTo ?? null (still valid)
+     *   - recorded_from  = options.recordedFrom ?? now (set automatically
+     *                      on every insert — the "when WOTANN learned it"
+     *                      timestamp is typically right-now)
+     *   - recorded_to    = null (still known)
+     *
+     * Throws ValidationError on malformed dates.
+     */
+    addBiTemporalEdge(sourceId: string, targetId: string, relation: string, options?: BiTemporalInsertOptions): string;
+    /**
+     * Retract an edge on the ingest-time axis (the fact is no longer
+     * known to WOTANN). Optionally also closes the knowledge-time axis
+     * when `factEndedAt` is supplied — use when WOTANN learns a fact was
+     * wrong AND knows when the fact stopped being true.
+     *
+     * The row is NOT deleted — historical queries (queryKnownAt(past))
+     * still see it. This preserves the "WOTANN knew this between dates
+     * X and Y" audit trail that Zep/Graphiti uses for knowledge updates.
+     */
+    retractBiTemporalEdge(edgeId: string, input?: {
+        readonly retractedAt?: string;
+        readonly factEndedAt?: string | null;
+    }): boolean;
+    /**
+     * Fetch a single bi-temporal edge by id. Returns null when missing.
+     * Handles legacy rows (null recorded_from) by falling back to
+     * created_at per the migration spec.
+     */
+    getBiTemporalEdge(edgeId: string): BiTemporalEdge | null;
+    /**
+     * Query edges that were VALID (true in the world) at `date`.
+     * Ignores the ingest-time axis entirely — even retracted edges are
+     * returned if they were valid at the given date.
+     */
+    queryValidAt(date: string): readonly BiTemporalEdge[];
+    /**
+     * Query edges that WOTANN KNEW at `date` on the ingest-time axis.
+     * Ignores the knowledge-time axis — even edges that represent
+     * historical (no-longer-valid) facts are returned if WOTANN knew
+     * about them at the given date.
+     */
+    queryKnownAt(date: string): readonly BiTemporalEdge[];
+    /**
+     * Query edges matching BOTH axes: the fact was true in the world at
+     * `validAt` AND WOTANN knew the fact at `knownAt`. This is the
+     * canonical Zep/Graphiti snapshot query — "what was WOTANN's picture
+     * of the world as of date X?".
+     */
+    querySnapshot(q: SnapshotQuery): readonly BiTemporalEdge[];
+    /**
+     * Replace an edge: invalidate the old one on BOTH axes (fact ended
+     * AND knowledge retracted) and insert a new edge carrying the
+     * successor fact. Returns the new edge id. This is the canonical
+     * Zep/Graphiti contradiction-handling flow: "we used to think X, now
+     * we think Y — the switchover happened at time T".
+     */
+    replaceBiTemporalEdge(oldEdgeId: string, input: {
+        readonly sourceId: string;
+        readonly targetId: string;
+        readonly relation: string;
+        readonly at?: string;
+        readonly weight?: number;
+    }): string | null;
+    /**
+     * Invalidate a knowledge edge by setting its valid_to timestamp.
+     * The edge remains for historical queries but is excluded from active queries.
+     */
+    invalidateKnowledgeEdge(edgeId: string, endedAt?: string): boolean;
+    /**
+     * Get knowledge edges that were active at a specific point in time.
+     * A relationship is active if valid_from <= date AND (valid_to IS NULL OR valid_to > date).
+     */
+    getActiveEdgesAt(date: string): readonly {
+        id: string;
+        sourceId: string;
+        targetId: string;
+        relation: string;
+        weight: number;
+        validFrom: string;
+        validTo: string | null;
+    }[];
+    getRelatedEntities(entity: string, maxDepth?: number): readonly KnowledgeNode[];
+    getKnowledgeGraphSize(): {
+        nodes: number;
+        edges: number;
+    };
+    skepticalSearch(query: string, limit?: number): readonly (MemorySearchResult & {
+        needsVerification: boolean;
+    })[];
+    setTeamMemory(agentId: string, key: string, value: string): void;
+    getTeamMemory(agentId?: string): readonly {
+        agent_id: string;
+        key: string;
+        value: string;
+    }[];
+    getTeamMemoryRecords(agentId?: string): readonly TeamMemoryRecord[];
+    exportTeamMemorySnapshot(agentId?: string): TeamMemorySnapshot;
+    importTeamMemorySnapshot(snapshot: TeamMemorySnapshot): TeamMemorySyncResult;
+    syncTeamMemoryFile(snapshotPath: string, agentId?: string): TeamMemorySyncResult & {
+        exported: number;
+    };
+    getProactiveContext(sessionId: string, currentFile?: string): readonly MemoryEntry[];
+    search(query: string, limit?: number, options?: {
+        readonly domainFilter?: readonly string[];
+    }): readonly MemorySearchResult[];
+    /**
+     * Domain-partitioned search (MemPalace R1).
+     * Filters by domain/topic BEFORE running FTS5, reducing noise by up to 34%.
+     * - domain only: +12% retrieval (MemPalace: 60.9% → 73.1%)
+     * - domain + topic: +34% retrieval (MemPalace: 60.9% → 94.8%)
+     */
+    searchPartitioned(query: string, options?: {
+        readonly domain?: string;
+        readonly topic?: string;
+        readonly limit?: number;
+    }): readonly MemorySearchResult[];
+    /**
+     * Phase 13 Wave-3C — MemPalace-aware search. Gated by MEMORY_PALACE=1
+     * env. When enabled, accepts a MemPalacePath/Query and routes through
+     * searchPartitioned with domain/topic derived from the palace path
+     * (hall → domain, wing[/room] → topic). The palace-style hierarchy
+     * then post-filters results so wing=X/room=Y queries only return
+     * entries recorded under X/Y, not X alone. When MEMORY_PALACE is
+     * unset, falls back to standard search (no regression).
+     */
+    searchPalace(query: string, palace?: MemPalaceQuery, limit?: number): readonly MemorySearchResult[];
+    /**
+     * Phase 2 P1-M7: list every distinct hall currently represented in
+     * memory_entries, derived from the row's domain/topic fields. A hall
+     * is the top-level palace axis ("auth", "deploy", "memory").
+     */
+    palaceListHalls(): readonly string[];
+    /** Phase 2 P1-M7: list wings under a hall. */
+    palaceListWings(hall: string): readonly string[];
+    /** Phase 2 P1-M7: list rooms under a specific wing within a hall. */
+    palaceListRooms(hall: string, wing: string): readonly string[];
+    /**
+     * Phase 2 P1-M7: tree-view of the palace — counts at hall, wing, and
+     * room granularity. Use together with `palaceTreeText()` for a
+     * printable outline.
+     */
+    palaceCountTree(): readonly PalaceLevelCount[];
+    /**
+     * Phase 2 P1-M7: render the palace tree as a printable outline.
+     * Wraps palaceCountTree + palaceRenderTree so TUIs and CLI consumers
+     * can print a quick palace summary without reaching into mem-palace
+     * directly.
+     */
+    palaceTreeText(): string;
+    /**
+     * Phase 2 P1-M7: parse a slash-separated palace path and format it
+     * back out. Kept on MemoryStore so the palace API is discoverable
+     * from a single entry point.
+     */
+    palaceParsePath(pathString: string): MemPalacePath;
+    palaceFormatPath(path: MemPalacePath): string;
+    /**
+     * Convert memory_entries rows to MemPalaceEntry shape. Derives the
+     * palace path from domain/topic fields via the shared
+     * palaceFromStoreFields helper.
+     */
+    private rowsToPalaceEntries;
+    /**
+     * Phase 2 P1-M7: install a ContextualChunkGenerator on this store.
+     * When set, every subsequent insert() will call the generator and
+     * prepend ~50 tokens of context to the indexed value per Anthropic's
+     * contextual retrieval guidelines.
+     *
+     * Thin wrapper over setContextGenerator that accepts the structured
+     * ContextualChunkGenerator type defined in contextual-embeddings.ts.
+     */
+    private asyncContextGenerator;
+    installContextGenerator(generator: ContextualChunkGenerator | null): void;
+    /** Phase 2 P1-M7: retrieve the installed async ContextualChunkGenerator. */
+    getContextGenerator(): ContextualChunkGenerator | null;
+    /**
+     * Phase 2 P1-M7: convenience — wrap an LLM query function as a
+     * ContextualChunkGenerator and install it in one call.
+     */
+    enableContextualRetrieval(llm: ContextualLlmQuery): void;
+    /**
+     * Phase 2 P1-M7: build one contextual chunk (chunk + LLM-derived
+     * context). Exposed for callers that want to precompute chunks
+     * offline before inserting into memory.
+     */
+    buildContextualChunk(chunk: string, document: string, llm: ContextualLlmQuery): Promise<string>;
+    /**
+     * Phase 2 P1-M7: batch version — build multiple contextual chunks
+     * with bounded concurrency.
+     */
+    buildContextualChunksBatch(chunks: readonly string[], document: string, llm: ContextualLlmQuery, options?: ContextualBatchOptions): Promise<readonly string[]>;
+    /**
+     * Phase 13 Wave-3C — extended search modes (Cognee parity). Dispatches
+     * to extended-search-types for non-default modes: temporal-filtered,
+     * summary-only, metadata-only, hybrid-fusion. Default mode falls
+     * through to FTS5 search. Non-default modes return an empty list when
+     * the store has no entries matching the mode's criteria.
+     */
+    searchExtended(query: string, options?: {
+        readonly mode?: "default" | "temporal-filtered" | "summary-only" | "metadata-only" | "hybrid-fusion";
+        readonly limit?: number;
+        readonly temporal?: TemporalFilter;
+        readonly metadata?: Readonly<Record<string, unknown>>;
+        readonly secondaryRanking?: readonly MemorySearchResult[];
+    }): readonly MemorySearchResult[];
+    /**
+     * TEMPR 4-channel parallel retrieval + RRF + cross-encoder rerank.
+     *
+     * Hindsight port (arXiv 2512.12818) — 91.4% LongMemEval-S reference.
+     * Runs 4 canonical channels in parallel over this store:
+     *
+     *   1. VECTOR   — dense retrieval via caller-supplied embedder
+     *                 (falls back to FTS5-equivalent if no embedder)
+     *   2. BM25     — FTS5 lexical match (store.search)
+     *   3. ENTITY   — KG-aware: parses query entity candidates and
+     *                 retrieves entries whose content mentions any
+     *                 related entity (from knowledge_nodes + M7 edges)
+     *   4. TEMPORAL — bi-temporal snapshot: returns entries adjacent
+     *                 to edges valid at `opts.validAt` (leverages M5
+     *                 queryValidAt). When no validAt, falls back to
+     *                 eventDate/documentDate proximity to `opts.now`.
+     *
+     * Failed channels (exceptions from the backing calls) are isolated
+     * — the remaining channels still contribute. A channel that crashes
+     * is captured in `result.channelResults.get(name).error`; the overall
+     * query never crashes.
+     *
+     * Cross-encoder: defaults to the word-overlap heuristic (good
+     * enough for wiring; the real MS MARCO MiniLM lands in P1-M2 via
+     * createCrossEncoderFromFn). Pass `crossEncoder: null` to skip
+     * rerank entirely.
+     *
+     * Per-query isolation: every call constructs a fresh TEMPR handle
+     * over snapshot channel functions — no shared state between calls.
+     */
+    temprSearch(query: string, opts?: {
+        readonly topK?: number;
+        readonly candidatePool?: number;
+        readonly embed?: (text: string) => Promise<readonly number[]>;
+        readonly validAt?: string;
+        readonly now?: number;
+        readonly crossEncoder?: CrossEncoder | null;
+        readonly onChannelError?: (channelName: string, error: Error) => void;
+        /**
+         * Phase 2 P1-M2 (OMEGA): native sqlite-vec backend for the dense
+         * channel. When supplied together with `embed`, the vector
+         * channel uses sqlite-vec's knn() directly instead of the
+         * per-row cosine fallback. When absent, the channel degrades
+         * to the FTS5 + cosine path (honest fallback).
+         */
+        readonly vectorBackend?: {
+            readonly knn: (q: readonly number[], k: number) => readonly {
+                readonly id: string;
+                readonly distance: number;
+            }[];
+        };
+        /**
+         * Asymmetric embedding prefixes (LightRAG `embedding-prefixes`
+         * inspiration). When the caller knows their embedding model name
+         * (e.g. "intfloat/e5-small-v2", "bge-large-en-v1.5"), passing it
+         * here lets the registry resolve the recommended query/doc
+         * prefix pair. Alternatively, pass `embeddingProfile` directly
+         * to override the registry. When NEITHER is supplied AND the
+         * `WOTANN_ASYMMETRIC_EMBEDDINGS` env var is unset, prefixes are
+         * not applied (legacy behavior — symmetric embed for both query
+         * and doc text). See ./embedding-profiles.ts for the rationale
+         * and the index-versioning warning.
+         */
+        readonly embeddingModel?: string;
+        readonly embeddingProfile?: EmbeddingProfile;
+    }): Promise<{
+        readonly hits: readonly (TEMPRHit & {
+            readonly entry: MemoryEntry | null;
+        })[];
+        readonly channelResults: ReadonlyMap<string, {
+            readonly candidates?: readonly TEMPRCandidate[];
+            readonly error?: Error;
+        }>;
+        readonly rerankerApplied: boolean;
+        readonly durationMs: number;
+    }>;
+    /** Get all unique domains in the memory store. */
+    getDomains(): readonly string[];
+    /** Get all unique topics within a domain (or all topics if no domain specified). */
+    getTopics(domain?: string): readonly string[];
+    acquireConsolidationLock(lockId: string): boolean;
+    releaseConsolidationLock(): void;
+    logDecision(decision: {
+        id: string;
+        decision: string;
+        rationale: string;
+        alternatives?: string;
+        constraints?: string;
+        stakeholders?: string;
+        sessionId?: string;
+    }): void;
+    getDecisions(limit?: number): readonly Record<string, unknown>[];
+    memoryReplace(block: MemoryBlockType, key: string, value: string, domain?: string, topic?: string): void;
+    memoryInsert(block: MemoryBlockType, key: string, value: string, domain?: string, topic?: string): void;
+    memoryRethink(entryId: string, newValue: string): MemoryEntry | null;
+    memorySearch(query: string, optionsOrLayers?: readonly MemoryLayer[] | {
+        readonly layers?: readonly MemoryLayer[];
+        readonly domain?: string;
+        readonly topic?: string;
+    }): readonly MemorySearchResult[];
+    memoryArchive(entryId: string): boolean;
+    memoryVerify(entryId: string): MemoryEntry | null;
+    getEntryCount(): number;
+    getLayerStats(): Record<string, number>;
+    private rowToEntry;
+    /**
+     * Store a vector embedding for a memory entry.
+     * Uses trigram-based local embeddings by default (zero API calls).
+     */
+    storeEmbedding(entryId: string, embedding: Float32Array, model?: string): void;
+    /**
+     * Generate a local trigram-based embedding (no API needed).
+     * Not as good as nomic-embed-text but works offline.
+     */
+    generateLocalEmbedding(text: string): Float32Array;
+    /**
+     * Cosine similarity between two embeddings.
+     */
+    private cosineSimilarity;
+    /**
+     * Vector similarity search across all memory entries with embeddings.
+     * Optional domainFilter narrows the candidate set to entries in the specified
+     * domains (MemPalace-style partition). Up to +34% retrieval improvement.
+     */
+    vectorSearch(query: string, limit?: number, options?: {
+        readonly domainFilter?: readonly string[];
+    }): readonly VectorSearchResult[];
+    /**
+     * Hybrid search combining FTS5 (BM25), vector similarity, temporal recency,
+     * and access frequency using Reciprocal Rank Fusion.
+     * Optional domainFilter narrows every signal to entries in the specified domains.
+     */
+    hybridSearch(query: string, limit?: number, options?: {
+        readonly domainFilter?: readonly string[];
+    }): readonly MemorySearchResult[];
+    /**
+     * Phase 2 P1-M7: expose the semantic-cache backend via MemoryStore
+     * so callers can build a deduped retrieval cache without importing
+     * semantic-cache directly. The cache's lifetime is the store's
+     * lifetime; call `clearRetrievalCache()` to reset or
+     * `getRetrievalCacheStats()` to observe.
+     */
+    private retrievalCache;
+    private getRetrievalCache;
+    /**
+     * Phase 2 P1-M7: cached wrapper around search() — returns previously
+     * computed results when the query embedding is near-identical to a
+     * prior miss. Miss falls through to live search, result is cached.
+     */
+    cachedSearch(query: string, limit?: number, options?: Partial<SemanticCacheOptions>): Promise<readonly MemorySearchResult[]>;
+    /** Phase 2 P1-M7: cache observability — hit/miss/eviction counters. */
+    getRetrievalCacheStats(): SemanticCacheStats | null;
+    /** Phase 2 P1-M7: clear the retrieval cache. */
+    clearRetrievalCache(): void;
+    /**
+     * Phase 2 P1-M7: run the LongMemEval-style memory benchmark against
+     * this store. Wires the MemoryBenchmark orphan into MemoryStore —
+     * callers just say `store.runMemoryBenchmark()` and receive a
+     * scored BenchmarkSuite. Optional category lets callers run only a
+     * specific slice (e.g. "adversarial", "partitioned").
+     */
+    runMemoryBenchmark(category?: string): BenchmarkSuite;
+    /**
+     * Phase 2 P1-M7: return a MemoryToolkit bound to this store.
+     *
+     * MemoryToolkit exposes memory_search / memory_replace / memory_insert
+     * as agent-callable tools following the OpenAI function-calling
+     * schema. Before this wire, the toolkit existed (580 LOC with tests)
+     * but no caller instantiated it — agents couldn't actually invoke
+     * memory operations by name.
+     *
+     * The adapter cast is safe because MemoryStore already implements
+     * every method of MemoryToolStoreAdapter with the exact signatures
+     * used by memory-tools.ts.
+     */
+    createAgentToolkit(): MemoryToolkit;
+    /**
+     * Phase 2 P1-M7: fetch the tool definitions (name + schema) for
+     * registering memory ops with a provider that supports function
+     * calling. Convenience so callers don't need to construct a
+     * MemoryToolkit just to read definitions.
+     */
+    getMemoryToolDefinitions(): readonly ToolDefinition[];
+    /**
+     * Phase 2 P1-M7: dispatch a memory tool by name. Returns the result
+     * envelope with success/error + data payload. Agents pass the
+     * tool_name + arguments received from the provider.
+     */
+    dispatchMemoryTool(toolName: string, args: Record<string, unknown>): ToolCallResult;
+    /**
+     * Phase 2 P1-M3: record an ADD-only agent-fact. Delegates to
+     * `recordAgentFact` in `agent-facts.ts`. Honest failure on empty
+     * agentId bubbles up — caller must provide a non-empty identity.
+     */
+    recordAgentFact(fact: import("./agent-facts.js").AgentFact): void;
+    /**
+     * Phase 2 P1-M3: retrieve agent-facts scoped to an agent identity.
+     * Delegates to `retrieveAgentFacts` in `agent-facts.ts`.
+     */
+    retrieveAgentFacts(opts: import("./agent-facts.js").AgentFactsQuery): readonly MemoryEntry[];
+    /**
+     * Phase 2 P1-M7: export all non-archived memory_entries to a
+     * portable MemvidFile (JSON). Useful for sharing memory between
+     * machines or backing up for review.
+     *
+     * Wires the orphan MemvidBackend into the MemoryStore export path.
+     * The returned MemvidFile can be written to disk with
+     * `JSON.stringify(file, null, 2)` or passed to another
+     * store.importFromMemvid() on a different machine.
+     */
+    exportToMemvid(options?: MemvidExportOptions & {
+        readonly outputPath?: string;
+    }): MemvidFile;
+    /**
+     * Phase 2 P1-M7: import entries from a MemvidFile into memory_entries.
+     * Delegates per-entry de-dup to the MemvidBackend then replays
+     * unique entries into the store as core_blocks rows.
+     *
+     * Returns a MemvidImportResult with imported / skipped / duplicate
+     * counts. The import is idempotent-by-key for the memvid layer but
+     * creates fresh memory_entries rows (caller can dedupe via domain
+     * or block_type after the fact).
+     */
+    importFromMemvid(file: MemvidFile): MemvidImportResult;
+    /**
+     * Phase 2 P1-M7: pluggable retriever-chain search.
+     *
+     * Wraps `hybrid-retrieval.hybridSearch`: a generic retriever-framework
+     * with RRF fusion + optional reranker. Complements the existing
+     * `hybridSearch()` (which hard-codes FTS5 + vector + recency + freq)
+     * by letting callers supply arbitrary Retriever / Reranker
+     * combinations.
+     *
+     * Default retrievers: the lexical retriever from hybrid-retrieval.
+     * Callers can pass additional retrievers (e.g. a dense-vector one) or
+     * a reranker via the `config` param.
+     */
+    hybridRetrieverSearch(query: string, config?: Partial<HybridRetrievalConfig> & {
+        readonly limit?: number;
+    }): Promise<HybridResult>;
+    /**
+     * Phase 2 P1-M7: factory for a default lexical retriever. Thin
+     * convenience so callers can build a HybridRetrievalConfig without
+     * importing hybrid-retrieval directly.
+     */
+    createLexicalRetriever(): Retriever;
+    /**
+     * Phase 2 P1-M7: factory for a default vector retriever backed by
+     * a caller-supplied embedding function.
+     */
+    createVectorRetriever(embed: (text: string) => Promise<readonly number[]>): Retriever;
+    /**
+     * Phase 2 P1-M7: reranker used by the retriever-chain API when
+     * supplied. Kept as a pass-through (caller implements their own).
+     */
+    applyReranker(query: string, hits: HybridResult["hits"], reranker: Reranker): Promise<readonly HybridResult["hits"][number][]>;
+    /**
+     * Compute the freshness-adjusted confidence for a memory entry.
+     * confidence = base_confidence * decay(age) * verification_boost
+     */
+    computeFreshness(entry: MemoryEntry): number;
+    /**
+     * Check if a new memory contradicts existing entries.
+     * Uses keyword overlap + sentiment analysis to detect conflicts.
+     */
+    detectContradictions(key: string, value: string): readonly ContradictionResult[];
+    private keywordOverlap;
+    logProvenance(entryId: string, action: string, oldValue: string | null, newValue: string | null, actor?: string, reason?: string): void;
+    getProvenance(entryId: string): readonly Record<string, unknown>[];
+    insertWithProvenance(entry: Omit<MemoryEntry, "createdAt" | "updatedAt">, sourceType: MemorySourceType, sourceFile?: string): {
+        contradictions: readonly ContradictionResult[];
+    };
+    /**
+     * Compute a freshness score for a memory entry using exponential decay.
+     * Score decays based on time since last update, with verified entries
+     * decaying 3x slower than unverified ones.
+     *
+     * Returns a value between 0 and 1.
+     */
+    computeFreshnessScore(entry: MemoryEntry): number;
+    /**
+     * Verify a memory entry against the codebase by checking whether
+     * the source file (if any) still exists and the entry's content
+     * is still relevant. Updates verification status and freshness.
+     */
+    verifyMemoryAgainstCodebase(entryId: string, workspaceDir: string): VerificationResult;
+    /**
+     * Batch-refresh freshness scores for all non-archived entries.
+     * Returns the number of entries updated.
+     */
+    refreshAllFreshnessScores(): number;
+    /**
+     * Get entries that need verification (stale or unverified with low freshness).
+     */
+    getEntriesNeedingVerification(limit?: number): readonly MemoryEntry[];
+    /**
+     * Delete auto_capture entries older than the retention window (S1-14).
+     *
+     * auto_capture logs every tool call's input/output — identical growth
+     * profile to the audit trail. Pair a call to this with
+     * AuditTrail.pruneOlderThan() on a daemon cron to keep
+     * `~/.wotann/memory.db` bounded.
+     *
+     * Returns the number of rows removed. Idempotent.
+     */
+    pruneAutoCaptures(days?: number): number;
+    /**
+     * Phase 2 P1-M7: file-indexing helpers wired into MemoryStore.
+     *
+     * The underlying IncrementalIndexer persists a SHA-per-file cache to
+     * `~/.wotann/index-cache.json` so repeat indexing runs only re-read
+     * files whose content actually changed. A lazy singleton keeps the
+     * cache in memory for the store's lifetime.
+     */
+    private incrementalIndexer;
+    private getIncrementalIndexer;
+    /**
+     * Return only the paths that need re-indexing (new or SHA-changed).
+     * First call loads the on-disk cache. Safe to call repeatedly.
+     */
+    getStaleFiles(paths: readonly string[], options?: IndexerOptions): Promise<readonly string[]>;
+    /**
+     * Record that a file has been indexed. Content-SHA is computed from
+     * the supplied text so callers who already have the content in
+     * memory don't pay an extra disk read.
+     */
+    markFileIndexed(path: string, content: string, chunksCount: number, options?: IndexerOptions): Promise<void>;
+    /** Forget a path — used when a file is deleted. Persists immediately. */
+    forgetFileIndex(path: string, options?: IndexerOptions): Promise<boolean>;
+    /** Stats on the in-memory index cache. */
+    getFileIndexStats(options?: IndexerOptions): Promise<{
+        readonly tracked: number;
+        readonly totalChunks: number;
+        readonly estimatedSavedMs: number;
+    }>;
+    /** Persist one typed relationship. Idempotent on id. */
+    addRelationship(rel: MemoryRelationship): void;
+    /** Bulk-persist relationships in a single transaction. */
+    addRelationships(rels: readonly MemoryRelationship[]): number;
+    /**
+     * Mark a relationship as invalidated. Used by
+     * knowledge-update-dynamics when a successor supersedes a
+     * predecessor — the predecessor's outbound non-updates edges are
+     * stamped so readers can distinguish active from historical edges.
+     */
+    invalidateRelationship(id: string, atMs?: number): boolean;
+    /** Fetch all relationships touching a given memory_entries id. */
+    getRelationshipsForEntry(entryId: string, options?: {
+        readonly kind?: MemoryRelationshipKind;
+        readonly includeInvalidated?: boolean;
+    }): readonly MemoryRelationship[];
+    /** All relationships — used by resolveLatest walkers + tests. */
+    getAllRelationships(options?: {
+        readonly includeInvalidated?: boolean;
+    }): readonly MemoryRelationship[];
+    private retrievalRegistrySlot;
+    private getRetrievalRegistry;
+    /**
+     * Register a custom retrieval mode on this store's registry. Callers
+     * that want a custom mode (e.g. a domain-specific reranker) can push
+     * it in here and then dispatch via `searchWithMode`.
+     */
+    registerRetrievalMode(mode: RetrievalMode): void;
+    /** List every retrieval mode name available on this store. */
+    listRetrievalModes(): readonly string[];
+    /**
+     * Dispatch a retrieval mode by name. When the mode is not
+     * registered, returns an empty result with an "unknown-mode"
+     * scoring note rather than throwing. This keeps callers in callback
+     * chains from needing to guard every dispatch.
+     */
+    searchWithMode(modeName: string, query: string, opts?: RetrievalModeOptions): Promise<RetrievalModeResult>;
+    /**
+     * V9 T14.2 — Register opt-in heavy / experimental retrieval
+     * strategies onto this store's registry. Default-OFF: callers must
+     * pass each flag explicitly. Each strategy delegates to a pure
+     * orphan module (asmr-voter / community-detection / persona-tree)
+     * and surfaces honest fallback semantics when its prerequisites
+     * (entry pool, edge graph, etc.) aren't available.
+     *
+     * Returns the names registered so the caller can introspect.
+     */
+    registerOptionalStrategies(opts: {
+        readonly asmrVoter?: boolean;
+        readonly communityDetection?: boolean;
+        readonly personaTree?: boolean;
+    }): readonly string[];
+    close(): void;
+}
+type AgentFactsModule = typeof import("./agent-facts.js");
+/**
+ * Bootstrap the agent-facts module reference used by
+ * `MemoryStore.recordAgentFact` / `MemoryStore.retrieveAgentFacts`.
+ *
+ * Called automatically by `agent-facts.ts` at import time so any
+ * consumer who imports either file gets the wiring transparently.
+ * Exposed for testability — tests can inject a stub module.
+ */
+export declare function setAgentFactsModule(mod: AgentFactsModule): void;
+export {};
+//# sourceMappingURL=store.d.ts.map