@danielsimonjr/memoryjs 2.8.0 → 2.9.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { z, ZodError, ZodSchema } from 'zod';
-import workerpool, { PoolStats, Pool } from '@danielsimonjr/workerpool';
+import { PoolStats, Pool } from '@danielsimonjr/workerpool';
 import { Database } from 'better-sqlite3';
 import { EventEmitter } from 'events';
 import { EventEmitter as EventEmitter$1 } from 'node:events';
@@ -221,6 +221,225 @@ declare class QueryTraceBuilder {
     complete(resultCount: number, metadata?: Record<string, unknown>): QueryTrace;
 }
 
+/**
+ * Graph Event Emitter
+ *
+ * Phase 10 Sprint 2: Provides event-based notifications for graph changes.
+ * Enables loose coupling between graph operations and dependent systems
+ * like search indexes, analytics, and external integrations.
+ *
+ * @module core/GraphEventEmitter
+ */
+
+/**
+ * Phase 10 Sprint 2: Event emitter for graph change notifications.
+ *
+ * Provides a type-safe event system for subscribing to and emitting
+ * graph change events. Supports wildcard listeners for all events.
+ *
+ * @example
+ * ```typescript
+ * const emitter = new GraphEventEmitter();
+ *
+ * // Listen to specific event types
+ * emitter.on('entity:created', (event) => {
+ *   console.log(`Entity ${event.entity.name} created`);
+ * });
+ *
+ * // Listen to all events
+ * emitter.onAny((event) => {
+ *   console.log(`Event: ${event.type}`);
+ * });
+ *
+ * // Emit an event
+ * emitter.emitEntityCreated(entity);
+ *
+ * // Remove listener
+ * const unsubscribe = emitter.on('entity:deleted', handler);
+ * unsubscribe();
+ * ```
+ */
+declare class GraphEventEmitter {
+    /**
+     * Map of event types to their registered listeners. The Set stores
+     * listeners typed for different specific event subtypes (one Set per
+     * GraphEventType key). TS can't express this dependent-key relationship
+     * without `any` due to function-parameter contravariance.
+     */
+    private listeners;
+    /**
+     * Listeners that receive all events regardless of type.
+     */
+    private wildcardListeners;
+    /**
+     * Whether to suppress errors from listeners (default: true).
+     * When true, listener errors are logged but don't stop event propagation.
+     */
+    private suppressListenerErrors;
+    /**
+     * Create a new GraphEventEmitter instance.
+     *
+     * @param options - Optional configuration
+     */
+    constructor(options?: {
+        suppressListenerErrors?: boolean;
+    });
+    /**
+     * Subscribe to a specific event type.
+     *
+     * @template K - The event type key
+     * @param eventType - The event type to listen for
+     * @param listener - Callback function to invoke when event occurs
+     * @returns Unsubscribe function to remove the listener
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = emitter.on('entity:created', (event) => {
+     *   console.log(`Created: ${event.entity.name}`);
+     * });
+     *
+     * // Later: unsubscribe();
+     * ```
+     */
+    on<K extends GraphEventType>(eventType: K, listener: GraphEventListener<GraphEventMap[K]>): () => void;
+    /**
+     * Unsubscribe from a specific event type.
+     *
+     * @template K - The event type key
+     * @param eventType - The event type to unsubscribe from
+     * @param listener - The listener function to remove
+     */
+    off<K extends GraphEventType>(eventType: K, listener: GraphEventListener<GraphEventMap[K]>): void;
+    /**
+     * Subscribe to all event types.
+     *
+     * @param listener - Callback function to invoke for any event
+     * @returns Unsubscribe function to remove the listener
+     *
+     * @example
+     * ```typescript
+     * emitter.onAny((event) => {
+     *   console.log(`Event: ${event.type} at ${event.timestamp}`);
+     * });
+     * ```
+     */
+    onAny(listener: GraphEventListener<GraphEvent>): () => void;
+    /**
+     * Unsubscribe from all events.
+     *
+     * @param listener - The listener function to remove
+     */
+    offAny(listener: GraphEventListener<GraphEvent>): void;
+    /**
+     * Subscribe to an event type, but only receive the first occurrence.
+     *
+     * @template K - The event type key
+     * @param eventType - The event type to listen for once
+     * @param listener - Callback function to invoke once
+     * @returns Unsubscribe function to cancel before event occurs
+     */
+    once<K extends GraphEventType>(eventType: K, listener: GraphEventListener<GraphEventMap[K]>): () => void;
+    /**
+     * Remove all listeners for all event types.
+     */
+    removeAllListeners(): void;
+    /**
+     * Get the count of listeners for a specific event type.
+     *
+     * @param eventType - The event type to count listeners for
+     * @returns Number of listeners registered
+     */
+    listenerCount(eventType?: GraphEventType): number;
+    /**
+     * Emit an event to all registered listeners.
+     *
+     * @param event - The event to emit
+     */
+    emit(event: GraphEvent): void;
+    /**
+     * Emit an entity:created event.
+     *
+     * @param entity - The entity that was created
+     */
+    emitEntityCreated(entity: Entity): void;
+    /**
+     * Emit an entity:updated event.
+     *
+     * @param entityName - Name of the updated entity
+     * @param changes - The changes that were applied
+     * @param previousValues - Optional previous values before update
+     */
+    emitEntityUpdated(entityName: string, changes: Partial<Entity>, previousValues?: Partial<Entity>): void;
+    /**
+     * Emit an entity:deleted event.
+     *
+     * @param entityName - Name of the deleted entity
+     * @param entity - Optional entity data before deletion
+     */
+    emitEntityDeleted(entityName: string, entity?: Entity): void;
+    /**
+     * Emit an entity:renamed event.
+     *
+     * Note: `EntityManager.renameEntity` also emits `entity:deleted` (old
+     * name) + `entity:created` (renamed entity) immediately after this event
+     * so create/delete-only derived views stay consistent.
+     *
+     * @param oldName - Entity name before the rename
+     * @param newName - Entity name after the rename
+     * @param entity - The renamed entity (name === newName)
+     */
+    emitEntityRenamed(oldName: string, newName: string, entity: Entity): void;
+    /**
+     * Emit a relation:created event.
+     *
+     * @param relation - The relation that was created
+     */
+    emitRelationCreated(relation: Relation): void;
+    /**
+     * Emit a relation:deleted event.
+     *
+     * @param from - Source entity name
+     * @param to - Target entity name
+     * @param relationType - Type of the deleted relation
+     */
+    emitRelationDeleted(from: string, to: string, relationType: string): void;
+    /**
+     * Emit an observation:added event.
+     *
+     * @param entityName - Name of the entity
+     * @param observations - Observations that were added
+     */
+    emitObservationAdded(entityName: string, observations: string[]): void;
+    /**
+     * Emit an observation:deleted event.
+     *
+     * @param entityName - Name of the entity
+     * @param observations - Observations that were deleted
+     */
+    emitObservationDeleted(entityName: string, observations: string[]): void;
+    /**
+     * Emit a graph:saved event.
+     *
+     * @param entityCount - Number of entities in the saved graph
+     * @param relationCount - Number of relations in the saved graph
+     */
+    emitGraphSaved(entityCount: number, relationCount: number): void;
+    /**
+     * Emit a graph:loaded event.
+     *
+     * @param entityCount - Number of entities in the loaded graph
+     * @param relationCount - Number of relations in the loaded graph
+     */
+    emitGraphLoaded(entityCount: number, relationCount: number): void;
+    /**
+     * Safely invoke a listener, optionally catching errors. Listener is
+     * typed `<any>` to match the heterogeneous storage in `this.listeners`
+     * (see field-level comment).
+     * @private
+     */
+    private invokeListener;
+}
+
 /**
  * Task Scheduler
  *
@@ -358,13 +577,10 @@ declare class TaskQueue {
     private queue;
     private running;
     private completed;
-    private pool;
     private concurrency;
-    private defaultTimeout;
     private isProcessing;
     private totalExecutionTime;
     private totalProcessed;
-    private useWorkerPool;
     private static readonly MAX_COMPLETED;
     private static readonly MAX_QUEUE;
     constructor(options?: {
@@ -372,10 +588,6 @@ declare class TaskQueue {
         timeout?: number;
         useWorkerPool?: boolean;
     });
-    /**
-     * Get or create the worker pool.
-     */
-    private getPool;
     /**
      * Add a task to the queue.
      *
@@ -571,6 +783,14 @@ declare const ENTITY_STATUS_TRANSITIONS: ReadonlyArray<readonly [EntityStatus, E
 interface Entity {
     /** Unique name identifying the entity */
     name: string;
+    /**
+     * Stable opaque identifier (UUID), assigned at creation by
+     * `EntityManager.createEntities` and preserved across renames
+     * (`renameEntity` never touches it). NOT yet used as a reference key —
+     * `name` remains the public primary key; `id` is forward-compat
+     * infrastructure for v2 stable-id references.
+     */
+    id?: string;
     /** Type/category of the entity (e.g., "person", "project", "concept") */
     entityType: string;
     /** Array of observation strings describing facts about the entity */
@@ -1628,6 +1848,40 @@ interface IGraphStorage {
      * @returns Promise resolving to true if found and updated
      */
     updateEntity(entityName: string, updates: Partial<Entity>): Promise<boolean>;
+    /**
+     * Atomically rename an entity, rewriting every stored reference to the
+     * old name: `Relation.from`/`Relation.to`, other entities' `parentId`,
+     * and the version-chain fields (`parentEntityName`, `rootEntityName`,
+     * `supersededBy`). The entity's `id`, `createdAt`, and all other fields
+     * are preserved; `lastModified` is updated.
+     *
+     * OPTIONAL member: kept optional so pre-existing third-party / test
+     * implementations of this interface remain valid without changes.
+     * Both first-party backends (`GraphStorage`, `SQLiteStorage`)
+     * implement it; `EntityManager.renameEntity` requires it.
+     *
+     * @param oldName - Current entity name (must exist)
+     * @param newName - New entity name (must not exist)
+     * @returns Promise resolving to the renamed entity
+     * @throws EntityNotFoundError if `oldName` does not exist
+     * @throws DuplicateEntityError if `newName` already exists
+     */
+    renameEntity?(oldName: string, newName: string): Promise<Entity>;
+    /**
+     * Graph event emitter powering event-driven derived views (TF-IDF sync,
+     * rank priors, embedding caches, columnar observation mirroring).
+     *
+     * OPTIONAL member: kept optional so pre-existing third-party / test
+     * implementations of this interface remain valid without changes (same
+     * precedent as `renameEntity`). Both first-party backends
+     * (`GraphStorage`, `SQLiteStorage`) expose one; derived views no-op
+     * gracefully when it is absent.
+     *
+     * Typed via an inline type-only import: `types.ts` is the root of the
+     * module layering (zero imports), so a top-level import from core would
+     * invert it; `import()` in type position is erased at compile time.
+     */
+    readonly events?: GraphEventEmitter;
     /**
      * Compact the storage by removing duplicates.
      *
@@ -2152,7 +2406,7 @@ interface BatchOptions {
  *
  * Used by GraphEventEmitter to categorize graph changes.
  */
-type GraphEventType = 'entity:created' | 'entity:updated' | 'entity:deleted' | 'relation:created' | 'relation:deleted' | 'observation:added' | 'observation:deleted' | 'graph:saved' | 'graph:loaded';
+type GraphEventType = 'entity:created' | 'entity:updated' | 'entity:deleted' | 'entity:renamed' | 'relation:created' | 'relation:deleted' | 'observation:added' | 'observation:deleted' | 'graph:saved' | 'graph:loaded';
 /**
  * Phase 10 Sprint 2: Base interface for all graph events.
  *
@@ -2210,6 +2464,30 @@ interface EntityDeletedEvent extends GraphEventBase {
     entityName: string;
     entity?: Entity;
 }
+/**
+ * Event emitted when an entity is renamed via `renameEntity`.
+ *
+ * Note for listeners: a rename ALSO emits `entity:deleted` (for the old
+ * name) followed by `entity:created` (for the renamed entity) so derived
+ * views that only understand create/delete (TF-IDF sync, rank priors,
+ * embedding caches) stay consistent without learning this event. Listeners
+ * therefore observe the sequence: `entity:renamed`, `entity:deleted`,
+ * `entity:created`.
+ *
+ * @example
+ * ```typescript
+ * emitter.on('entity:renamed', (event) => {
+ *   console.log(`${event.oldName} -> ${event.newName}`);
+ * });
+ * ```
+ */
+interface EntityRenamedEvent extends GraphEventBase {
+    type: 'entity:renamed';
+    oldName: string;
+    newName: string;
+    /** The entity after the rename (name === newName). */
+    entity: Entity;
+}
 /**
  * Phase 10 Sprint 2: Event emitted when a relation is created.
  *
@@ -2305,7 +2583,7 @@ interface GraphLoadedEvent extends GraphEventBase {
  *
  * Use this when handling any type of graph event.
  */
-type GraphEvent = EntityCreatedEvent | EntityUpdatedEvent | EntityDeletedEvent | RelationCreatedEvent | RelationDeletedEvent | ObservationAddedEvent | ObservationDeletedEvent | GraphSavedEvent | GraphLoadedEvent;
+type GraphEvent = EntityCreatedEvent | EntityUpdatedEvent | EntityDeletedEvent | EntityRenamedEvent | RelationCreatedEvent | RelationDeletedEvent | ObservationAddedEvent | ObservationDeletedEvent | GraphSavedEvent | GraphLoadedEvent;
 /**
  * Phase 10 Sprint 2: Listener function type for graph events.
  *
@@ -2321,6 +2599,7 @@ interface GraphEventMap {
     'entity:created': EntityCreatedEvent;
     'entity:updated': EntityUpdatedEvent;
     'entity:deleted': EntityDeletedEvent;
+    'entity:renamed': EntityRenamedEvent;
     'relation:created': RelationCreatedEvent;
     'relation:deleted': RelationDeletedEvent;
     'observation:added': ObservationAddedEvent;
@@ -2483,7 +2762,7 @@ interface HybridSearchResult {
         symbolic: number;
         combined: number;
     };
-    matchedLayers: ('semantic' | 'lexical' | 'symbolic')[];
+    matchedLayers: ('semantic' | 'lexical' | 'symbolic' | 'graph')[];
 }
 /**
  * An extracted entity from query analysis.
@@ -2882,6 +3161,25 @@ interface DecayEngineConfig {
      * Enable to make low-confidence memories decay faster in importance.
      */
     applyConfidenceToImportance?: boolean;
+    /**
+     * Connectivity protection strength in [0, 1] (default: 0 = off).
+     * Well-connected entities decay slower:
+     * `effectiveDecayFactor = decayFactor + (1 - decayFactor) × connectivityProtection × normalizedDegree`
+     * where `normalizedDegree` is the entity's relation degree divided by
+     * the maximum degree in the graph. At protection 1 a max-degree entity
+     * does not decay at all; at 0 behavior is unchanged. Values outside
+     * [0, 1] are clamped. Applies only to the legacy
+     * `calculateEffectiveImportance` path, never to
+     * `calculatePrdEffectiveImportance`.
+     *
+     * Because `calculateEffectiveImportance` is synchronous, degrees are
+     * read from a cached snapshot that is refreshed by the batch
+     * operations (`applyDecay`, `getDecayedMemories`, `getMemoriesAtRisk`,
+     * `forgetWeakMemories`) or explicitly via
+     * `refreshConnectivitySnapshot()`. Before the first refresh no
+     * protection is applied.
+     */
+    connectivityProtection?: number;
     /**
      * PRD `decay_rate`: exponential decay rate per second for the recency
      * term in `calculatePrdEffectiveImportance`. When absent, derived from
@@ -2952,6 +3250,8 @@ declare class DecayEngine {
     private readonly accessTracker;
     private readonly config;
     private readonly freshnessManager;
+    /** Degree snapshot for connectivity protection (see refreshConnectivitySnapshot). */
+    private _connectivityDegrees;
     constructor(storage: IGraphStorage, accessTracker: AccessTracker, config?: DecayEngineConfig);
     /**
      * Calculate decay factor based on time since last access.
@@ -3000,7 +3300,9 @@ declare class DecayEngine {
      * Formula: base_importance * decay_factor * strength_multiplier * confidence_factor
      *
      * - base_importance: Entity's stated importance (0-10)
-     * - decay_factor: Time-based decay (0-1), accelerated for past-TTL entities
+     * - decay_factor: Time-based decay (0-1), accelerated for past-TTL entities;
+     *   when `connectivityProtection` > 0 and a degree snapshot is available,
+     *   lifted toward 1 for well-connected entities (see DecayEngineConfig)
      * - strength_multiplier: Boost from confirmations and accesses
      * - confidence_factor: Decayed confidence based on entity age
      *
@@ -3027,6 +3329,23 @@ declare class DecayEngine {
      * Exposed for callers that need freshness calculations alongside decay.
      */
     getFreshnessManager(): FreshnessManager;
+    /**
+     * Refresh the degree snapshot used for connectivity protection.
+     *
+     * `calculateEffectiveImportance` is synchronous, so it reads entity
+     * degrees from this cached snapshot. The batch operations
+     * (`applyDecay`, `getDecayedMemories`, `getMemoriesAtRisk`,
+     * `forgetWeakMemories`) refresh it automatically from the graph they
+     * already load; call this method directly before ad-hoc single-entity
+     * scoring when relations may have changed. No-op cost when
+     * `connectivityProtection` is 0 apart from the graph load.
+     */
+    refreshConnectivitySnapshot(): Promise<void>;
+    /**
+     * Refresh the degree snapshot from an already-loaded graph.
+     * Skipped entirely when connectivity protection is disabled.
+     */
+    private maybeRefreshConnectivity;
     /**
      * Calculate effective importance using the Context Engine PRD formula.
      *
@@ -3173,6 +3492,13 @@ interface SalienceEngineConfig {
      * The freshness factor is subtracted from the final score proportionally.
      */
     freshnessWeight?: number;
+    /**
+     * Weight for graph connectivity boost (default: 0 = disabled).
+     * The connectivity signal is an entity's relation degree normalized
+     * by the maximum degree in the graph, in [0, 1]. With the default
+     * weight of 0 the signal is never computed and scores are unchanged.
+     */
+    connectivityWeight?: number;
 }
 /**
  * Calculates multi-factor salience scores for memories.
@@ -3203,6 +3529,7 @@ declare class SalienceEngine {
     private readonly freshnessManager;
     private readonly config;
     private _cachedMaxAccessCount;
+    private _cachedDegreeMap;
     constructor(storage: IGraphStorage, accessTracker: AccessTracker, decayEngine: DecayEngine, config?: SalienceEngineConfig);
     /**
      * Calculate salience score for an entity in the given context.
@@ -3213,6 +3540,7 @@ declare class SalienceEngine {
      * - Frequency: Log-normalized access count relative to max
      * - Context: Text similarity to current task/session/query
      * - Novelty: Inverse of recency (rewards less recently accessed)
+     * - Connectivity: Relation degree normalized by max degree (opt-in, weight 0 by default)
      *
      * @param entity - AgentEntity to calculate salience for
      * @param context - Context information for relevance scoring
@@ -3337,6 +3665,21 @@ declare class SalienceEngine {
      * @returns Score between 0 and 1
      */
     private calculateObservationUniqueness;
+    /**
+     * Calculate connectivity boost component.
+     * Relation degree of the entity normalized by the maximum degree
+     * in the graph. Well-connected (hub) entities score closer to 1;
+     * isolated entities score 0.
+     *
+     * @param entity - Entity to calculate for
+     * @returns Score between 0 and 1
+     */
+    private calculateConnectivityBoost;
+    /**
+     * Compute the relation degree map for the current graph.
+     * Used for normalizing connectivity scores.
+     */
+    private getDegreeMap;
     /**
      * Get the maximum access count across all entities.
      * Used for normalizing frequency scores.
@@ -4651,6 +4994,12 @@ interface SalienceComponents {
     contextRelevance: number;
     /** Novelty contribution */
     noveltyBoost: number;
+    /**
+     * Graph connectivity contribution (relation degree normalized by max
+     * degree). Optional for backwards compatibility; 0 when the
+     * connectivity signal is disabled (connectivityWeight = 0).
+     */
+    connectivityBoost?: number;
 }
 /**
  * Entity with calculated salience score.
@@ -6059,12 +6408,185 @@ declare function createDetailedProgressReporter(total: number, callback?: Progre
 };
 
 /**
- * Result<T, E> — discriminated-union return type for operations with
- * *expected* domain failures.
+ * Types for the Cue–Tag–Content associative memory graph and active memory
+ * reconstruction, implementing the MRAgent design from
+ * "Memory is Reconstructed, Not Retrieved: Graph Memory for LLM Agents"
+ * (Ji, Li & Hooi, ICML 2026).
  *
- * Per the MemoryJS error-handling policy (see CONTRIBUTING.md > Error
- * Handling):
- * - **throw** for programmer errors — bad arguments, invariant violations,
+ * The memory system is modelled as a heterogeneous graph `M = (C, V, R)`:
+ *   - Cues `c ∈ C`   — fine-grained keywords (entities, attributes, descriptors)
+ *   - Contents `v ∈ V` — memory items, organised into multi-granular layers
+ *   - Relations `R ⊆ C × G × V` — typed `(cue, tag, content)` triples where the
+ *     associative **tag** `g ∈ G` is the semantic bridge between cue and content.
+ *
+ * @module types/reconstruction
+ * @experimental
+ */
+/**
+ * Multi-granular memory layers (paper §3.2).
+ *
+ * - `episodic` — event-specific units grounded in a particular time/context.
+ * - `semantic` — stable knowledge (attributes, preferences, facts) anchored to
+ *   an entity-level cue via an aspect-level tag.
+ * - `topic` — higher-level abstractions summarising recurring patterns across a
+ *   coherent set of episodes.
+ */
+type ContentLayer = 'episodic' | 'semantic' | 'topic';
+/** A fine-grained retrieval cue (entity, attribute, or salient descriptor). */
+interface CueNode {
+    /** Stable identifier (normalised cue text). */
+    id: string;
+    /** Human-readable cue surface form. */
+    text: string;
+}
+/**
+ * An associative tag — a short phrase summarising the relational pattern that
+ * links a cue to memory content. Tags are the controllable intermediate that
+ * lets the agent prune traversal branches before touching expensive content.
+ */
+interface TagNode {
+    /** Stable identifier (normalised tag text). */
+    id: string;
+    /** Human-readable tag surface form (≤ ~2 words). */
+    text: string;
+}
+/** A memory content node — an episode, a semantic fact, or a topic abstraction. */
+interface ContentNode {
+    /** Stable identifier (e.g. `e1`, `s2`, `t3`). */
+    id: string;
+    /** Which multi-granular layer this content belongs to. */
+    layer: ContentLayer;
+    /** The content text (episode description, fact, or topic summary). */
+    text: string;
+    /** ISO `YYYY-MM-DD` conversation timestamp (episodic layer). */
+    timestamp?: string;
+    /** Topic ids this episode belongs to (episodic → topic links). */
+    topicIds?: string[];
+    /** Entity-level anchor for semantic content (the person/subject the fact is about). */
+    person?: string;
+    /** Free-form provenance (e.g. originating dialogue id). */
+    origin?: string;
+    /**
+     * Name of the persisted MemoryJS entity backing this content node, set when the
+     * graph is bridged to the live store (episodic→`EpisodicMemoryManager` timeline,
+     * semantic→entity/observation graph, topic→topic entity). Absent when running
+     * the self-contained in-memory graph.
+     */
+    entityName?: string;
+}
+/** A `(cue, tag, content)` association — one edge of the relation set `R`. */
+interface CTCTriple {
+    /** Cue id. */
+    cue: string;
+    /** Tag id. */
+    tag: string;
+    /** Content id. */
+    content: string;
+}
+/** Serialisable snapshot of a {@link CueTagContentGraph}. */
+interface CTCGraphSnapshot {
+    cues: CueNode[];
+    tags: TagNode[];
+    contents: ContentNode[];
+    triples: CTCTriple[];
+}
+/** A single processed/rewritten dialogue sentence produced by distillation. */
+interface DistilledSentence {
+    /** Sentence id (e.g. `D1:1-1`). */
+    id: string;
+    /** Rewritten, self-contained text (pronouns resolved, time normalised). */
+    text: string;
+    /** Short associative tag (≤ ~2 words). */
+    tag: string;
+    /** Originating raw sentence id. */
+    origin?: string;
+    /** Topic ids this sentence belongs to. */
+    topics?: string[];
+    /** ISO `YYYY-MM-DD` timestamp. */
+    time?: string;
+}
+/** A person-anchored semantic fact extracted during distillation. */
+interface PersonalFact {
+    /** Fact id (e.g. `p1`). */
+    id: string;
+    /** Normalised fact text. */
+    text: string;
+    /** Aspect-level tag (e.g. `preference`, `occupation`). */
+    tag: string;
+    /** The person/entity the fact is about. */
+    person: string;
+    /** Originating raw sentence id. */
+    origin?: string;
+}
+/** Result of running the LLM distillation pipeline over a dialogue. */
+interface DistillationResult$1 {
+    /** Conversation reference date (ISO `YYYY-MM-DD`). */
+    conversationTime?: string;
+    /** Rewritten episodic sentences. */
+    sentences: DistilledSentence[];
+    /** topic-id → topic description. */
+    topics: Record<string, string>;
+    /** Extracted person-anchored semantic facts. */
+    personalFacts: PersonalFact[];
+    /** sentence-id → extracted cue surface forms. */
+    keywords: Record<string, string[]>;
+}
+/** Raw dialogue input accepted by the distiller. */
+interface DialogueTurn {
+    /** Stable id for the turn (e.g. `D1:1`). */
+    id: string;
+    /** Speaker name, if known. */
+    speaker?: string;
+    /** Raw utterance text. */
+    text: string;
+    /** ISO timestamp for the turn, if known. */
+    timestamp?: string;
+}
+/** A traversal action the agent may take over the memory graph (paper §4.1). */
+type TraversalActionType = 'cue->tag' | 'cuetag->content' | 'content->cuetag' | 'topic->episode';
+/** One executed traversal action and the candidates it produced. */
+interface TraversalStep {
+    /** 0-based reconstruction step index. */
+    step: number;
+    /** The action(s) the policy selected this step. */
+    actions: TraversalActionType[];
+    /** Content nodes routed into the reconstructed context this step. */
+    routed: ContentNode[];
+    /** Short rationale for the step (policy- or LLM-supplied). */
+    rationale?: string;
+}
+/** Final output of an active reconstruction run (Algorithm 1). */
+interface ReconstructionResult {
+    /** The query that was reconstructed against. */
+    query: string;
+    /** Final answer, when an answering policy is supplied. */
+    answer?: string;
+    /** Confidence in `[0, 1]`, when available. */
+    confidence?: number;
+    /** Accumulated evidence (the reconstructed context `H`). */
+    evidence: ContentNode[];
+    /** The step-by-step traversal trajectory. */
+    trajectory: TraversalStep[];
+    /** Whether the loop stopped on a satisfied stopping condition (vs. budget). */
+    stoppedEarly: boolean;
+}
+/** Tunables for the reconstruction loop. */
+interface ReconstructionOptions {
+    /** Max reasoning turns `T` (paper caps at 8). Default 8. */
+    maxSteps?: number;
+    /** Max content nodes routed per step (per-turn retrieval budget `K`). Default 10. */
+    perStepBudget?: number;
+    /** Stop once this many distinct evidence items are accumulated. Default 12. */
+    evidenceTarget?: number;
+}
+
+/**
+ * Result<T, E> — discriminated-union return type for operations with
+ * *expected* domain failures.
+ *
+ * Per the MemoryJS error-handling policy (see CONTRIBUTING.md > Error
+ * Handling):
+ * - **throw** for programmer errors — bad arguments, invariant violations,
  *   "this should never happen" states;
  * - **return `Result<T, E>`** for expected, recoverable failures the caller
  *   is meant to branch on (not found, validation failed, conflict, ...);
@@ -6970,6 +7492,18 @@ declare function levenshteinDistance(str1: string, str2: string): number;
  * @returns Term frequency (0.0 to 1.0)
  */
 declare function calculateTF(term: string, document: string): number;
+/**
+ * Calculate Term Frequency (TF) from pre-tokenized documents.
+ *
+ * TF = (Number of times term appears in document) / (Total terms in document)
+ *
+ * **Optimized**: Avoids re-tokenizing the document text for each term.
+ *
+ * @param term - The search term (should already be lowercase if possible)
+ * @param tokens - Pre-tokenized lowercase tokens for the document
+ * @returns Term frequency (0.0 to 1.0)
+ */
+declare function calculateTFFromTokens(term: string, tokens: string[]): number;
 /**
  * Calculate Inverse Document Frequency (IDF) for a term across documents.
  *
@@ -7206,6 +7740,7 @@ declare function cleanupAllCaches(): void;
  * Used for validating full entity objects including timestamps.
  */
 declare const EntitySchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     entityType: z.ZodString;
     observations: z.ZodArray<z.ZodString>;
@@ -7222,6 +7757,7 @@ declare const EntitySchema: z.ZodObject<{
  * Timestamps are optional and will be auto-generated if not provided.
  */
 declare const CreateEntitySchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     entityType: z.ZodString;
     observations: z.ZodArray<z.ZodString>;
@@ -7348,6 +7884,7 @@ declare const ExportFormatSchema: z.ZodEnum<{
  * Empty arrays are allowed (no-op).
  */
 declare const BatchCreateEntitiesSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     entityType: z.ZodString;
     observations: z.ZodArray<z.ZodString>;
@@ -7636,6 +8173,10 @@ declare function validateRelation(relation: unknown): ValidationResult$1;
 declare function validateImportance(importance: number): boolean;
 /** Validate an array of tags. */
 declare function validateTags(tags: unknown): ValidationResult$1;
+/** Validate a non-empty string with detailed error reporting. */
+declare function validateNonEmpty(value: unknown, fieldName: string, contextName?: string): void;
+/** Validate a non-empty array with detailed error reporting. */
+declare function validateNonEmptyArray(value: unknown, fieldName: string, contextName?: string): void;
 
 /**
  * Response and Pagination Formatters
@@ -8167,16 +8708,15 @@ declare function ensureMemoryFilePath(): Promise<string>;
 /**
  * Parallel Utilities
  *
- * Utilities for parallel array operations using workerpool.
+ * Utilities for parallel array operations.
  * Phase 8 Sprint 3: Parallel array operations for improved performance.
  *
- * **SECURITY WARNING:** These functions use `new Function()` internally for worker serialization.
- * The `fn` parameter MUST be a real function object, never a user-provided string.
- * Runtime validation ensures only function objects are accepted.
+ * Note: Actual multiprocessing capabilities have been removed for security reasons
+ * (preventing dynamic function execution) and to use the unified WorkerTaskManager.
+ * These utilities now execute sequentially but asynchronously via Promise.all.
  *
  * @module utils/parallelUtils
  */
-
 /**
  * Shutdown the shared worker pool and clean up resources.
  * Should be called when parallel utilities are no longer needed.
@@ -8207,7 +8747,7 @@ declare function shutdownParallelUtils(): Promise<void>;
  * // Result: [1, 4, 9, 16, 25]
  * ```
  */
-declare function parallelMap<T, R>(items: T[], fn: (item: T) => R, chunkSize?: number): Promise<R[]>;
+declare function parallelMap<T, R>(items: T[], fn: (item: T) => R | Promise<R>, _chunkSize?: number): Promise<R[]>;
 /**
  * Filter items in parallel using workerpool.
  *
@@ -8232,13 +8772,19 @@ declare function parallelMap<T, R>(items: T[], fn: (item: T) => R, chunkSize?: n
  * // Result: [2, 4, 6]
  * ```
  */
-declare function parallelFilter<T>(items: T[], predicate: (item: T) => boolean, chunkSize?: number): Promise<T[]>;
+declare function parallelFilter<T>(items: T[], predicate: (item: T) => boolean | Promise<boolean>, _chunkSize?: number): Promise<T[]>;
 /**
  * Get statistics about the worker pool.
  *
  * @returns Pool statistics or null if pool is not initialized
  */
-declare function getPoolStats(): workerpool.PoolStats | null;
+declare function getPoolStats(): {
+    totalWorkers: number;
+    busyWorkers: number;
+    idleWorkers: number;
+    pendingTasks: number;
+    activeTasks: number;
+} | null;
 
 /**
  * Operation Utilities
@@ -8480,10 +9026,13 @@ interface TaskSubmitOptions {
 }
 /**
  * Handle returned by `submitWithHandle`. The `result` promise settles when
- * the task finishes; `cancel()` evicts a still-pending task from the queue
- * (returns `true`) or signals a request-cancellation flag on a running task
- * (returns `false` — `workerpool` itself doesn't support hard-cancel and
- * terminating mid-task is destructive).
+ * the task finishes; `cancel()` performs two-tier cancellation:
+ *
+ *   - If still pending in the queue: evict cleanly. Returns `true`.
+ *   - If already dispatched: propagate to the underlying
+ *     `WorkerpoolPromise.cancel()` so the running worker rejects with
+ *     `CancellationError`. Returns `true` if the workerpool promise was
+ *     still pending at the moment of cancel; `false` if it already settled.
  */
 interface TaskHandle<R> {
     id: string;
@@ -8534,6 +9083,7 @@ declare class WorkerTaskManager {
     private readonly touchedPoolIds;
     private readonly cancelledTaskIds;
     private readonly handleStatus;
+    private readonly liveExecPromises;
     constructor(opts?: {
         /** Max concurrent tasks across the queue. Default: cpus − 1. */
         concurrency?: number;
@@ -9814,213 +10364,6 @@ declare class BatchTransaction {
     private applyBatchOperation;
 }
 
-/**
- * Graph Event Emitter
- *
- * Phase 10 Sprint 2: Provides event-based notifications for graph changes.
- * Enables loose coupling between graph operations and dependent systems
- * like search indexes, analytics, and external integrations.
- *
- * @module core/GraphEventEmitter
- */
-
-/**
- * Phase 10 Sprint 2: Event emitter for graph change notifications.
- *
- * Provides a type-safe event system for subscribing to and emitting
- * graph change events. Supports wildcard listeners for all events.
- *
- * @example
- * ```typescript
- * const emitter = new GraphEventEmitter();
- *
- * // Listen to specific event types
- * emitter.on('entity:created', (event) => {
- *   console.log(`Entity ${event.entity.name} created`);
- * });
- *
- * // Listen to all events
- * emitter.onAny((event) => {
- *   console.log(`Event: ${event.type}`);
- * });
- *
- * // Emit an event
- * emitter.emitEntityCreated(entity);
- *
- * // Remove listener
- * const unsubscribe = emitter.on('entity:deleted', handler);
- * unsubscribe();
- * ```
- */
-declare class GraphEventEmitter {
-    /**
-     * Map of event types to their registered listeners. The Set stores
-     * listeners typed for different specific event subtypes (one Set per
-     * GraphEventType key). TS can't express this dependent-key relationship
-     * without `any` due to function-parameter contravariance.
-     */
-    private listeners;
-    /**
-     * Listeners that receive all events regardless of type.
-     */
-    private wildcardListeners;
-    /**
-     * Whether to suppress errors from listeners (default: true).
-     * When true, listener errors are logged but don't stop event propagation.
-     */
-    private suppressListenerErrors;
-    /**
-     * Create a new GraphEventEmitter instance.
-     *
-     * @param options - Optional configuration
-     */
-    constructor(options?: {
-        suppressListenerErrors?: boolean;
-    });
-    /**
-     * Subscribe to a specific event type.
-     *
-     * @template K - The event type key
-     * @param eventType - The event type to listen for
-     * @param listener - Callback function to invoke when event occurs
-     * @returns Unsubscribe function to remove the listener
-     *
-     * @example
-     * ```typescript
-     * const unsubscribe = emitter.on('entity:created', (event) => {
-     *   console.log(`Created: ${event.entity.name}`);
-     * });
-     *
-     * // Later: unsubscribe();
-     * ```
-     */
-    on<K extends GraphEventType>(eventType: K, listener: GraphEventListener<GraphEventMap[K]>): () => void;
-    /**
-     * Unsubscribe from a specific event type.
-     *
-     * @template K - The event type key
-     * @param eventType - The event type to unsubscribe from
-     * @param listener - The listener function to remove
-     */
-    off<K extends GraphEventType>(eventType: K, listener: GraphEventListener<GraphEventMap[K]>): void;
-    /**
-     * Subscribe to all event types.
-     *
-     * @param listener - Callback function to invoke for any event
-     * @returns Unsubscribe function to remove the listener
-     *
-     * @example
-     * ```typescript
-     * emitter.onAny((event) => {
-     *   console.log(`Event: ${event.type} at ${event.timestamp}`);
-     * });
-     * ```
-     */
-    onAny(listener: GraphEventListener<GraphEvent>): () => void;
-    /**
-     * Unsubscribe from all events.
-     *
-     * @param listener - The listener function to remove
-     */
-    offAny(listener: GraphEventListener<GraphEvent>): void;
-    /**
-     * Subscribe to an event type, but only receive the first occurrence.
-     *
-     * @template K - The event type key
-     * @param eventType - The event type to listen for once
-     * @param listener - Callback function to invoke once
-     * @returns Unsubscribe function to cancel before event occurs
-     */
-    once<K extends GraphEventType>(eventType: K, listener: GraphEventListener<GraphEventMap[K]>): () => void;
-    /**
-     * Remove all listeners for all event types.
-     */
-    removeAllListeners(): void;
-    /**
-     * Get the count of listeners for a specific event type.
-     *
-     * @param eventType - The event type to count listeners for
-     * @returns Number of listeners registered
-     */
-    listenerCount(eventType?: GraphEventType): number;
-    /**
-     * Emit an event to all registered listeners.
-     *
-     * @param event - The event to emit
-     */
-    emit(event: GraphEvent): void;
-    /**
-     * Emit an entity:created event.
-     *
-     * @param entity - The entity that was created
-     */
-    emitEntityCreated(entity: Entity): void;
-    /**
-     * Emit an entity:updated event.
-     *
-     * @param entityName - Name of the updated entity
-     * @param changes - The changes that were applied
-     * @param previousValues - Optional previous values before update
-     */
-    emitEntityUpdated(entityName: string, changes: Partial<Entity>, previousValues?: Partial<Entity>): void;
-    /**
-     * Emit an entity:deleted event.
-     *
-     * @param entityName - Name of the deleted entity
-     * @param entity - Optional entity data before deletion
-     */
-    emitEntityDeleted(entityName: string, entity?: Entity): void;
-    /**
-     * Emit a relation:created event.
-     *
-     * @param relation - The relation that was created
-     */
-    emitRelationCreated(relation: Relation): void;
-    /**
-     * Emit a relation:deleted event.
-     *
-     * @param from - Source entity name
-     * @param to - Target entity name
-     * @param relationType - Type of the deleted relation
-     */
-    emitRelationDeleted(from: string, to: string, relationType: string): void;
-    /**
-     * Emit an observation:added event.
-     *
-     * @param entityName - Name of the entity
-     * @param observations - Observations that were added
-     */
-    emitObservationAdded(entityName: string, observations: string[]): void;
-    /**
-     * Emit an observation:deleted event.
-     *
-     * @param entityName - Name of the entity
-     * @param observations - Observations that were deleted
-     */
-    emitObservationDeleted(entityName: string, observations: string[]): void;
-    /**
-     * Emit a graph:saved event.
-     *
-     * @param entityCount - Number of entities in the saved graph
-     * @param relationCount - Number of relations in the saved graph
-     */
-    emitGraphSaved(entityCount: number, relationCount: number): void;
-    /**
-     * Emit a graph:loaded event.
-     *
-     * @param entityCount - Number of entities in the loaded graph
-     * @param relationCount - Number of relations in the loaded graph
-     */
-    emitGraphLoaded(entityCount: number, relationCount: number): void;
-    /**
-     * Safely invoke a listener, optionally catching errors. Listener is
-     * typed `<any>` to match the heterogeneous storage in `this.listeners`
-     * (see field-level comment).
-     * @private
-     */
-    private invokeListener;
-}
-
 /**
  * Graph Storage
  *
@@ -10351,6 +10694,41 @@ declare class GraphStorage implements IGraphStorage {
      * @returns Promise resolving to true if entity was found and updated, false otherwise
      */
     updateEntity(entityName: string, updates: Partial<Entity>): Promise<boolean>;
+    /**
+     * Atomically rename an entity, rewriting every stored reference to the
+     * old name:
+     * - `Relation.from` / `Relation.to`
+     * - other entities' `parentId`
+     * - version-chain fields on all entities (`parentEntityName`,
+     *   `rootEntityName`, `supersededBy`) — including self-references on
+     *   the renamed entity itself.
+     *
+     * The entity's `id`, `createdAt`, and all other fields are preserved;
+     * only `lastModified` is bumped. Referencing entities/relations keep
+     * their own timestamps (a rename is a pure reference rewrite, their
+     * content did not change).
+     *
+     * Implementation: load-mutate-save via `saveGraphInternal`, which fully
+     * rewrites the file and rebuilds every in-memory index (NameIndex /
+     * TypeIndex / LowercaseCache / RelationIndex / ObservationIndex) — the
+     * same pattern other bulk mutations use. This also makes segment mode
+     * (`MEMORY_STORAGE_SEGMENT_COUNT >= 2`) correct for free: `saveAll`
+     * re-routes every entity through `fnv1a32(name) % N`, so the renamed
+     * entity migrates to its new owning segment atomically (manifest-based
+     * multi-file commit).
+     *
+     * Does NOT emit entity events itself — `EntityManager.renameEntity`
+     * emits `entity:renamed` + `entity:deleted` + `entity:created` after
+     * the storage write succeeds. (`saveGraphInternal` still emits its
+     * usual `graph:saved`.)
+     *
+     * @param oldName - Current entity name (must exist)
+     * @param newName - New entity name (must not exist)
+     * @returns The renamed entity
+     * @throws {EntityNotFoundError} If `oldName` does not exist
+     * @throws {DuplicateEntityError} If `newName` already exists
+     */
+    renameEntity(oldName: string, newName: string): Promise<Entity>;
     /**
      * Manually clear the cache.
      *
@@ -10653,6 +11031,15 @@ declare class SQLiteStorage implements IGraphStorage {
      * to protect our in-memory cache and index operations.
      */
     private mutex;
+    /**
+     * Application-level mutex for managers to serialize validate+mutate+save.
+     * Mirrors `GraphStorage.graphMutex` — `EntityManager` / `RelationManager` /
+     * `ObservationManager` acquire it around their read-modify-write cycles,
+     * so it must exist on every backend those managers can be handed.
+     * (Previously missing here, which made manager-level batch mutations
+     * crash on the SQLite backend.)
+     */
+    readonly graphMutex: AsyncMutex;
     /**
      * SQLite database instance for writes and write-transaction reads.
      */
@@ -10723,6 +11110,14 @@ declare class SQLiteStorage implements IGraphStorage {
      * Maps entity name -> all relations involving that entity (both incoming and outgoing).
      */
     private bidirectionalRelationCache;
+    /**
+     * Event emitter for graph change notifications. Mirrors
+     * `GraphStorage.eventEmitter` so event-driven derived views
+     * (`TFIDFEventSync`, `GraphRankPrior`, embedding caches, the columnar
+     * observation shadow store, `TransitionLedger`) work identically on the
+     * SQLite backend.
+     */
+    private eventEmitter;
     /**
      * Validated database file path (after path traversal checks).
      */
@@ -10734,6 +11129,33 @@ declare class SQLiteStorage implements IGraphStorage {
      * @throws {FileOperationError} If path traversal is detected
      */
     constructor(dbFilePath: string);
+    /**
+     * Get the event emitter for subscribing to graph changes.
+     *
+     * Emission parity with `GraphStorage` (one-for-one at the equivalent
+     * mutation points):
+     * - `graph:loaded` — after `loadCache()` populates the in-memory cache
+     * - `graph:saved` — after `saveGraph()` commits a full-graph write
+     * - `entity:created` — `appendEntity()`
+     * - `relation:created` — `appendRelation()`
+     * - `entity:updated` — `updateEntity()` (with `previousValues`)
+     * - rename events (`entity:renamed` → `entity:deleted` → `entity:created`)
+     *   are emitted by `EntityManager.renameEntity` (manager level, same as
+     *   the JSONL path) — `renameEntity()` here intentionally emits nothing
+     *   so each event fires exactly once.
+     *
+     * @returns GraphEventEmitter instance
+     *
+     * @example
+     * ```typescript
+     * const storage = new SQLiteStorage('/data/memory.db');
+     *
+     * storage.events.on('entity:created', (event) => {
+     *   console.log(`Entity ${event.entity.name} created`);
+     * });
+     * ```
+     */
+    get events(): GraphEventEmitter;
     /**
      * Initialize the database connection and schema.
      */
@@ -10847,6 +11269,43 @@ declare class SQLiteStorage implements IGraphStorage {
      * @returns Promise resolving to true if found and updated
      */
     updateEntity(entityName: string, updates: Partial<Entity>): Promise<boolean>;
+    /**
+     * Atomically rename an entity, rewriting every stored reference to the
+     * old name inside a single SQLite transaction:
+     * - `entities.name` (+ `lastModified` bump on the renamed row)
+     * - `relations.fromEntity` / `relations.toEntity`
+     * - other entities' `parentId`
+     * - version-chain columns (`parentEntityName`, `rootEntityName`,
+     *   `supersededBy` — all native columns, not JSON fields)
+     * - `embeddings.entityName` (when the embeddings table exists)
+     *
+     * FTS5 stays in sync automatically: the `entities_au` AFTER UPDATE
+     * trigger re-indexes each touched row (delete old values / insert new).
+     *
+     * Foreign keys are toggled OFF around the transaction (same pattern as
+     * `saveGraph`): `relations.fromEntity/toEntity` and `entities.parentId`
+     * reference `entities(name)` with no ON UPDATE action, so renaming the
+     * parent key first would otherwise fail the FK check mid-flight.
+     *
+     * Referencing rows keep their own timestamps (a rename is a pure
+     * reference rewrite; their content did not change).
+     *
+     * Does NOT emit entity events itself — `EntityManager.renameEntity`
+     * emits `entity:renamed` + `entity:deleted` + `entity:created` after
+     * the storage write succeeds (same division of responsibility as the
+     * JSONL path). Emitting here as well would double-fire those events.
+     * Unlike `GraphStorage.renameEntity` (which routes through
+     * `saveGraphInternal` and therefore also emits `graph:saved` as an
+     * implementation artifact of the full-file rewrite), this targeted SQL
+     * transaction emits no `graph:saved` — no full-graph write happens.
+     *
+     * @param oldName - Current entity name (must exist)
+     * @param newName - New entity name (must not exist)
+     * @returns The renamed entity
+     * @throws {EntityNotFoundError} If `oldName` does not exist
+     * @throws {DuplicateEntityError} If `newName` already exists
+     */
+    renameEntity(oldName: string, newName: string): Promise<Entity>;
     /**
      * Compact the storage (runs VACUUM to reclaim space).
      *
@@ -11158,6 +11617,17 @@ declare class RefIndex {
      * @returns Number of refs removed
      */
     purgeEntity(entityName: string): Promise<number>;
+    /**
+     * Remap every alias pointing at `oldName` to point at `newName`.
+     * Called by `EntityManager.renameEntity` so registered refs survive
+     * entity renames (the reason this index exists). Silent no-op when no
+     * refs point at `oldName`.
+     *
+     * @param oldName - Entity name before the rename
+     * @param newName - Entity name after the rename
+     * @returns Number of refs remapped
+     */
+    renameEntity(oldName: string, newName: string): Promise<number>;
     /**
      * Batch {@link purgeEntity} — rewrites the JSONL sidecar once for the
      * whole set instead of once per name.
@@ -11392,6 +11862,39 @@ declare class EntityManager {
      * ```
      */
     getEntity(name: string, options?: GetEntityOptions): Promise<Entity | null>;
+    /**
+     * List all entities in the graph, optionally filtered by entity type.
+     *
+     * This is the public bulk-enumeration API — use it instead of reaching
+     * into the storage layer (`entityManager['storage'].loadGraph()`).
+     *
+     * Performance: when an `entityType` filter is given, the storage layer's
+     * TypeIndex fast path (`getEntitiesByType`) resolves matches in O(k) for
+     * k matching entities. Without a filter the full graph is loaded — O(n)
+     * in graph size — so avoid unfiltered calls in hot paths on large graphs.
+     *
+     * The returned array is always a fresh copy (safe to sort/mutate), but
+     * the Entity objects inside are the storage layer's live references —
+     * treat them as read-only, same as `getEntity` results.
+     *
+     * @param filter - Optional filter. `entityType` matches case-insensitively
+     *   (TypeIndex semantics, same as `storage.getEntitiesByType`).
+     * @returns Array of matching entities (empty when nothing matches)
+     *
+     * @example
+     * ```typescript
+     * const manager = new EntityManager(storage);
+     *
+     * // All entities
+     * const all = await manager.listEntities();
+     *
+     * // Only procedures (O(k) via TypeIndex)
+     * const procedures = await manager.listEntities({ entityType: 'procedure' });
+     * ```
+     */
+    listEntities(filter?: {
+        entityType?: string;
+    }): Promise<Entity[]>;
     /**
      * List all distinct project IDs in the graph (excluding global entities).
      *
@@ -11501,6 +12004,55 @@ declare class EntityManager {
     updateEntity(name: string, updates: Partial<Entity>, options?: {
         expectedVersion?: number;
     }): Promise<Entity>;
+    /**
+     * Rename an entity, atomically rewriting every core-graph reference to
+     * the old name.
+     *
+     * Delegates to the storage-level `renameEntity` primitive (implemented
+     * by both `GraphStorage` and `SQLiteStorage`), which rewrites:
+     * - `Relation.from` / `Relation.to`
+     * - other entities' `parentId`
+     * - version-chain fields (`parentEntityName`, `rootEntityName`,
+     *   `supersededBy`)
+     *
+     * The entity's `id`, `createdAt`, and all other fields are preserved;
+     * `lastModified` is bumped. Registered `RefIndex` aliases pointing at
+     * the old name are remapped to the new name (when a RefIndex is
+     * configured via `setRefIndex` — `ManagerContext` wires this
+     * automatically).
+     *
+     * **Events**: on backends with an event emitter (JSONL `GraphStorage`),
+     * emits a typed `entity:renamed` event, followed by `entity:deleted`
+     * (old name) and `entity:created` (renamed entity) so create/delete-only
+     * derived views (TF-IDF event sync, rank priors, embedding caches) stay
+     * consistent without learning the new event type. Listeners therefore
+     * observe: `entity:renamed`, `entity:deleted`, `entity:created`.
+     * Both first-party backends expose an emitter (`storage.events`), so
+     * this sequence fires on JSONL and SQLite alike; the guard below only
+     * protects third-party storage implementations without one.
+     *
+     * **Known limitations (intentionally out of scope)**:
+     * - Archived snapshots (`ArchiveManager` compressed archives) keep the
+     *   old name — they are point-in-time exports, not live references.
+     * - The audit log is immutable by design; historical records keep the
+     *   old name.
+     * - Agent-memory soft references stored inside `agentMetadata` blobs or
+     *   observation text (e.g. `promotedFrom`, `previousSessionId`,
+     *   free-text mentions) are not rewritten.
+     * - JSONL-backend vector-store sidecars are not rewritten; the emitted
+     *   delete+create events let embedding caches re-index the new name.
+     *
+     * @param oldName - Current entity name (must exist)
+     * @param newName - New entity name (must not exist; must pass the same
+     *   validation as `createEntities`, including the reserved `profile-` /
+     *   `diary-` namespace rules)
+     * @returns The renamed entity
+     * @throws {ValidationError} If `newName` fails name validation or
+     *   violates a reserved namespace
+     * @throws {EntityNotFoundError} If `oldName` does not exist
+     * @throws {DuplicateEntityError} If `newName` already exists
+     */
+    renameEntity(oldName: string, newName: string): Promise<Entity>;
     /**
      * Update multiple entities in a single batch operation.
      *
@@ -14355,6 +14907,137 @@ declare class BasicSearch {
     searchByDateRange(startDate?: string, endDate?: string, entityType?: string, tags?: string[], offset?: number, limit?: number): Promise<KnowledgeGraph>;
 }
 
+/**
+ * Graph Rank Prior
+ *
+ * Cached graph-connectivity signal provider for search ranking. Exposes
+ * PageRank and degree centrality as ranking priors so that well-connected
+ * entities can be boosted over isolated ones. The full-graph computation is
+ * cached and lazily invalidated on graph mutation via GraphEventEmitter
+ * subscription (entity created/updated/deleted, relation created/deleted,
+ * and graph saved — the latter covers manager-level batch mutations like
+ * `EntityManager.createEntities` / `RelationManager.createRelations`,
+ * which persist via `storage.saveGraph` and emit only `graph:saved`) —
+ * recomputation happens on next access, not eagerly per event.
+ *
+ * Cost guard: when the graph exceeds `maxPageRankEntities` (default 50 000),
+ * PageRank is skipped and the normalized signal falls back to degree
+ * centrality, which is a single O(V + E) pass.
+ *
+ * @module search/GraphRankPrior
+ * @experimental
+ */
+
+/**
+ * Options for {@link GraphRankPrior}.
+ */
+interface GraphRankPriorOptions {
+    /**
+     * Entity-count threshold above which the PageRank computation is skipped
+     * and the normalized connectivity signal falls back to degree centrality.
+     * Default: 50 000.
+     */
+    maxPageRankEntities?: number;
+    /** PageRank damping factor (default: 0.85). */
+    dampingFactor?: number;
+    /**
+     * Event emitter to subscribe to for cache invalidation. When provided,
+     * entity:created/updated/deleted, relation:created/deleted, and
+     * graph:saved events mark the cached scores stale (lazy recompute on
+     * next access). graph:saved matters because manager-level batch
+     * mutations (create/delete entities and relations) persist via a full
+     * `saveGraph` and emit no per-item events.
+     */
+    events?: GraphEventEmitter;
+}
+/** Default entity-count threshold for skipping PageRank. */
+declare const DEFAULT_MAX_PAGERANK_ENTITIES = 50000;
+/**
+ * Provides cached graph-connectivity ranking signals (PageRank + degree).
+ *
+ * @example
+ * ```typescript
+ * const prior = new GraphRankPrior(ctx.graphTraversal, { events: storage.events });
+ * const scores = await prior.getScores(['Alice', 'Bob']); // normalized [0, 1]
+ * prior.dispose(); // unsubscribe from events when done
+ * ```
+ */
+declare class GraphRankPrior {
+    private readonly traversal;
+    private readonly maxPageRankEntities;
+    private readonly dampingFactor;
+    /** Cached scores, or null when stale/uncomputed. */
+    private cache;
+    /** In-flight computation, deduplicating concurrent accesses. */
+    private pending;
+    private unsubscribers;
+    /**
+     * Create a new GraphRankPrior.
+     *
+     * @param source - A GraphTraversal instance (preferred — reuses its
+     *   PageRank/degree implementations) or a GraphStorage, which is wrapped
+     *   in a private GraphTraversal.
+     * @param options - Threshold, damping, and event-subscription options
+     */
+    constructor(source: GraphTraversal | GraphStorage, options?: GraphRankPriorOptions);
+    /**
+     * Get the raw PageRank score for an entity.
+     *
+     * Returns 0 for unknown entities, and 0 for all entities when the graph
+     * exceeded `maxPageRankEntities` (degree-only fallback — use
+     * {@link getScores} for the fallback-aware normalized signal).
+     */
+    getPageRank(entityName: string): Promise<number>;
+    /**
+     * Get the raw degree (incident relation count, both directions) for an
+     * entity. Returns 0 for unknown entities.
+     */
+    getDegree(entityName: string): Promise<number>;
+    /**
+     * Get min-max-normalized connectivity scores (in [0, 1], normalized over
+     * the whole graph) for the given entity names. Uses PageRank when the
+     * graph is within `maxPageRankEntities`, degree centrality otherwise.
+     * Unknown entities map to 0.
+     */
+    getScores(names: string[]): Promise<Map<string, number>>;
+    /**
+     * Get the unique one-hop neighbor names of an entity (both directions).
+     * Reads the live relation index — not part of the cached computation.
+     */
+    neighbors(entityName: string): string[];
+    /**
+     * Whether the last computed signal used the degree-only fallback
+     * (graph exceeded `maxPageRankEntities`). Undefined before first compute.
+     */
+    isDegreeFallback(): boolean | undefined;
+    /**
+     * Mark the cached scores stale. The next access recomputes lazily.
+     */
+    invalidate(): void;
+    /**
+     * Unsubscribe from all graph events and drop cached scores. The instance
+     * remains usable (scores recompute on demand) but no longer auto-invalidates.
+     */
+    dispose(): void;
+    /**
+     * Return the cached scores, computing them if stale. Concurrent callers
+     * share a single in-flight computation.
+     * @internal
+     */
+    private ensureComputed;
+    /**
+     * Run the full-graph connectivity computation.
+     * @internal
+     */
+    private compute;
+    /**
+     * Min-max normalize scores to [0, 1]. All-equal non-zero scores map to 1;
+     * all-zero scores stay 0 (mirrors HybridScorer.minMaxNormalize semantics).
+     * @internal
+     */
+    private minMaxNormalize;
+}
+
 /**
  * Ranked Search
  *
@@ -14369,6 +15052,12 @@ declare class BasicSearch {
 declare class RankedSearch {
     private storage;
     private indexManager;
+    /**
+     * Optional graph-connectivity prior. When set with a positive boost, final
+     * scores are multiplied by `(1 + boost * normalizedPageRank)`. Default off.
+     */
+    private graphPrior;
+    private graphBoost;
     /**
      * Phase 4 Sprint 2: Fallback token cache for entities.
      * Maps entity name -> pre-tokenized entity data.
@@ -14378,6 +15067,18 @@ declare class RankedSearch {
     private cachedEntityCount;
     private cachedEntityNames;
     constructor(storage: GraphStorage, storageDir?: string);
+    /**
+     * Attach (or detach) a graph-connectivity prior for score boosting.
+     *
+     * When both a prior and a positive boost are set, `searchNodesRanked`
+     * multiplies each result's score by `(1 + boost * normalizedPageRank)`
+     * and re-sorts. A boost of 0 (the default) disables the behavior entirely.
+     *
+     * @param prior - GraphRankPrior instance, or null to detach
+     * @param boost - Multiplicative boost factor (default 0 = off)
+     * @experimental
+     */
+    setGraphPrior(prior: GraphRankPrior | null, boost?: number): void;
     /**
      * Phase 4 Sprint 2: Clear the fallback token cache.
      * Called when graph changes are detected or explicitly by external code.
@@ -14418,6 +15119,11 @@ declare class RankedSearch {
      * @returns Array of search results sorted by relevance
      */
     searchNodesRanked(query: string, tags?: string[], minImportance?: number, maxImportance?: number, limit?: number, projectId?: string): Promise<SearchResult[]>;
+    /**
+     * Multiply each result's score by `(1 + boost * normalizedPageRank)` and
+     * re-sort. No-op when no prior/boost is configured (the default).
+     */
+    private applyGraphBoost;
     /**
      * Search using pre-calculated TF-IDF index (fast path).
      */
@@ -15443,31 +16149,184 @@ declare class SearchManager {
     /** Get cost estimates for all search methods. */
     getSearchCostEstimates(query: string): Promise<QueryCostEstimate[]>;
     /**
-     * Phase 10 Sprint 4: Get the query cost estimator instance.
-     *
-     * @returns The QueryCostEstimator instance
+     * Phase 10 Sprint 4: Get the query cost estimator instance.
+     *
+     * @returns The QueryCostEstimator instance
+     */
+    getQueryEstimator(): QueryCostEstimator;
+    /**
+     * Feature 3 (Must-Have): Search entities by a natural language time expression.
+     *
+     * Parses the query using chrono-node and returns entities whose
+     * `createdAt` or `lastModified` timestamp falls within the resolved range.
+     *
+     * Returns an empty array if the expression cannot be parsed.
+     *
+     * @param query - Natural language temporal expression, e.g. "last hour", "since yesterday"
+     * @param options - Optional field and undated-entity configuration
+     * @returns Entities matching the time range, sorted oldest-first
+     *
+     * @example
+     * ```typescript
+     * const recentEntities = await manager.searchByTime('last 10 minutes');
+     * const todayEntities  = await manager.searchByTime('today');
+     * const rangedEntities = await manager.searchByTime('between Monday and Wednesday');
+     * ```
+     */
+    searchByTime(query: string, options?: TemporalSearchOptions): Promise<Entity[]>;
+}
+
+/**
+ * Symbolic Search Layer - metadata-based filtering using structured predicates.
+ * @module search/SymbolicSearch
+ */
+
+/**
+ * Result from symbolic search with match score.
+ */
+interface SymbolicResult {
+    entity: Entity;
+    score: number;
+    matchedFilters: string[];
+}
+/** Filters entities using structured metadata predicates (tags, types, dates, importance, hierarchy). */
+declare class SymbolicSearch {
+    /** Filter entities using AND-combined metadata predicates. */
+    search(entities: readonly Entity[], filters: SymbolicFilters): SymbolicResult[];
+    /** @internal Evaluate all filters against an entity. */
+    private evaluateFilters;
+    /** Get entities matching a specific tag. */
+    byTag(entities: readonly Entity[], tag: string): Entity[];
+    /** Get entities of a specific type. */
+    byType(entities: readonly Entity[], entityType: string): Entity[];
+    /** Get entities within importance range. */
+    byImportance(entities: readonly Entity[], min: number, max: number): Entity[];
+}
+
+/**
+ * Hybrid Search Manager - orchestrates semantic, lexical, symbolic, and
+ * (optionally) graph-connectivity search layers.
+ * @module search/HybridSearchManager
+ */
+
+declare const DEFAULT_HYBRID_WEIGHTS: {
+    semantic: number;
+    lexical: number;
+    symbolic: number;
+};
+/** Default number of top results whose neighbors are expanded. */
+declare const DEFAULT_NEIGHBOR_TOP_K = 10;
+/** Default damping applied to a neighbor's inherited combined score. */
+declare const DEFAULT_NEIGHBOR_DAMPING = 0.3;
+/**
+ * Matched-layer union including the graph-connectivity channel.
+ *
+ * @deprecated The canonical `HybridSearchResult['matchedLayers']` union
+ * (src/types) now includes `'graph'`. Use
+ * `HybridSearchResult['matchedLayers'][number]` instead. Kept as an alias
+ * for back-compat (exported from the search barrel).
+ */
+type HybridSearchLayer = HybridSearchResult['matchedLayers'][number];
+/**
+ * HybridSearchResult variant whose scores may carry the normalized
+ * graph-connectivity score. Now that the canonical `matchedLayers` union
+ * includes `'graph'`, this type differs from HybridSearchResult only by
+ * the optional `scores.graph` field, so every GraphHybridSearchResult is a
+ * valid HybridSearchResult (and vice versa when the graph layer did not
+ * run). Results produced with the graph channel enabled conform to this
+ * shape.
+ */
+interface GraphHybridSearchResult extends HybridSearchResult {
+    scores: HybridSearchResult['scores'] & {
+        /** Normalized graph-connectivity score. Present when the graph layer ran. */
+        graph?: number;
+    };
+}
+/** One-hop neighbor expansion options (only a single hop is supported). */
+interface NeighborExpansionOptions {
+    /** Number of hops to expand. Only 1 is supported. */
+    hops: 1;
+    /** Number of top-ranked results to expand from (default: 10). */
+    topK?: number;
+    /** Damping factor applied to the parent's combined score (default: 0.3). */
+    damping?: number;
+}
+/** Additive graph-channel options for hybrid search. All default off. */
+interface GraphHybridOptions {
+    /**
+     * Weight for the graph-connectivity channel (normalized PageRank via
+     * GraphRankPrior). Default 0 = channel disabled. Requires a GraphRankPrior
+     * to have been passed to the constructor.
+     */
+    graphWeight?: number;
+    /**
+     * One-hop neighbor expansion: after scoring, neighbors of the top-K
+     * results are appended with a damped combined score and re-sorted.
+     * Requires a GraphRankPrior. Off unless provided.
+     */
+    expandNeighbors?: NeighborExpansionOptions;
+}
+/**
+ * Combines semantic, lexical, symbolic, and (optionally) graph-connectivity
+ * search layers with configurable weights.
+ */
+declare class HybridSearchManager {
+    private semanticSearch;
+    private rankedSearch;
+    private graphPrior;
+    private defaults;
+    private symbolicSearch;
+    /**
+     * @param semanticSearch - Semantic layer (null = layer disabled)
+     * @param rankedSearch - Lexical layer (TF-IDF/BM25)
+     * @param graphPrior - Optional graph-connectivity signal provider; when
+     *   absent, the graph channel and neighbor expansion are inert
+     * @param defaults - Default per-search graph options (e.g. env-configured
+     *   graphWeight); per-call options override these
+     */
+    constructor(semanticSearch: SemanticSearch | null, rankedSearch: RankedSearch, graphPrior?: GraphRankPrior | null, defaults?: GraphHybridOptions);
+    /**
+     * Perform hybrid search combining all layers.
+     *
+     * When the graph channel or expandNeighbors is enabled, matchedLayers may
+     * include 'graph' and results additionally conform to
+     * GraphHybridSearchResult (`scores.graph` carries the normalized
+     * graph-connectivity score).
+     */
+    search(graph: ReadonlyKnowledgeGraph, query: string, options?: Partial<HybridSearchOptions> & GraphHybridOptions): Promise<HybridSearchResult[]>;
+    /**
+     * Execute semantic search layer.
+     */
+    private executeSemanticSearch;
+    /**
+     * Execute lexical search layer (TF-IDF/BM25).
+     */
+    private executeLexicalSearch;
+    /**
+     * Execute symbolic search layer.
+     */
+    private executeSymbolicSearch;
+    /**
+     * Merge results from all layers.
      */
-    getQueryEstimator(): QueryCostEstimator;
+    private mergeResults;
     /**
-     * Feature 3 (Must-Have): Search entities by a natural language time expression.
-     *
-     * Parses the query using chrono-node and returns entities whose
-     * `createdAt` or `lastModified` timestamp falls within the resolved range.
-     *
-     * Returns an empty array if the expression cannot be parsed.
-     *
-     * @param query - Natural language temporal expression, e.g. "last hour", "since yesterday"
-     * @param options - Optional field and undated-entity configuration
-     * @returns Entities matching the time range, sorted oldest-first
+     * One-hop neighbor expansion: append unseen neighbors of the top-K results
+     * with a damped combined score (`damping * parent.combined`), tagged with
+     * matchedLayers ['graph'], then re-sort and re-apply the limit.
      *
-     * @example
-     * ```typescript
-     * const recentEntities = await manager.searchByTime('last 10 minutes');
-     * const todayEntities  = await manager.searchByTime('today');
-     * const rangedEntities = await manager.searchByTime('between Monday and Wednesday');
-     * ```
+     * Neighbors already present in the result set are never duplicated.
      */
-    searchByTime(query: string, options?: TemporalSearchOptions): Promise<Entity[]>;
+    private expandOneHop;
+    /**
+     * Search with full entity resolution.
+     * Alias for search() since we now always resolve entities.
+     */
+    searchWithEntities(graph: ReadonlyKnowledgeGraph, query: string, options?: Partial<HybridSearchOptions> & GraphHybridOptions): Promise<HybridSearchResult[]>;
+    /**
+     * Get the symbolic search instance for direct access.
+     */
+    getSymbolicSearch(): SymbolicSearch;
 }
 
 /**
@@ -16748,78 +17607,6 @@ declare class TFIDFEventSync {
     private handleEntityDeleted;
 }
 
-/**
- * Symbolic Search Layer - metadata-based filtering using structured predicates.
- * @module search/SymbolicSearch
- */
-
-/**
- * Result from symbolic search with match score.
- */
-interface SymbolicResult {
-    entity: Entity;
-    score: number;
-    matchedFilters: string[];
-}
-/** Filters entities using structured metadata predicates (tags, types, dates, importance, hierarchy). */
-declare class SymbolicSearch {
-    /** Filter entities using AND-combined metadata predicates. */
-    search(entities: readonly Entity[], filters: SymbolicFilters): SymbolicResult[];
-    /** @internal Evaluate all filters against an entity. */
-    private evaluateFilters;
-    /** Get entities matching a specific tag. */
-    byTag(entities: readonly Entity[], tag: string): Entity[];
-    /** Get entities of a specific type. */
-    byType(entities: readonly Entity[], entityType: string): Entity[];
-    /** Get entities within importance range. */
-    byImportance(entities: readonly Entity[], min: number, max: number): Entity[];
-}
-
-/**
- * Hybrid Search Manager - orchestrates semantic, lexical, and symbolic search.
- * @module search/HybridSearchManager
- */
-
-declare const DEFAULT_HYBRID_WEIGHTS: {
-    semantic: number;
-    lexical: number;
-    symbolic: number;
-};
-/** Combines semantic, lexical, and symbolic search layers with configurable weights. */
-declare class HybridSearchManager {
-    private semanticSearch;
-    private rankedSearch;
-    private symbolicSearch;
-    constructor(semanticSearch: SemanticSearch | null, rankedSearch: RankedSearch);
-    /** Perform hybrid search combining all three layers. */
-    search(graph: ReadonlyKnowledgeGraph, query: string, options?: Partial<HybridSearchOptions>): Promise<HybridSearchResult[]>;
-    /**
-     * Execute semantic search layer.
-     */
-    private executeSemanticSearch;
-    /**
-     * Execute lexical search layer (TF-IDF/BM25).
-     */
-    private executeLexicalSearch;
-    /**
-     * Execute symbolic search layer.
-     */
-    private executeSymbolicSearch;
-    /**
-     * Merge results from all three layers.
-     */
-    private mergeResults;
-    /**
-     * Search with full entity resolution.
-     * Alias for search() since we now always resolve entities.
-     */
-    searchWithEntities(graph: ReadonlyKnowledgeGraph, query: string, options?: Partial<HybridSearchOptions>): Promise<HybridSearchResult[]>;
-    /**
-     * Get the symbolic search instance for direct access.
-     */
-    getSymbolicSearch(): SymbolicSearch;
-}
-
 /**
  * Query Analyzer
  *
@@ -17422,6 +18209,11 @@ interface SymbolicSearchResult {
     score: number;
     entity?: Entity;
 }
+/**
+ * Result from the graph-connectivity layer (e.g. normalized PageRank from
+ * GraphRankPrior). Same shape as the symbolic layer results.
+ */
+type GraphLayerResult = SymbolicSearchResult;
 interface ScoredResult {
     entityName: string;
     entity: Entity;
@@ -17429,19 +18221,23 @@ interface ScoredResult {
         semantic: number;
         lexical: number;
         symbolic: number;
+        graph: number;
         combined: number;
     };
-    matchedLayers: ('semantic' | 'lexical' | 'symbolic')[];
+    matchedLayers: ('semantic' | 'lexical' | 'symbolic' | 'graph')[];
     rawScores: {
         semantic?: number;
         lexical?: number;
         symbolic?: number;
+        graph?: number;
     };
 }
 interface HybridWeights {
     semantic: number;
     lexical: number;
     symbolic: number;
+    /** Graph-connectivity channel weight. Default 0 = disabled (legacy behavior). */
+    graph: number;
 }
 declare const DEFAULT_SCORER_WEIGHTS: HybridWeights;
 interface HybridScorerOptions {
@@ -17461,14 +18257,23 @@ declare class HybridScorer {
     setWeights(weights: Partial<HybridWeights>): void;
     /** Min-max normalize scores to 0-1 range. */
     minMaxNormalize(scores: Map<string, number>): Map<string, number>;
-    /** Combine results from all three search layers. */
-    combine(semanticResults: SemanticLayerResult[], lexicalResults: LexicalSearchResult[], symbolicResults: SymbolicSearchResult[], entityMap: Map<string, Entity>): ScoredResult[];
+    /**
+     * Combine results from all search layers.
+     *
+     * @param semanticResults - Semantic similarity layer results
+     * @param lexicalResults - Lexical (TF-IDF/BM25) layer results
+     * @param symbolicResults - Symbolic/metadata layer results
+     * @param entityMap - Entity lookup map by name
+     * @param graphResults - Optional graph-connectivity layer results
+     *   (default: empty — legacy three-layer behavior)
+     */
+    combine(semanticResults: SemanticLayerResult[], lexicalResults: LexicalSearchResult[], symbolicResults: SymbolicSearchResult[], entityMap: Map<string, Entity>, graphResults?: GraphLayerResult[]): ScoredResult[];
     /** Get weights normalized to sum to 1, redistributing for missing layers. */
-    getNormalizedWeights(hasSemantic: boolean, hasLexical: boolean, hasSymbolic: boolean): HybridWeights;
+    getNormalizedWeights(hasSemantic: boolean, hasLexical: boolean, hasSymbolic: boolean, hasGraph?: boolean): HybridWeights;
     /** Combine scores from maps directly (alternative interface). */
-    combineFromMaps(semanticScores: Map<string, number>, lexicalScores: Map<string, number>, symbolicScores: Map<string, number>, entityMap: Map<string, Entity>): ScoredResult[];
+    combineFromMaps(semanticScores: Map<string, number>, lexicalScores: Map<string, number>, symbolicScores: Map<string, number>, entityMap: Map<string, Entity>, graphScores?: Map<string, number>): ScoredResult[];
     /** Calculate combined score for a single entity. */
-    calculateScore(semanticScore: number, lexicalScore: number, symbolicScore: number): number;
+    calculateScore(semanticScore: number, lexicalScore: number, symbolicScore: number, graphScore?: number): number;
 }
 
 /**
@@ -20456,6 +21261,16 @@ declare class PatternDetector {
  * @module agent/RuleEvaluator
  */
 
+/**
+ * Simple rule interface for demonstration.
+ */
+interface Rule$1 {
+    condition: {
+        type: string;
+        field: string;
+        value: unknown;
+    };
+}
 /**
  * Evaluates rule conditions against entities.
  *
@@ -20495,6 +21310,14 @@ declare class RuleEvaluator {
      * Get cache size for monitoring.
      */
     getCacheSize(): number;
+    /**
+     * Evaluates a simple rule against a set of facts.
+     *
+     * @param rule - Rule to evaluate
+     * @param facts - Facts to check against
+     * @returns True if the rule evaluates to true
+     */
+    evaluateRule(rule: Rule$1, facts: Record<string, unknown>): boolean;
 }
 
 /**
@@ -22785,9 +23608,37 @@ declare class MultiAgentMemoryManager extends EventEmitter {
  * Session Checkpoint Manager
  *
  * Provides session checkpointing, crash recovery, and sleep/wake
- * functionality for agent memory sessions. Checkpoints capture
- * working memory state and decay snapshots, stored as observations
- * on the session entity.
+ * functionality for agent memory sessions. Checkpoints are persisted as
+ * real graph structure instead of JSON blobs, so checkpoint content is
+ * queryable and traversable:
+ *
+ * - Each checkpoint is its own `entityType: 'session-checkpoint'` entity
+ *   (name = checkpoint id `checkpoint_{sessionId}_{timestamp}`), with
+ *   `parentId` set to the session entity for hierarchy integration.
+ * - Scalar fields are human-readable observation lines:
+ *   `[session-id]: <id>`, `[label]: <name>` (when present), and
+ *   `[created-at]: <ISO timestamp>`.
+ * - The working-memory snapshot is one line per memory:
+ *   `[working-memory]: <JSON-name>` for membership (order-preserving) and
+ *   `[decay]: <JSON-name>=<importance>` for the importance snapshot —
+ *   names are JSON-encoded so arbitrary strings (equals signs, newlines,
+ *   unicode) roundtrip.
+ * - Arbitrary metadata roundtrips via `[meta]: <JSON-key>=<JSON-value>`
+ *   lines (key and value JSON-encoded separately).
+ * - Relations wire it together: session —`has_checkpoint`→ checkpoint,
+ *   and checkpoint —`snapshots`→ each working-memory entity that still
+ *   exists at write time. Observation lines remain the source of truth
+ *   for the snapshot content (so a checkpoint survives working-memory
+ *   deletion, whose cascade drops the `snapshots` relation).
+ *
+ * Ordering: `listCheckpoints` sorts by the `[created-at]` scalar (newest
+ * first, ties broken by the numeric id suffix) — the module only ever
+ * needs "latest checkpoint", so no `precedes` chain is maintained.
+ *
+ * Legacy `[CHECKPOINT] {json}` observations on session entities remain
+ * decodable via `decodeLegacyCheckpoint` and are auto-migrated to the
+ * decomposed shape on read; use `migrateLegacySessionCheckpoints` for
+ * bulk migration.
  *
  * @module agent/SessionCheckpoint
  */
@@ -22814,16 +23665,26 @@ interface SessionCheckpointData {
         metadata: Record<string, unknown>;
     };
 }
+/** Entity type for decomposed checkpoint entities. */
+declare const SESSION_CHECKPOINT_ENTITY_TYPE = "session-checkpoint";
+/** Relation type: session —has_checkpoint→ checkpoint entity. */
+declare const HAS_CHECKPOINT_RELATION = "has_checkpoint";
+/** Relation type: checkpoint —snapshots→ working-memory entity. */
+declare const SNAPSHOTS_RELATION = "snapshots";
 /**
  * Manages session checkpoints for crash recovery and sleep/wake.
  *
- * Stores checkpoint data as JSON-serialized observations on the
- * session entity, prefixed with `[CHECKPOINT]`. This avoids
- * requiring a separate storage mechanism.
+ * Persists each checkpoint as a dedicated `session-checkpoint` entity
+ * linked to its session via a `has_checkpoint` relation (see the module
+ * doc for the full decomposed schema). Legacy JSON-blob checkpoints
+ * stored as `[CHECKPOINT]` observations on session entities are
+ * auto-migrated on read.
  *
  * @example
  * ```typescript
- * const mgr = new SessionCheckpointManager(storage, workingMemory, decayEngine);
+ * const mgr = new SessionCheckpointManager(
+ *   storage, workingMemory, decayEngine, entityManager, relationManager
+ * );
  *
  * // Create a checkpoint
  * const cp = await mgr.checkpoint('session_123', 'before-experiment');
@@ -22842,13 +23703,15 @@ declare class SessionCheckpointManager {
     private readonly storage;
     private readonly workingMemoryManager;
     private readonly decayEngine;
-    constructor(storage: IGraphStorage, workingMemoryManager: WorkingMemoryManager, decayEngine: DecayEngine);
+    private readonly entityManager;
+    private readonly relationManager;
+    constructor(storage: IGraphStorage, workingMemoryManager: WorkingMemoryManager, decayEngine: DecayEngine, entityManager: EntityManager, relationManager: RelationManager);
     /**
      * Create a checkpoint for a session.
      *
      * Captures the current working memory entity names and their
-     * importance values, storing the data as a JSON-serialized
-     * observation on the session entity.
+     * importance values, persisting them as a dedicated
+     * `session-checkpoint` entity plus linking relations.
      *
      * @param sessionId - Session to checkpoint
      * @param name - Optional user-provided label
@@ -22871,8 +23734,10 @@ declare class SessionCheckpointManager {
     /**
      * List all checkpoints for a session.
      *
-     * Parses checkpoint observations from the session entity and
-     * returns them sorted by timestamp (newest first).
+     * Collects `session-checkpoint` entities linked to the session via
+     * `has_checkpoint` relations and returns them sorted by creation time
+     * (newest first). Legacy `[CHECKPOINT]` blob observations found on the
+     * session entity are auto-migrated to the decomposed shape first.
      *
      * @param sessionId - Session to list checkpoints for
      * @returns Array of checkpoint data, newest first
@@ -22919,24 +23784,71 @@ declare class SessionCheckpointManager {
      */
     private getSessionEntity;
     /**
-     * Parse checkpoint observations from a session entity.
-     * Returns checkpoints sorted newest first.
+     * Collect decomposed checkpoint entities for a session via its
+     * `has_checkpoint` relations. Returns checkpoints sorted newest first.
+     * @internal
+     */
+    private collectCheckpoints;
+    /**
+     * Auto-migrate any legacy `[CHECKPOINT]` blob observations on the given
+     * session entity to the decomposed shape, stripping the migrated blobs
+     * from the session's observations. Malformed blobs are left in place
+     * (they were already skipped by the legacy parser). Returns the
+     * migrated checkpoints (empty when nothing was migrated).
      * @internal
      */
-    private parseCheckpoints;
+    private migrateSessionLegacyCheckpoints;
     /**
-     * Find a checkpoint by ID across all sessions.
+     * Find a checkpoint by ID. Checkpoint IDs double as entity names, so
+     * the decomposed lookup is O(1); when the entity is missing, sessions
+     * still carrying legacy blobs are migrated and re-checked.
      * @internal
      */
     private findCheckpointById;
 }
+/**
+ * Scan every session entity and migrate any legacy `[CHECKPOINT] {json}`
+ * blob observations to the decomposed graph shape (checkpoint entities +
+ * `has_checkpoint` / `snapshots` relations), mirroring
+ * `migrateLegacyProcedures`.
+ *
+ * @returns Number of checkpoints migrated.
+ */
+declare function migrateLegacySessionCheckpoints(entityManager: EntityManager, relationManager: RelationManager): Promise<number>;
+/**
+ * Pure decoder for a single legacy `[CHECKPOINT] {json}` observation
+ * line. Returns null when the line is not a well-formed legacy blob.
+ *
+ * @deprecated Legacy decoder — kept for reading pre-decomposition
+ * observations. `SessionCheckpointManager` auto-migrates such blobs on
+ * read; new code should go through `SessionCheckpointManager`.
+ */
+declare function decodeLegacyCheckpoint(observation: string): SessionCheckpointData | null;
 
 /**
  * Work Thread Manager
  *
- * Manages work threads for coordinating tasks across agents.
- * Threads are stored as entities with entityType 'work_thread',
- * using relations for parent-child and blocking relationships.
+ * Manages work threads for coordinating tasks across agents. Threads are
+ * persisted as real graph structure instead of JSON blobs, so thread
+ * content is queryable and traversable:
+ *
+ * - Each thread is an `entityType: 'work_thread'` entity (name =
+ *   `thread.id`). Its observations carry human-readable scalar lines
+ *   (`[title]: Ship feature X`, `[status]: active`, `[owner]: agent_1`,
+ *   `[priority]: 8`, `[created-at]: …`, `[updated-at]: …`) plus the
+ *   free-text description as a plain observation.
+ * - Custom metadata encodes one `[meta]: <JSON-key>=<JSON-value>` line per
+ *   entry — key and value are JSON-encoded separately so arbitrary strings
+ *   (equals signs, newlines, unicode) roundtrip.
+ * - Cross-thread references are real relations, not payload fields:
+ *   thread —`child_of`→ parent thread, and thread —`blocked_by`→ each
+ *   blocker thread. `load()` rehydrates `parentId` / `blockedBy` from
+ *   those relations.
+ *
+ * Legacy single-JSON-observation threads (the pre-decomposition shape)
+ * remain decodable via `decodeLegacyWorkThread` and are auto-migrated to
+ * the decomposed shape on `load()`; use `migrateLegacyWorkThreads` for
+ * bulk migration.
  *
  * @module agent/WorkThreadManager
  */
@@ -23001,6 +23913,12 @@ interface CreateWorkThreadOptions {
     /** Custom metadata */
     metadata?: Record<string, unknown>;
 }
+/** Relation type for parent-child thread relationships */
+declare const CHILD_OF_RELATION = "child_of";
+/** Relation type for blocking relationships */
+declare const BLOCKED_BY_RELATION = "blocked_by";
+/** Entity type for work thread entities */
+declare const WORK_THREAD_ENTITY_TYPE = "work_thread";
 /**
  * Manages work thread lifecycle and coordination.
  *
@@ -23027,8 +23945,15 @@ declare class WorkThreadManager {
      * Load existing work threads from storage into memory.
      *
      * Scans the graph for entities with entityType 'work_thread' and
-     * rehydrates the in-memory Map from their serialized observations.
-     * Must be called after construction to restore state from a previous session.
+     * rehydrates the in-memory Map from their scalar observation lines,
+     * deriving `parentId` / `blockedBy` from `child_of` / `blocked_by`
+     * relations. Must be called after construction to restore state from a
+     * previous session.
+     *
+     * **Side effect (auto-migration):** threads still stored in the legacy
+     * single-JSON-observation shape are decoded with the legacy decoder and
+     * rewritten in place to the decomposed shape (scalar lines + relations)
+     * before returning.
      *
      * @returns Number of threads loaded
      */
@@ -23132,14 +24057,30 @@ declare class WorkThreadManager {
      */
     private detectCycles;
     /**
-     * Persist a thread's state to storage by updating its entity observation.
+     * Persist a thread's state to storage by rewriting its scalar
+     * observation lines. Relations (`child_of` / `blocked_by`) are managed
+     * by `create` / `block` / `unblock`, not here.
      */
     private persistThread;
-    /**
-     * Serialize a thread to a plain object for JSON storage.
-     */
-    private serializeThread;
 }
+/**
+ * Scan every `entityType: 'work_thread'` entity and migrate any that
+ * still use the legacy single-JSON-observation encoding to the
+ * decomposed shape (scalar observation lines + `child_of` / `blocked_by`
+ * relations). Mirrors `migrateLegacyProcedures`.
+ *
+ * @returns Number of threads migrated.
+ */
+declare function migrateLegacyWorkThreads(storage: IGraphStorage): Promise<number>;
+/**
+ * Pure decoder for the legacy single-JSON-observation thread shape
+ * (`JSON.stringify({ title, status, … })` in `observations[0]`).
+ *
+ * @deprecated Legacy decoder — kept for reading pre-decomposition
+ * entities. `WorkThreadManager.load()` auto-migrates such entities; new
+ * code should go through `WorkThreadManager`.
+ */
+declare function decodeLegacyWorkThread(id: string, observations: string[]): WorkThread | null;
 
 /**
  * Collaborative Memory Synthesis
@@ -23316,6 +24257,13 @@ declare class CollaborativeSynthesis {
  * Manages user profiles stored as Entity instances with entityType 'profile'.
  * Observations are tagged [static] or [dynamic] to classify facts.
  *
+ * **Contract (graph-core):** the `[static]`/`[dynamic]` prefixes are the
+ * accepted line-per-observation format — one human-readable fact per
+ * observation, individually indexable and searchable. This is NOT the
+ * JSON-blob antipattern that ProcedureStore/WorkThreadManager/
+ * SessionCheckpoint were migrated away from (a whole structured record
+ * serialized into a single opaque observation); no decomposition needed.
+ *
  * @module agent/ProfileManager
  */
 
@@ -23650,6 +24598,7 @@ declare class AgentMemoryManager extends EventEmitter {
     private _profileManager?;
     private _entityManager?;
     private _observationManager?;
+    private _relationManager?;
     private _workThreadManager?;
     private _checkpointManager?;
     constructor(storage: IGraphStorage, config?: AgentMemoryConfig);
@@ -23678,6 +24627,10 @@ declare class AgentMemoryManager extends EventEmitter {
      * Internal ObservationManager, created on demand from the underlying storage.
      */
     private get observationManager();
+    /**
+     * Internal RelationManager, created on demand from the underlying storage.
+     */
+    private get relationManager();
     /** Profile manager for persistent user/agent profile facts */
     get profileManager(): ProfileManager;
     /**
@@ -24823,7 +25776,10 @@ declare class ToolCallObserver {
  * First-class type definitions for stored, executable procedures —
  * skills / how-to sequences distinct from semantic facts and episodic
  * events. Procedures are persisted as `entityType: 'procedure'` entities
- * with the step list encoded in `observations` as JSON.
+ * whose steps are decomposed into `entityType: 'procedure-step'` child
+ * entities linked via `has_step` / `precedes` / `has_fallback` relations
+ * (see `agent/procedural/ProcedureStore`); step fields are stored as
+ * one human-readable observation line each, not JSON blobs.
  *
  * @module types/procedure
  */
@@ -24973,7 +25929,7 @@ type InvocationResult = {
 declare class ProcedureManager {
     private readonly store;
     private readonly successRateAlpha;
-    constructor(entityManager: EntityManager, config?: ProcedureManagerConfig);
+    constructor(entityManager: EntityManager, relationManager: RelationManager, config?: ProcedureManagerConfig);
     /**
      * Persist a new procedure. Auto-generates `id` (and falls back to it
      * for `name`) when caller omits them. Throws if the id collides — the
@@ -25967,6 +26923,417 @@ declare class ActiveRetrievalController {
     private estimateCoverage;
 }
 
+/**
+ * Cue–Tag–Content (CTC) associative memory graph.
+ *
+ * Implements the heterogeneous memory graph `M = (C, V, R)` of MRAgent
+ * ("Memory is Reconstructed, Not Retrieved", §3.1). Cues and contents are nodes;
+ * associations are typed `(cue, tag, content)` triples where the **tag** mediates
+ * retrieval. The class exposes the paper's induced mapping operators (Eq. 5/8/9)
+ * that the active reconstruction loop composes into traversal actions.
+ *
+ * @module agent/reconstruction/CueTagContentGraph
+ * @experimental
+ */
+
+/** Normalise cue/tag surface text into a stable lookup id. */
+declare function normalizeKey(text: string): string;
+/**
+ * In-memory associative memory graph with O(1) mapping operators.
+ *
+ * Indexes are maintained incrementally on `addTriple`, so traversal operators
+ * never scan the full relation set.
+ */
+declare class CueTagContentGraph {
+    private readonly cues;
+    private readonly tags;
+    private readonly contents;
+    private readonly tripleSet;
+    /** φ_{c→g}: cue id → set of associated tag ids. */
+    private readonly cueTags;
+    /** φ_{(c,g)→v}: (cue,tag) key → set of content ids. */
+    private readonly cueTagContents;
+    /** φ_{v→(c,g)}: content id → list of (cue,tag) pairs (reverse traversal). */
+    private readonly contentCueTags;
+    /** φ_{τ→e}: topic content id → set of episode content ids. */
+    private readonly topicEpisodes;
+    /** Insert (or fetch) a cue node, returning its id. */
+    addCue(text: string): string;
+    /** Insert (or fetch) a tag node, returning its id. */
+    addTag(text: string): string;
+    /**
+     * Insert (or replace) a content node. The caller supplies a stable id so that
+     * episodic/semantic/topic nodes can be cross-referenced (timeline, topic links).
+     */
+    addContent(node: ContentNode): ContentNode;
+    /** Connect a topic node to one of its constituent episodes (topic → episode). */
+    linkTopicEpisode(topicId: string, episodeId: string): void;
+    /**
+     * Add a `(cue, tag, content)` association. Cue and tag are created on demand;
+     * the content node must already exist (added via {@link addContent}).
+     */
+    addTriple(cueText: string, tagText: string, contentId: string): void;
+    /**
+     * φ_{c→g}(c) — activate candidate associative tags from a cue.
+     * Accepts a cue surface form or id.
+     */
+    tagsForCue(cue: string): TagNode[];
+    /**
+     * φ_{(c,g)→v}(c, g) — retrieve content conditioned on a cue and a selected tag.
+     * Optionally restrict to a single memory layer.
+     */
+    contentsForCueTag(cue: string, tag: string, layer?: ContentLayer): ContentNode[];
+    /**
+     * φ_{v→(c,g)}(v) — reverse traversal: surface the cues and tags associated with
+     * a retrieved content node, enabling the agent to redirect its trajectory.
+     */
+    cueTagsForContent(contentId: string): Array<{
+        cue: CueNode;
+        tag: TagNode;
+    }>;
+    /** φ_{τ→e}(τ) — descend from a topic node to its constituent episodes. */
+    episodesForTopic(topicId: string): ContentNode[];
+    /** Fetch a content node by id. */
+    getContent(id: string): ContentNode | undefined;
+    /** Look up a cue node by surface form or id. */
+    getCue(text: string): CueNode | undefined;
+    /** All content nodes in a given layer (timeline order for episodic). */
+    contentsByLayer(layer: ContentLayer): ContentNode[];
+    /**
+     * Match a free-form cue phrase against the stored cue set, returning ids of
+     * cues whose surface form exactly equals or contains the (normalised) phrase.
+     * Used to build the initial active set `Z(0)` from a query.
+     */
+    matchCues(phrase: string): CueNode[];
+    /** Number of cues / tags / contents / triples currently stored. */
+    stats(): {
+        cues: number;
+        tags: number;
+        contents: number;
+        triples: number;
+    };
+    /** Export a structural snapshot (e.g. to persist alongside JSONL storage). */
+    toSnapshot(): CTCGraphSnapshot;
+    /** Rebuild a graph from a snapshot produced by {@link toSnapshot}. */
+    static fromSnapshot(snap: CTCGraphSnapshot): CueTagContentGraph;
+}
+
+/**
+ * Memory toolkit for controlled traversal of the Cue–Tag–Content graph.
+ *
+ * Implements the seven typed traversal operators of MRAgent (paper Table 4).
+ * Each tool corresponds to a typed mapping between memory components, letting an
+ * agent (LLM- or heuristic-driven) explicitly control the direction and
+ * granularity of memory access rather than retrieving a fixed similarity set.
+ *
+ * @module agent/reconstruction/MemoryToolkit
+ * @experimental
+ */
+
+/** Result of the keyword/context introspection tools. */
+interface EventKeywords {
+    cues: string[];
+    tags: string[];
+}
+/**
+ * The MRAgent traversal toolkit. Stateless over the graph — each call is a pure
+ * mapping operator invocation, which keeps memory access interpretable.
+ */
+declare class MemoryToolkit {
+    private readonly graph;
+    constructor(graph: CueTagContentGraph);
+    /**
+     * `query_tag_events` — φ_{(c,g)→e}: retrieve episodic events associated with a
+     * cue–tag pair. The workhorse for multi-hop questions (paper Table 6).
+     */
+    queryTagEvents(cue: string, tag: string): ContentNode[];
+    /**
+     * `query_conversation_time` — φ_{e→t}: return the conversation timestamp of an
+     * episodic event. Primary operator for temporal questions.
+     */
+    queryConversationTime(eventId: string): string | undefined;
+    /**
+     * `query_event_keywords` — φ_{e→(c,g)}: extract the cues and tags associated
+     * with an episodic event (reverse traversal to discover new retrieval paths).
+     */
+    queryEventKeywords(eventId: string): EventKeywords;
+    /**
+     * `query_event_context` — φ_{e→ctx}: retrieve the textual context surrounding
+     * an episodic event (the event's own text plus its temporal neighbours on the
+     * unified timeline).
+     */
+    queryEventContext(eventId: string, window?: number): string;
+    /**
+     * `query_personal_information` — φ_{cs→gs}: return the semantic aspects (tags)
+     * associated with a person entity, e.g. `preference`, `occupation`.
+     */
+    queryPersonalInformation(person: string): TagNode[];
+    /**
+     * `query_personal_aspect` — φ_{(cs,gs)→vs}: retrieve the semantic content for a
+     * `(person, aspect)` pair without scanning long episodic histories.
+     */
+    queryPersonalAspect(person: string, aspect: string): ContentNode[];
+    /**
+     * `query_topic_events` — φ_{τ→e}: retrieve episodic events associated with a
+     * topic node, enabling efficient top-down localisation.
+     */
+    queryTopicEvents(topicId: string): ContentNode[];
+}
+
+/**
+ * Memory distillation pipeline — populates the Cue–Tag–Content graph from raw
+ * dialogue (MRAgent §3.3 / Appendix B.1).
+ *
+ * The pipeline mirrors the paper's element-generation phase:
+ *   1. **Rewrite** raw turns into self-contained sentences — pronoun resolution,
+ *      temporal normalisation (`YYYY-MM-DD`), and episodic segmentation.
+ *   2. **Tag** each episode with a short associative phrase (`T_LLM`).
+ *   3. **Cue** extraction — fine-grained entities/attributes (`K_LLM`).
+ *   4. **Semantic** extraction — person-anchored stable facts (`S_LLM`).
+ *   5. **Topic** abstraction — recurring patterns across episodes (`A_LLM`).
+ *
+ * When an {@link LLMProvider} is supplied the pipeline uses the paper's prompts
+ * (Appendix E); otherwise it falls back to deterministic heuristics so the
+ * feature works with zero configuration — matching the LLM-optional pattern used
+ * elsewhere in the codebase (e.g. `LLMQueryPlanner`).
+ *
+ * @module agent/reconstruction/MemoryDistiller
+ * @experimental
+ */
+
+declare class MemoryDistiller {
+    private readonly llm?;
+    private readonly keywords;
+    constructor(llm?: LLMProvider | undefined);
+    /** Run the full distillation pipeline over a dialogue. */
+    distill(turns: DialogueTurn[]): Promise<DistillationResult$1>;
+    /**
+     * Build (or extend) a {@link CueTagContentGraph} from a distillation result.
+     * Episodic, semantic and topic layers are populated in one pass.
+     */
+    buildGraph(result: DistillationResult$1, graph?: CueTagContentGraph): CueTagContentGraph;
+    private distillWithLLM;
+    private distillHeuristic;
+    /** Cluster episodes by their most salient shared cue into topic nodes. */
+    private deriveTopics;
+}
+/** Extract the first JSON object/array from a possibly noisy LLM completion. */
+declare function extractJson<T>(raw: string): T | undefined;
+
+/**
+ * Active memory reconstruction (MRAgent §4 / Algorithm 1).
+ *
+ * Rather than a one-shot "retrieve-then-reason" lookup, the reconstructor
+ * formulates memory access as a stateful, multi-step process over the
+ * Cue–Tag–Content graph. It maintains a reconstruction state `S(t) = (Z(t),
+ * H(t))` — an active set of candidate elements `Z` and the accumulated
+ * reconstructed context `H` — and iterates:
+ *
+ *   1. **Action selection** `f_select(x, H, Z)` — choose promising traversal
+ *      directions (forward cue→tag / (cue,tag)→content, reverse content→(cue,tag),
+ *      top-down topic→episode), reducing noise vs. exhaustive expansion.
+ *   2. **Controlled traversal** — execute the selected actions to produce
+ *      candidates `Z̃(t+1)`.
+ *   3. **Routing + state update** `f_route(x, H, Z̃)` — keep the candidates most
+ *      relevant to the query and prune the rest, then fold them into `H`.
+ *   4. **Stopping** — terminate once accumulated evidence suffices.
+ *
+ * The default policy is a deterministic, embedding-free heuristic so the feature
+ * works with zero configuration. When an {@link LLMProvider} is supplied the
+ * final answer is synthesised by the LLM under the paper's QA prompt (Appendix E),
+ * and routing is LLM-assisted; otherwise an extractive answer is returned.
+ *
+ * @module agent/reconstruction/MemoryReconstructor
+ * @experimental
+ */
+
+declare class MemoryReconstructor {
+    private readonly graph;
+    private readonly llm?;
+    /**
+     * Optional semantic similarity in `[0, 1]` (e.g. `SemanticSearch`), used to
+     * rank candidates during routing/answer when a live-store backing supplies
+     * it. Falls back to lexical overlap when absent.
+     */
+    private readonly similarityFn?;
+    private readonly toolkit;
+    private readonly keywords;
+    constructor(graph: CueTagContentGraph, llm?: LLMProvider | undefined, 
+    /**
+     * Optional semantic similarity in `[0, 1]` (e.g. `SemanticSearch`), used to
+     * rank candidates during routing/answer when a live-store backing supplies
+     * it. Falls back to lexical overlap when absent.
+     */
+    similarityFn?: ((query: string, text: string) => Promise<number>) | undefined);
+    /** Run active reconstruction for a query (Algorithm 1). */
+    reconstruct(query: string, options?: ReconstructionOptions): Promise<ReconstructionResult>;
+    private extractQueryCues;
+    /**
+     * Select promising traversal directions from the current active set. The
+     * heuristic prefers to advance cues → tags → content, expands retrieved
+     * content both reverse (new cues/tags) and top-down (topic → episode).
+     */
+    private selectActions;
+    private traverse;
+    /**
+     * Rank candidate content by lexical relevance to the query, drop already-seen
+     * nodes, and keep the top `budget`. This is the noise-pruning step that keeps
+     * the reconstructed context focused.
+     */
+    private route;
+    /**
+     * Relevance of a candidate to the query. Uses semantic similarity when a
+     * backing supplies it (embedding-based, captures paraphrase), otherwise falls
+     * back to lexical keyword overlap.
+     */
+    private relevance;
+    private shouldStop;
+    private answer;
+}
+
+/**
+ * Bridge between the Cue–Tag–Content graph and MemoryJS's live memory modules.
+ *
+ * The paper organises memory into multi-granular layers (episodic / semantic /
+ * topic) that mirror cognitive memory types (§3.2). MemoryJS already implements
+ * those types, so the bridge persists each CTC content node into the
+ * corresponding module so reconstructed memory is durable and visible to the
+ * rest of the stack:
+ *
+ *   - **Episodic** → first-class `memoryType: 'episodic'` entities stamped with
+ *     the conversation timestamp, so they land on the
+ *     {@link EpisodicMemoryManager} timeline and are temporally linked
+ *     (`precedes`/`follows`).
+ *   - **Semantic** → `memoryType: 'semantic'` fact entities anchored to their
+ *     person entity via a typed relation, and indexed for `SemanticSearch`.
+ *   - **Topic** → topic entities linked to their constituent episodes via a
+ *     `summarizes` relation (queryable through `GraphTraversal`).
+ *
+ * The bridge writes through narrow structural interfaces so it can be driven by
+ * the real `ManagerContext` managers or by fakes in tests.
+ *
+ * @module agent/reconstruction/MemoryGraphBridge
+ * @experimental
+ */
+
+/** Relation type connecting a topic entity to one of its episodes. */
+declare const TOPIC_SUMMARIZES = "summarizes";
+/**
+ * The live-store dependencies the bridge writes through. Satisfied by the
+ * `ManagerContext` managers (`entityManager`, `relationManager`,
+ * `semanticSearch`) or by test doubles.
+ */
+interface ReconstructiveBacking {
+    /** Persist entities (existing names are skipped by `EntityManager`). */
+    createEntities(entities: Entity[]): Promise<unknown>;
+    /** Persist relations. */
+    createRelations(relations: Relation[]): Promise<unknown>;
+    /** Optional semantic similarity in `[0, 1]` for routing/answer ranking. */
+    similarity?(a: string, b: string): Promise<number>;
+    /** Optional: index a freshly-created entity for semantic search. */
+    indexEntity?(entity: Entity): Promise<unknown>;
+    /** Session id used to scope episodes onto the timeline. Default `mragent`. */
+    sessionId?: string;
+}
+/** Summary of what a {@link MemoryGraphBridge.persist} call wrote. */
+interface BridgePersistResult {
+    episodes: number;
+    semanticFacts: number;
+    topics: number;
+    relations: number;
+}
+declare class MemoryGraphBridge {
+    private readonly backing;
+    private readonly sessionId;
+    constructor(backing: ReconstructiveBacking);
+    /** The session id episodes are written under (use with `getTimeline`). */
+    get session(): string;
+    /**
+     * Persist a distillation result into the live store and annotate the in-memory
+     * graph's content nodes with their backing entity names.
+     */
+    persist(result: DistillationResult$1, graph: CueTagContentGraph): Promise<BridgePersistResult>;
+}
+
+/**
+ * Reconstructive memory facade — the public entry point for the MRAgent-style
+ * Cue–Tag–Content associative memory and active reconstruction.
+ *
+ * Wraps the construction pipeline ({@link MemoryDistiller}), the associative
+ * graph ({@link CueTagContentGraph}), the traversal {@link MemoryToolkit}, and
+ * the active {@link MemoryReconstructor} behind one cohesive API:
+ *
+ * ```typescript
+ * const rm = new ReconstructiveMemory();
+ * await rm.ingest([
+ *   { id: 'D1:1', speaker: 'Nate', text: "I won a video game tournament in July." },
+ *   { id: 'D1:2', speaker: 'Caroline', text: "I started a new painting class that month." },
+ * ]);
+ * const result = await rm.reconstruct("What did Caroline do in July?");
+ * console.log(result.answer, result.evidence);
+ * ```
+ *
+ * **Contract (graph-core):** the in-memory {@link CueTagContentGraph} is a
+ * specialized associative *index*, not a second system-of-record. Durability
+ * and graph queryability come from persisting through
+ * {@link MemoryGraphBridge} into the Entity/Relation graph — which is the
+ * default when constructed via `ctx.reconstructiveMemory()` (the context
+ * wires its own `entityManager`/`relationManager`/`semanticSearch` as the
+ * backing). Passing `backing: undefined` opts out and makes the instance
+ * ephemeral; treat that as a testing/short-lived-process mode.
+ *
+ * @module agent/reconstruction/ReconstructiveMemory
+ * @experimental
+ */
+
+/** Configuration for {@link ReconstructiveMemory}. */
+interface ReconstructiveMemoryConfig {
+    /** Optional LLM provider for distillation + answer synthesis. */
+    llmProvider?: LLMProvider;
+    /** Pre-existing graph snapshot to restore from. */
+    snapshot?: CTCGraphSnapshot;
+    /**
+     * Optional live-store backing. When supplied, ingested memory is persisted
+     * into MemoryJS's episodic / semantic / topic modules (durable + searchable),
+     * and semantic similarity is reused for reconstruction routing. When absent,
+     * the facade runs the self-contained in-memory graph.
+     */
+    backing?: ReconstructiveBacking;
+}
+declare class ReconstructiveMemory {
+    private graph;
+    private readonly distiller;
+    private readonly llm?;
+    private readonly bridge?;
+    private lastPersist?;
+    constructor(config?: ReconstructiveMemoryConfig);
+    private readonly backing?;
+    /**
+     * Construction phase: distil raw dialogue into Cue–Tag–Content structure and
+     * merge it into the in-memory graph. When a live-store backing is configured,
+     * the episodic / semantic / topic layers are also persisted into the
+     * corresponding MemoryJS modules. Multiple `ingest` calls accumulate.
+     */
+    ingest(turns: DialogueTurn[]): Promise<DistillationResult$1>;
+    /** Summary of what the most recent `ingest` persisted to the live store. */
+    get lastPersistResult(): BridgePersistResult | undefined;
+    /**
+     * Reconstruction phase: answer a query via active, multi-step traversal of the
+     * memory graph (Algorithm 1).
+     */
+    reconstruct(query: string, options?: ReconstructionOptions): Promise<ReconstructionResult>;
+    /** Direct access to the traversal toolkit for manual graph exploration. */
+    get toolkit(): MemoryToolkit;
+    /** The underlying associative graph (read/inspect cues, tags, contents). */
+    get memoryGraph(): CueTagContentGraph;
+    /** Graph size statistics. */
+    stats(): ReturnType<CueTagContentGraph['stats']>;
+    /** Serialise the current graph (e.g. to persist alongside the knowledge base). */
+    toSnapshot(): CTCGraphSnapshot;
+    /** Replace the current graph with a restored snapshot. */
+    loadSnapshot(snapshot: CTCGraphSnapshot): void;
+}
+
 /**
  * Options for constructing a ManagerContext.
  */
@@ -26005,6 +27372,8 @@ declare class ManagerContext {
     private _graphTraversal?;
     private _searchManager?;
     private _rankedSearch?;
+    private _graphRankPrior?;
+    private _hybridSearchManager?;
     private _ioManager?;
     private _tagManager?;
     private _analyticsManager?;
@@ -26051,6 +27420,7 @@ declare class ManagerContext {
     private _roleAssignmentStore?;
     private _worldModelManager?;
     private _activeRetrieval?;
+    private _reconstructiveMemory?;
     private _accessTracker?;
     private _decayEngine?;
     private _decayScheduler?;
@@ -26174,6 +27544,19 @@ declare class ManagerContext {
     get searchManager(): SearchManager;
     /** RankedSearch - TF-IDF/BM25 ranked search */
     get rankedSearch(): RankedSearch;
+    /**
+     * GraphRankPrior — cached graph-connectivity ranking signal (normalized
+     * PageRank with degree fallback). Built over the existing GraphTraversal
+     * and auto-invalidated via the storage GraphEventEmitter.
+     * @experimental
+     */
+    get graphRankPrior(): GraphRankPrior;
+    /**
+     * HybridSearchManager — semantic + lexical + symbolic (+ optional graph)
+     * layered search. Reads MEMORY_HYBRID_GRAPH_WEIGHT at first access; when
+     * 0/unset (the default), the GraphRankPrior is not attached — zero overhead.
+     */
+    get hybridSearchManager(): HybridSearchManager;
     /**
      * Materialised search views — pre-computed result sets for repeated
      * filter-based queries. Lazy: only constructed on first access (which
@@ -26445,6 +27828,25 @@ declare class ManagerContext {
      * LLM-driven decomposition use `ctx.llmQueryPlanner`.
      */
     get activeRetrieval(): ActiveRetrievalController;
+    /**
+     * `ReconstructiveMemory` — MRAgent-style associative memory ("Memory is
+     * Reconstructed, Not Retrieved"). Builds a Cue–Tag–Content graph from
+     * dialogue (`ingest`) and answers queries via active, multi-step memory
+     * reconstruction (`reconstruct`). Lazy; works zero-config with heuristic
+     * distillation/reconstruction, or pass an `LLMProvider` for the paper's
+     * LLM-driven distillation and answer synthesis.
+     *
+     * @param config Optional LLM provider / restored graph snapshot. Passing a
+     *   config re-instantiates the facade (invalidates the cached instance).
+     */
+    reconstructiveMemory(config?: ReconstructiveMemoryConfig): ReconstructiveMemory;
+    /**
+     * Build a {@link ReconstructiveBacking} that bridges the Cue–Tag–Content
+     * layers to this context's live modules: episodic episodes onto the
+     * `EpisodicMemoryManager` timeline, semantic facts into the entity graph +
+     * `SemanticSearch`, and topic links as relations.
+     */
+    private buildReconstructiveBacking;
     /**
      * TransitionLedger - Append-only audit trail for state changes.
      * Returns null if not enabled via MEMORY_TRANSITION_LEDGER env var.
@@ -26508,6 +27910,7 @@ declare class ManagerContext {
      * - MEMORY_SALIENCE_FREQUENCY_WEIGHT (default: 0.2)
      * - MEMORY_SALIENCE_CONTEXT_WEIGHT (default: 0.2)
      * - MEMORY_SALIENCE_NOVELTY_WEIGHT (default: 0.1)
+     * - MEMORY_SALIENCE_CONNECTIVITY_WEIGHT (default: 0 = disabled)
      */
     get salienceEngine(): SalienceEngine;
     /**
@@ -27842,6 +29245,14 @@ declare class VisibilityResolver {
  * persistence. Suitable as the default backend when no SQLite/Postgres
  * configuration exists, and as the fast/clean fixture in unit tests.
  *
+ * **Contract (graph-core):** this backend is *ephemeral by design* — it is
+ * an in-process turn buffer, not part of the knowledge graph's
+ * system-of-record. Anything that must survive the process or be
+ * queryable/traversable as graph content belongs in `SQLiteBackend`,
+ * which routes through `MemoryEngine` into the Entity/Relation graph.
+ * Do not extend this class with durability features; swap backends
+ * instead (`MEMORY_BACKEND=sqlite`).
+ *
  * Scoring delegates to `DecayEngine.calculatePrdEffectiveImportance` so
  * `get_weighted` returns the same PRD-formula scores that
  * `SQLiteBackend` (T13) will produce.
@@ -28001,11 +29412,29 @@ declare class QueryRewriter {
 /**
  * Procedure Store (3B.4)
  *
- * Persists `Procedure` records as memoryjs entities (`entityType:
- * 'procedure'`). Steps + metadata live in `observations` as a single
- * JSON-encoded line; the rest of the entity carries triggers/successRate
- * via observations and tags. This shape lets procedures roundtrip
- * through both the JSONL and SQLite backends without schema changes.
+ * Persists `Procedure` records as real graph structure instead of JSON
+ * blobs, so procedure content is queryable and traversable:
+ *
+ * - The procedure itself is an `entityType: 'procedure'` entity (name =
+ *   `procedure.id`). Its observations carry the description plus
+ *   human-readable scalar lines (`[success-rate]: 0.85`,
+ *   `[execution-count]: 12`). Tags = `['procedure', ...triggers]`.
+ * - Every step is its own `entityType: 'procedure-step'` entity named
+ *   `${procedureId}::step-${order}` (fallbacks: `${parentStepName}::fallback`,
+ *   recursively). Step observations encode one field per line:
+ *   `[order]: <n>`, `[action]: <action>`, `[timeout]: <ms>`, and one
+ *   `[param]: <JSON-key>=<JSON-value>` line per parameter — key and value
+ *   are JSON-encoded separately so arbitrary strings (equals signs,
+ *   newlines, unicode) roundtrip.
+ * - Relations wire it together: procedure —`has_step`→ each top-level
+ *   step, step —`precedes`→ the next step in sequence, and step
+ *   —`has_fallback`→ its fallback step. Step entities set `parentId` to
+ *   the procedure id for hierarchy integration.
+ *
+ * Legacy JSON-blob procedures (`[procedure-steps]:` / `[procedure-meta]:`
+ * observations) remain decodable via `decodeProcedure` and are
+ * auto-migrated to the decomposed shape on `load()`; use
+ * `migrateLegacyProcedures` for bulk migration.
  *
  * @module agent/procedural/ProcedureStore
  */
@@ -28013,28 +29442,61 @@ declare class QueryRewriter {
 declare const PROCEDURE_ENTITY_TYPE = "procedure";
 declare class ProcedureStore {
     private readonly entityManager;
-    constructor(entityManager: EntityManager);
+    private readonly relationManager;
+    constructor(entityManager: EntityManager, relationManager: RelationManager);
     /**
-     * Persist a new procedure. The entity name = `procedure.id`. Steps and
-     * metadata are encoded as JSON observations alongside any caller-supplied
-     * description observation. Idempotent on duplicate id (relies on
-     * `EntityManager.createEntities` semantics).
+     * Persist a new procedure. The entity name = `procedure.id`; each step
+     * (and recursive fallback) becomes its own `procedure-step` entity
+     * linked via `has_step` / `precedes` / `has_fallback` relations.
+     * Idempotent on duplicate id (relies on `EntityManager.createEntities`
+     * skip-duplicate semantics). Step `order` values are assumed unique
+     * within a procedure (they name the step entities).
      */
     save(procedure: Procedure): Promise<void>;
     /**
-     * Load a procedure by id, or undefined if not found. Tolerant of partial
-     * encodings — steps default to `[]`, meta to zeroed fields.
+     * Load a procedure by id, or undefined if not found. Tolerant of
+     * partial encodings — steps default to `[]`, scalars to zero.
+     *
+     * **Side effect (auto-migration):** when the entity still uses the
+     * legacy JSON-blob encoding (`[procedure-steps]:` observation), it is
+     * decoded with the legacy decoder and then rewritten in place to the
+     * decomposed graph shape (step entities + relations) before returning.
      */
     load(id: string): Promise<Procedure | undefined>;
     /**
-     * Replace an existing procedure's steps + metadata. Throws if the
-     * entity doesn't exist or isn't a procedure.
+     * Replace an existing procedure's steps + metadata. Deletes the
+     * procedure's current step entities (cascading their relations — see
+     * `EntityManager.deleteEntities`) and recreates the step graph from
+     * `procedure.steps`. Throws if the entity doesn't exist.
      */
     update(procedure: Procedure): Promise<void>;
+    /** Create step entities + linking relations for `procedure.steps`. */
+    private createStepGraph;
+    /**
+     * All step entity names reachable from the procedure via `has_step`
+     * then recursive `has_fallback` edges.
+     */
+    private collectStepEntityNames;
+    /**
+     * Load top-level steps via `has_step`, ordered by the `precedes` chain
+     * (preserving the original array order); falls back to a numeric sort
+     * on `[order]` when the chain is incomplete.
+     */
+    private loadSteps;
+    /**
+     * Load one step entity plus its recursive fallback chain. Records the
+     * step's `precedes` successor (among `topSet`) into `successor` when
+     * provided. Returns null when the entity is missing or not a step.
+     */
+    private loadStepTree;
 }
 /**
- * Pure decoder: extracts `Procedure` shape from the observation list.
- * Exported for tests and for callers wanting to introspect raw entities.
+ * Pure decoder for the legacy JSON-blob observation shape
+ * (`[procedure-steps]:` / `[procedure-meta]:` lines).
+ *
+ * @deprecated Legacy decoder — kept for reading pre-decomposition
+ * entities. `ProcedureStore.load()` auto-migrates such entities; new
+ * code should go through `ProcedureStore`.
  */
 declare function decodeProcedure(id: string, observations: string[]): Procedure;
 
@@ -28735,4 +30197,4 @@ declare class LangChainMemoryAdapter {
     clear(): Promise<void>;
 }
 
-export { type ABACCondition, type ABACContext, type ABACDecision, type ABACEffect, type ABACOp, ABACPolicy, type ABACRule, APIKeyStore, type ValidationResult as APIKeyValidationResult, type AcceptDecisionResult, type AccessContext, AccessContextBuilder, type AccessPattern, type AccessStats, AccessTracker, type AccessTrackerConfig, type Action, type ActiveRetrievalConfig, ActiveRetrievalController, type AdaptiveDepthConfig, type AdaptiveReductionResult, type AdaptiveResult, type AddExclusionRuleInput, type AddHeuristicOptions, type AddObservationInput, AddObservationInputSchema, AddObservationsInputSchema, type AddTurnOptions, type AddTurnResult, type AdequacyCheck, type AgentEntity, type AgentMemoryConfig, AgentMemoryManager, type AgentObservation, type AgentRole, AnalyticsManager, type ArchiveCriteria, type ArchiveCriteriaInput, ArchiveCriteriaSchema, ArchiveManager, type ArchiveOptions, type ArchiveReflectionResult, type ArchiveResult, type ArchiveResultExtended, type ArtifactEntity, type ArtifactFilter, ArtifactManager, type ArtifactType, AsyncMutex, type AsyncMutexOptions, type AttributionMode, type AuditEntry, type AuditFilter, AuditLog, type AuditOperation, type AuditStats, type AutoLinkOptions, type AutoLinkResult, AutoLinker, type AutoSearchResult, type BM25Config, type BM25DocumentEntry, type BM25Index, BM25Search, type BackupInfo, type BackupInfoExtended, type BackupMetadata, type BackupMetadataExtended, type BackupOptions, type BackupResult, BasicSearch, BatchCreateEntitiesSchema, BatchCreateRelationsSchema, type BatchItemResult, type BatchOperation, type BatchOperationType, type BatchOptions, type BatchProcessResult, BatchProcessor, type BatchProcessorOptions, type BatchProgress, type BatchProgressCallback, type BatchResult, BatchTransaction, type BidirectionalRelation, type BooleanCacheEntry, type BooleanOpNode, type BooleanQueryNode, BooleanSearch, COMPRESSION_CONFIG, type CacheCompressionStats, type CacheStats, type CachedQueryEntry, type CausalChain, type CausalCycle, CausalReasoner, type CausalReasonerConfig, type CausalRelationType, type CentralityResult, type ClusterMethod, CognitiveLoadAnalyzer, type CognitiveLoadConfig, type CognitiveLoadMetrics, CollaborationAuditEnforcer, type CollaborationAuditEnforcerOptions, CollaborativeSynthesis, type CollaborativeSynthesisConfig, type CommonSearchFilters, type ComponentMemoryUsage, CompositeDistillationPolicy, CompressedCache, type CompressedCacheOptions, type CompressedCacheStats, type CompressedMemory, CompressionManager, type CompressionMetadata, type CompressionOptions, type CompressionQuality, type CompressionResult, type ConfirmationResult, type ConflictInfo, ConflictResolver, type ConflictResolverConfig, type ConflictStrategy, type ConnectedComponentsResult, type ConsolidateOptions, type ConsolidationAction, type ConsolidationCycleResult, ConsolidationPipeline, type ConsolidationPipelineConfig, type ConsolidationResult, type ConsolidationRule, ConsolidationScheduler, type ConsolidationSchedulerConfig, type ConsolidationTrigger, type ContextPackage, type ContextProfile, ContextProfileManager, type ContextRetrievalOptions, ContextWindowManager, type ContextWindowManagerConfig, type Contradiction$1 as Contradiction, ContradictionDetector, type CreateArtifactOptions, type CreateEntityInput, CreateEntitySchema, type CreateEpisodeOptions, type CreateMemoryOptions, type CreatePlanOptions, type CreateRelationInput, CreateRelationSchema, type CreateWorkThreadOptions, CycleDetectedError, DEFAULT_BASE_DIR, DEFAULT_BM25_CONFIG, DEFAULT_CAUSAL_RELATION_TYPES, DEFAULT_DUPLICATE_THRESHOLD, DEFAULT_EMBEDDING_CACHE_OPTIONS, DEFAULT_FILE_NAMES, DEFAULT_HYBRID_WEIGHTS, DEFAULT_INDEXER_OPTIONS, DEFAULT_PERMISSION_MATRIX, DEFAULT_PII_PATTERNS, DEFAULT_SCORER_WEIGHTS, DOCUMENT_PREFIX, type DateRange, DateRangeSchema, type DecayCycleResult, DecayEngine, type DecayEngineConfig, type DecayOperationOptions, type DecayOptions, type DecayResult, DecayScheduler, type DecaySchedulerConfig, type DecisionEntityOptions, type DecisionInput, DecisionManager, type DecisionRule, type DedupTier, type DeduplicationOptions, DefaultDistillationPolicy, type DeleteObservationInput, DeleteObservationInputSchema, DeleteObservationsInputSchema, DeleteRelationsSchema, type DistillOptions, type DistillationConfig, DistillationPipeline, type DistillationResult, type DistillationStats, type DistilledLesson, type DistilledMemory, type DocumentVector, type DreamCycleResult, DreamEngine, type DreamEngineCallbacks, type DreamEngineConfig, type DreamPhaseConfig, type DreamPhaseResult, type DuplicateCheckResult, DuplicateEntityError, type DuplicateObservationGroup, type DuplicateObservationOccurrence, type DuplicatePair, ENTITY_STATUS_TRANSITIONS, ENV_VARS, EarlyTerminationManager, type EarlyTerminationOptions, type EarlyTerminationResult, EmbeddingCache, type EmbeddingCacheOptions, type EmbeddingCacheStats, type EmbeddingConfig, type EmbeddingMode, type EmbeddingProgressCallback, type EmbeddingService, type EndSessionResult, type Entity, type EntityCreatedEvent, type EntityDeletedEvent, type EntityInput, EntityManager, type EntityManagerOptions, EntityNamesSchema, EntityNotFoundError, type EntityRuleResult, EntitySchema, type EntityStatus, type EntityUpdatedEvent, type EntityValidationIssue, type EntityValidationResult, type EntityValidationRule, EntityValidator, type EntityValidatorConfig, type EntityWithContext, type EntropyFilterConfig, EntropyFilterStage, type EpisodicMemoryConfig, type EpisodicMemoryEntity, EpisodicMemoryManager, EpisodicRelations, ErrorCode, type ErrorOptions, type ExcludedEntity, type ExclusionCheckResult, ExclusionManager, type Experience, ExperienceExtractor, type ExperienceExtractorConfig, type ExperienceType, type ExplainedSearchResult, ExportError, type ExportFilter, type ExportFilterInput, ExportFilterSchema, type ExportFormat, ExportFormatSchema, type ExportOptions, type ExportResult, type ExtendedExportFormatInput, ExtendedExportFormatSchema, type ExtendedPoolStats, type ExtendedQueryCostEstimate, type ExtractedEntity, type ExtractedFact, FILE_EXTENSIONS, FILE_SUFFIXES, type FactExtractionOptions, type FactExtractionResult, FactExtractor, FailureDistillation, type FailureDistillationConfig, type FailureDistillationResult, type FailureEntityOptions, type GetAllOptions as FailureGetAllOptions, type FailureInput, type LookupOptions as FailureLookupOptions, FailureManager, type FailureManagerConfig, type FieldNode, FileOperationError, type FlushResult, type ForContextOptions, type ForgetOptions, type ForgetResult, FreshnessManager, type FreshnessManagerConfig, type FreshnessReport, type FuzzyCacheKey, FuzzySearch, type FuzzySearchOptions, GRAPH_LIMITS, type GetWeightedOptions, GovernanceManager, type GovernanceOperationOptions, type GovernancePolicy, GovernanceTransaction, type Granularity, type GraphCompressionResult, type GraphEvent, type GraphEventBase, GraphEventEmitter, type GraphEventListener, type GraphEventMap, type GraphEventType, type GraphLoadedEvent, type GraphProjection, type GraphSavedEvent, type GraphStats, GraphStorage, GraphTraversal, type GroupMembership, type GroupingResult, type HeuristicConflict, HeuristicExtractionStage, type HeuristicExtractionStageConfig, type HeuristicGuideline, HeuristicManager, type HeuristicMatch, type HeuristicUpdateResult, HierarchyManager, HybridScorer, type HybridScorerOptions, HybridSearchManager, type HybridSearchOptions, type HybridSearchResult, type HybridWeights, type IDistillationPolicy, type IGraphStorage, IMPORTANCE_RANGE, type IMemoryBackend, IOManager, type ISummarizationProvider, type IVectorStore, ImportError, type ImportFormat, type ImportFormatInput, ImportFormatSchema, type ImportResult, ImportanceScorer, type ImportanceScorerConfig, InMemoryBackend, InMemoryVectorStore, IncrementalIndexer, type IncrementalIndexerOptions, type IndexMemoryUsage, type IndexOperation, type IndexOperationType, type IngestInput, type IngestOptions, type IngestResult, InsufficientEntitiesError, InvalidImportanceError, type IssueOptions, type IssueResult, type JSONValue, type JsonSchema, type KeyRecord, KeywordExtractor, type KnowledgeGraph, KnowledgeGraphError, ManagerContext as KnowledgeGraphManager, type LLMProvider, LLMQueryPlanner, type LLMQueryPlannerConfig, LLMSearchExecutor, type LLMSearchExecutorOptions, LOG_PREFIXES, LangChainMemoryAdapter, type LayerRecommendationOptions, type LayerTiming, type LexicalSearchResult, type ListDecisionsOptions, type ListPlansOptions, type ListReflectionsOptions, LocalEmbeddingService, type LogLevel, type LongRunningOperationOptions, LowEntropyContentError, LowercaseCache, type LowercaseData, MCPToolObserverAdapter, MEMORY_TYPES, ManagerContext, type ManagerContextOptions, type MatchedTerm, type MemoryAcquisitionMethod, type MemoryAlert, type MemoryChangeCallback, MemoryEngine, type MemoryEngineConfig, type MemoryEngineEventName, MemoryFormatter, type MemoryFormatterConfig, type MemoryMergeStrategy, MemoryMonitor, type MemorySource, type MemoryThresholds, type MemoryTurn, type MemoryType, type MemoryUsageStats, type MemoryValidationIssue, type MemoryValidationResult, MemoryValidator, type MemoryValidatorConfig, type Contradiction as MemoryValidatorContradiction, type MemoryVisibility, type MergeResult, type MergeStrategy, type MergeStrategyInput, MergeStrategySchema, MockEmbeddingService, type MultiAgentConfig, MultiAgentMemoryManager, NGramIndex, type NGramIndexStats, NameIndex, NoOpDistillationPolicy, type NormalizationOptions, type NormalizationResult, type ObservableDataModelAdapterOptions, type ObservableDataModelShape, type ObservationAddedEvent, type ObservationDedupFilter, ObservationDedupManager, type ObservationDedupManagerConfig, ObservationDedupReportStage, type ObservationDedupReportStageConfig, type ObservationDeletedEvent, ObservationManager, ObservationNormalizer, type ObservationScore, type ObservationSource, ObserverPipeline, type ObserverPipelineOptions, type ObserverPipelineStats, OpenAIEmbeddingService, OperationCancelledError, type OperationResult, OperationType, OptimizedInvertedIndex, OptionalEntityNamesSchema, OptionalTagsSchema, type Outcome, PROCEDURE_ENTITY_TYPE, type PaginatedCacheEntry, type PaginatedResult, type PaginationParams, ParallelSearchExecutor, type ParallelSearchOptions, type ParallelSearchResult, type ParsePaginationOptions, type ParsedTemporalRange, type PathResult, PatternDetector, type PatternResult, type Permission, type PermissionMatrix, type PermissionMatrixRow, type PhaseDefinition, type PhraseNode, type PiiPattern, PiiRedactor, type PiiRedactorOptions, type PipelineStage, PlanManager, type PlanManagerConfig, type PoolEventCallback, type PostingListResult, type PreparedEntity, type ProceduralMemoryEntity, type ProcedureInvoker, ProcedureManager, type ProcedureManagerConfig, ProcedureStore, type ProfileConfig, type ProfileEntity, ProfileManager, type ProfileManagerConfig, type ProfileOptions, type ProfileResponse, type ProgressCallback, type ProgressInfo, type ProgressInfoCallback, type ProgressOptions, ProjectContextManager, type ProjectContextManagerConfig, type ProjectContextUpsertInput, type PromotionCriteria, type PromotionMarkOptions, type PromotionResult, type ProspectiveMemoryConfig, ProspectiveMemoryManager, ProspectivePromotionStage, type ProximityMatch, type ProximityMatchLocation, type ProximityNode, ProximitySearch, type PushSubGoalOptions, QUERY_LIMITS, QUERY_PREFIX, type QuantizationParams, type QuantizedSearchResult, QuantizedVectorStore, type QuantizedVectorStoreOptions, type QuantizedVectorStoreStats, type QueryAnalysis, QueryAnalyzer, type QueryCostEstimate, QueryCostEstimator, type QueryCostEstimatorOptions, type QueryLogEntry, QueryLogger, type QueryLoggerConfig, type QueryNode, QueryParser, type QueryPlan, QueryPlanCache, type QueryPlanCacheOptions, type QueryPlanCacheStats, QueryPlanner, QueryRewriter, type QueryStage, type QueryTrace, QueryTraceBuilder, type QueueStats, RankedSearch, type RateLimitVerdict, RateLimiter, type RateLimiterConfig, RbacMiddleware, type RbacMiddlewareOptions, type RbacPolicy, ReadOnlyMemoryGraphDataError, type ReadonlyKnowledgeGraph, type RecordOutcomeInput, type RedactionResult, type RedactionStats, type RedundancyGroup, RefConflictError, type RefEntry, RefIndex, type RefIndexStats, RefNotFoundError, type RefinementHistoryEntry, type ReflectionEntityOptions, type ReflectionInput, ReflectionManager$1 as ReflectionManager, ReflectionManager as ReflectionMemoryManager, type ReflectionManagerConfig as ReflectionMemoryManagerConfig, type ReflectionOptions, type ReflectionResult, ReflectionStage, type ReflectionStageConfig, type ReinforcementOptions, type RejectDecisionResult, type Relation, RelationBuilder, type RelationCreatedEvent, type RelationDeletedEvent, RelationIndex, type RelationInput, RelationManager, RelationNotFoundError, type RelationProperties, RelationSchema, type RelationValidationError, type RelationValidationResult, type RelationValidationWarning, type RelevanceOptions, type ResolutionResult, type ResourcePermissionOverrides, type ResourceType, type RestHandler, type RestMethod, type RestRequest, type RestResponse, RestRouter, type RestoreResult, type Result, type RetrievalContext, type RetrievalDecision, type RetrievalRound, type RetrieveContextOptions, type RewriteResult, type Role, type RoleAssignment, RoleAssignmentStore, type RoleAssignmentStoreOptions, type RoleProfile, type RouteDefinition, RowLevelFilter, type RowPredicate, type Rule, type RuleConditions, type RuleEvaluationResult, RuleEvaluator, SEARCH_LIMITS, SIMILARITY_WEIGHTS, SQLiteBackend, type SQLiteBackendOptions, SQLiteStorage, type SQLiteStorageWithEmbeddings, SQLiteVectorStore, STOPWORDS, STREAMING_CONFIG, type SalienceComponents, type SalienceContext, SalienceEngine, type SalienceEngineConfig, type SalienceWeights, type SavedSearch, type SavedSearchInput, SavedSearchInputSchema, SavedSearchManager, type SavedSearchUpdateInput, SavedSearchUpdateSchema, type ScheduleOptions, SchemaValidator, type ScoreBoost, type ScoreOptions, type ScoredEntity, type ScoredKeyword, type ScoredResult, type ScoringSignal, SearchCache, type SearchExplanation, SearchFilterChain, type SearchFilters, type SearchFunction, type SearchLayer, SearchManager, type SearchMethod, type SearchQuery, SearchQuerySchema, type SearchResult, SearchSuggestions, SemanticForget, type SemanticForgetOptions, type SemanticForgetResult, type SemanticIndexOptions, type SemanticLayerResult, type SemanticMemoryEntity, SemanticSearch, type SemanticSearchResult, type SessionCheckpointData, SessionCheckpointManager, type SessionConfig, type SessionEntity, type SessionHistoryOptions, SessionManager, type SessionMemoryFilter, type SessionOutcome, SessionQueryBuilder, type SessionSearchOptions, type SessionStatus, SpellChecker, type SpellCheckerConfig, type SpellSuggestion, type SpilloverResult, type SplitOptions, type SplitResult, type StageResult, type StartSessionOptions, StepSequencer, type StorageConfig, type StreamResult, StreamingExporter, type StructuredQuery, type SubQuery, type SuggestOptions, type SuggestToolOptions, type SummarizationConfig, type SummarizationResult, SummarizationService, type SupersedeDecisionResult, type SymbolicFilters, type SymbolicResult, SymbolicSearch, type SymbolicSearchResult, type SynthesisResult, TFIDFEventSync, type TFIDFIndex, TFIDFIndexManager, type TagAlias, type TagAliasInput, TagAliasSchema, TagManager, type Task, type TaskBatchOptions, type TaskHandle, TaskPriority, TaskQueue, type TaskResult, TaskStatus, type TaskSubmitOptions, type TemporalFilterField, type TemporalFocus, TemporalQueryParser, type TemporalRange, type TemporalRelation, TemporalSearch, type TemporalSearchOptions, type TermNode, type TimelineOptions, type TokenBreakdown, type TokenEstimationOptions, type TokenizedEntity, ToolAffordanceManager, type ToolAffordanceManagerConfig, type ToolAffordanceStats, type ToolCallEvent, ToolCallObserver, type ToolResponse, type ToolSuggestion, type Trajectory, type TrajectoryCluster, TrajectoryCompressor, type TrajectoryCompressorConfig, type TrajectoryMergeStrategy, TransactionManager, type TransactionOperation, type TransactionResult, type TransitionEvent, type TransitionFilter, TransitionLedger, type TraversalOptions, type TraversalResult, TypeIndex, type UpdateEntityInput, UpdateEntitySchema, type ValidatedPagination, ValidationError, type ValidationIssue, type ValidationReport, type ValidationResult$1 as ValidationResult, type ValidationWarning, type VectorSearchResult, VisibilityResolver, type VisualizeOptions, type WakeUpOptions, type WakeUpResult, type WeightedRelation, type WeightedTurn, type WildcardNode, type WorkThread, type WorkThreadFilter, WorkThreadManager, type WorkThreadStatus, type WorkerPoolConfig, WorkerPoolManager, WorkerTaskManager, type WorkerTaskManagerStats, type WorkingMemoryConfig, type WorkingMemoryEntity, WorkingMemoryManager, type WorkingMemoryOptions, WorldModelManager, type WorldModelManagerOptions, type WorldStateChange, type WorldStateEntity, WorldStateSnapshot, addUniqueTags, all, allRelationsValidMetadata, applyPagination, asWarning, batchProcess, batchProcessViaWorkers, buildTFVector, calculateIDF, calculateIDFFromTokenSets, calculateTF, calculateTFIDF, calculateTextSimilarity, checkCancellation, chunkArray, cleanupAllCaches, clearAllSearchCaches, compress, compressFile, compressToBase64, computeEntropy, cosineSimilarity, createCustomProfile, createDetailedProgressReporter, createEmbeddingService, createMetadata, createObservableDataModelFromGraph, createProgress, createProgressInfo, createProgressReporter, createStorage, createStorageFromPath, createThrottledProgress, createUncompressedMetadata, createVectorStore, custom, customSync, debounce, decodeProcedure, decompress, decompressFile, decompressFromBase64, defaultMemoryPath, email, ensureMemoryFilePath, entityExists, entityPassesFilters, entityToText, err, escapeCsvFormula, executeWithPhases, extractToolName, filterByCreatedDate, filterByEntityType, filterByImportance, filterByModifiedDate, filterByTags, filterParallel, findEntitiesByNames, findEntityByName, fnv1aHash, formatErrorResponse, formatRawResponse, formatTextResponse, formatToolResponse, formatZodErrors, generateSuggestions, getAllCacheStats, getCompressionRatio, getCurrentTimestamp, getEntityIndex, getEntityNameSet, getPaginationMeta, getPoolStats, getQuickHint, getRoleProfile, getWorkerPoolManager, getWorkerTaskManager, globalMemoryMonitor, groupEntitiesByType, hasAllTags, hasBrotliExtension, hasConfidence, hasMatchingTag, isAgentEntity, isArtifactEntity, isBidirectionalRelation, isCurrentlyValid, isEpisodicMemory, isErr, isOk, isPrefixPattern, isProceduralMemory, isProfileEntity, isSemanticMemory, isSessionEntity, isTemporalRelation, isValidISODate, isWeightedRelation, isWithinDateRange, isWithinImportanceRange, isWorkingMemory, isoDate, l2Normalize, levenshteinDistance, listRoleProfiles, loadConfigFromEnv, logger, mapOk, mapParallel, matchesPhrase, matchesPrefix, max, maxItems, maxLength, mergeConfig, min, minItems, minLength, normalizeTag, normalizeTags, ok, oneOf, paginate, paginateArray, parallelFilter, parallelLimit, parallelMap, parseDateRange, parsePaginationParams, passesEntropyFilter, pattern, permissionsForRole, processBatch, processBatchesWithProgress, processWithRetry, range, rateLimitedProcess, removeEntityByName, removeTags, required, resolveRoleProfile, sanitizeObject, searchCaches, shutdownParallelUtils, cosineSimilarity$1 as textCosineSimilarity, tokenize as textTokenize, throttle, tokenize$1 as tokenize, touchEntity, typeOf, unwrap, unwrapOr, url, validateArrayWithSchema, validateConfig, validateEntity, validateFilePath, validateImportance, validatePagination, validateRelation, validateRelationMetadata, validateRelationsMetadata, validateSafe, validateTags, validateWithSchema, when, withRetry };
+export { type ABACCondition, type ABACContext, type ABACDecision, type ABACEffect, type ABACOp, ABACPolicy, type ABACRule, APIKeyStore, type ValidationResult as APIKeyValidationResult, type AcceptDecisionResult, type AccessContext, AccessContextBuilder, type AccessPattern, type AccessStats, AccessTracker, type AccessTrackerConfig, type Action, type ActiveRetrievalConfig, ActiveRetrievalController, type AdaptiveDepthConfig, type AdaptiveReductionResult, type AdaptiveResult, type AddExclusionRuleInput, type AddHeuristicOptions, type AddObservationInput, AddObservationInputSchema, AddObservationsInputSchema, type AddTurnOptions, type AddTurnResult, type AdequacyCheck, type AgentEntity, type AgentMemoryConfig, AgentMemoryManager, type AgentObservation, type AgentRole, AnalyticsManager, type ArchiveCriteria, type ArchiveCriteriaInput, ArchiveCriteriaSchema, ArchiveManager, type ArchiveOptions, type ArchiveReflectionResult, type ArchiveResult, type ArchiveResultExtended, type ArtifactEntity, type ArtifactFilter, ArtifactManager, type ArtifactType, AsyncMutex, type AsyncMutexOptions, type AttributionMode, type AuditEntry, type AuditFilter, AuditLog, type AuditOperation, type AuditStats, type AutoLinkOptions, type AutoLinkResult, AutoLinker, type AutoSearchResult, BLOCKED_BY_RELATION, type BM25Config, type BM25DocumentEntry, type BM25Index, BM25Search, type BackupInfo, type BackupInfoExtended, type BackupMetadata, type BackupMetadataExtended, type BackupOptions, type BackupResult, BasicSearch, BatchCreateEntitiesSchema, BatchCreateRelationsSchema, type BatchItemResult, type BatchOperation, type BatchOperationType, type BatchOptions, type BatchProcessResult, BatchProcessor, type BatchProcessorOptions, type BatchProgress, type BatchProgressCallback, type BatchResult, BatchTransaction, type BidirectionalRelation, type BooleanCacheEntry, type BooleanOpNode, type BooleanQueryNode, BooleanSearch, type BridgePersistResult, CHILD_OF_RELATION, COMPRESSION_CONFIG, type CTCGraphSnapshot, type CTCTriple, type CacheCompressionStats, type CacheStats, type CachedQueryEntry, type CausalChain, type CausalCycle, CausalReasoner, type CausalReasonerConfig, type CausalRelationType, type CentralityResult, type ClusterMethod, CognitiveLoadAnalyzer, type CognitiveLoadConfig, type CognitiveLoadMetrics, CollaborationAuditEnforcer, type CollaborationAuditEnforcerOptions, CollaborativeSynthesis, type CollaborativeSynthesisConfig, type CommonSearchFilters, type ComponentMemoryUsage, CompositeDistillationPolicy, CompressedCache, type CompressedCacheOptions, type CompressedCacheStats, type CompressedMemory, CompressionManager, type CompressionMetadata, type CompressionOptions, type CompressionQuality, type CompressionResult, type ConfirmationResult, type ConflictInfo, ConflictResolver, type ConflictResolverConfig, type ConflictStrategy, type ConnectedComponentsResult, type ConsolidateOptions, type ConsolidationAction, type ConsolidationCycleResult, ConsolidationPipeline, type ConsolidationPipelineConfig, type ConsolidationResult, type ConsolidationRule, ConsolidationScheduler, type ConsolidationSchedulerConfig, type ConsolidationTrigger, type ContentLayer, type ContentNode, type ContextPackage, type ContextProfile, ContextProfileManager, type ContextRetrievalOptions, ContextWindowManager, type ContextWindowManagerConfig, type Contradiction$1 as Contradiction, ContradictionDetector, type CreateArtifactOptions, type CreateEntityInput, CreateEntitySchema, type CreateEpisodeOptions, type CreateMemoryOptions, type CreatePlanOptions, type CreateRelationInput, CreateRelationSchema, type CreateWorkThreadOptions, type CueNode, CueTagContentGraph, CycleDetectedError, DEFAULT_BASE_DIR, DEFAULT_BM25_CONFIG, DEFAULT_CAUSAL_RELATION_TYPES, DEFAULT_DUPLICATE_THRESHOLD, DEFAULT_EMBEDDING_CACHE_OPTIONS, DEFAULT_FILE_NAMES, DEFAULT_HYBRID_WEIGHTS, DEFAULT_INDEXER_OPTIONS, DEFAULT_MAX_PAGERANK_ENTITIES, DEFAULT_NEIGHBOR_DAMPING, DEFAULT_NEIGHBOR_TOP_K, DEFAULT_PERMISSION_MATRIX, DEFAULT_PII_PATTERNS, DEFAULT_SCORER_WEIGHTS, DOCUMENT_PREFIX, type DateRange, DateRangeSchema, type DecayCycleResult, DecayEngine, type DecayEngineConfig, type DecayOperationOptions, type DecayOptions, type DecayResult, DecayScheduler, type DecaySchedulerConfig, type DecisionEntityOptions, type DecisionInput, DecisionManager, type DecisionRule, type DedupTier, type DeduplicationOptions, DefaultDistillationPolicy, type DeleteObservationInput, DeleteObservationInputSchema, DeleteObservationsInputSchema, DeleteRelationsSchema, type DialogueTurn, type DistillOptions, type DistillationConfig, DistillationPipeline, type DistillationResult, type DistillationStats, type DistilledLesson, type DistilledMemory, type DistilledSentence, type DocumentVector, type DreamCycleResult, DreamEngine, type DreamEngineCallbacks, type DreamEngineConfig, type DreamPhaseConfig, type DreamPhaseResult, type DuplicateCheckResult, DuplicateEntityError, type DuplicateObservationGroup, type DuplicateObservationOccurrence, type DuplicatePair, ENTITY_STATUS_TRANSITIONS, ENV_VARS, EarlyTerminationManager, type EarlyTerminationOptions, type EarlyTerminationResult, EmbeddingCache, type EmbeddingCacheOptions, type EmbeddingCacheStats, type EmbeddingConfig, type EmbeddingMode, type EmbeddingProgressCallback, type EmbeddingService, type EndSessionResult, type Entity, type EntityCreatedEvent, type EntityDeletedEvent, type EntityInput, EntityManager, type EntityManagerOptions, EntityNamesSchema, EntityNotFoundError, type EntityRenamedEvent, type EntityRuleResult, EntitySchema, type EntityStatus, type EntityUpdatedEvent, type EntityValidationIssue, type EntityValidationResult, type EntityValidationRule, EntityValidator, type EntityValidatorConfig, type EntityWithContext, type EntropyFilterConfig, EntropyFilterStage, type EpisodicMemoryConfig, type EpisodicMemoryEntity, EpisodicMemoryManager, EpisodicRelations, ErrorCode, type ErrorOptions, type EventKeywords, type ExcludedEntity, type ExclusionCheckResult, ExclusionManager, type Experience, ExperienceExtractor, type ExperienceExtractorConfig, type ExperienceType, type ExplainedSearchResult, ExportError, type ExportFilter, type ExportFilterInput, ExportFilterSchema, type ExportFormat, ExportFormatSchema, type ExportOptions, type ExportResult, type ExtendedExportFormatInput, ExtendedExportFormatSchema, type ExtendedPoolStats, type ExtendedQueryCostEstimate, type ExtractedEntity, type ExtractedFact, FILE_EXTENSIONS, FILE_SUFFIXES, type FactExtractionOptions, type FactExtractionResult, FactExtractor, FailureDistillation, type FailureDistillationConfig, type FailureDistillationResult, type FailureEntityOptions, type GetAllOptions as FailureGetAllOptions, type FailureInput, type LookupOptions as FailureLookupOptions, FailureManager, type FailureManagerConfig, type FieldNode, FileOperationError, type FlushResult, type ForContextOptions, type ForgetOptions, type ForgetResult, FreshnessManager, type FreshnessManagerConfig, type FreshnessReport, type FuzzyCacheKey, FuzzySearch, type FuzzySearchOptions, GRAPH_LIMITS, type GetWeightedOptions, GovernanceManager, type GovernanceOperationOptions, type GovernancePolicy, GovernanceTransaction, type Granularity, type GraphCompressionResult, type GraphEvent, type GraphEventBase, GraphEventEmitter, type GraphEventListener, type GraphEventMap, type GraphEventType, type GraphHybridOptions, type GraphHybridSearchResult, type GraphLayerResult, type GraphLoadedEvent, type GraphProjection, GraphRankPrior, type GraphRankPriorOptions, type GraphSavedEvent, type GraphStats, GraphStorage, GraphTraversal, type GroupMembership, type GroupingResult, HAS_CHECKPOINT_RELATION, type HeuristicConflict, HeuristicExtractionStage, type HeuristicExtractionStageConfig, type HeuristicGuideline, HeuristicManager, type HeuristicMatch, type HeuristicUpdateResult, HierarchyManager, HybridScorer, type HybridScorerOptions, type HybridSearchLayer, HybridSearchManager, type HybridSearchOptions, type HybridSearchResult, type HybridWeights, type IDistillationPolicy, type IGraphStorage, IMPORTANCE_RANGE, type IMemoryBackend, IOManager, type ISummarizationProvider, type IVectorStore, ImportError, type ImportFormat, type ImportFormatInput, ImportFormatSchema, type ImportResult, ImportanceScorer, type ImportanceScorerConfig, InMemoryBackend, InMemoryVectorStore, IncrementalIndexer, type IncrementalIndexerOptions, type IndexMemoryUsage, type IndexOperation, type IndexOperationType, type IngestInput, type IngestOptions, type IngestResult, InsufficientEntitiesError, InvalidImportanceError, type IssueOptions, type IssueResult, type JSONValue, type JsonSchema, type KeyRecord, KeywordExtractor, type KnowledgeGraph, KnowledgeGraphError, ManagerContext as KnowledgeGraphManager, type LLMProvider, LLMQueryPlanner, type LLMQueryPlannerConfig, LLMSearchExecutor, type LLMSearchExecutorOptions, LOG_PREFIXES, LangChainMemoryAdapter, type LayerRecommendationOptions, type LayerTiming, type LexicalSearchResult, type ListDecisionsOptions, type ListPlansOptions, type ListReflectionsOptions, LocalEmbeddingService, type LogLevel, type LongRunningOperationOptions, LowEntropyContentError, LowercaseCache, type LowercaseData, MCPToolObserverAdapter, MEMORY_TYPES, ManagerContext, type ManagerContextOptions, type MatchedTerm, type MemoryAcquisitionMethod, type MemoryAlert, type MemoryChangeCallback, MemoryDistiller, MemoryEngine, type MemoryEngineConfig, type MemoryEngineEventName, MemoryFormatter, type MemoryFormatterConfig, MemoryGraphBridge, type MemoryMergeStrategy, MemoryMonitor, MemoryReconstructor, type MemorySource, type MemoryThresholds, MemoryToolkit, type MemoryTurn, type MemoryType, type MemoryUsageStats, type MemoryValidationIssue, type MemoryValidationResult, MemoryValidator, type MemoryValidatorConfig, type Contradiction as MemoryValidatorContradiction, type MemoryVisibility, type MergeResult, type MergeStrategy, type MergeStrategyInput, MergeStrategySchema, MockEmbeddingService, type MultiAgentConfig, MultiAgentMemoryManager, NGramIndex, type NGramIndexStats, NameIndex, type NeighborExpansionOptions, NoOpDistillationPolicy, type NormalizationOptions, type NormalizationResult, type ObservableDataModelAdapterOptions, type ObservableDataModelShape, type ObservationAddedEvent, type ObservationDedupFilter, ObservationDedupManager, type ObservationDedupManagerConfig, ObservationDedupReportStage, type ObservationDedupReportStageConfig, type ObservationDeletedEvent, ObservationManager, ObservationNormalizer, type ObservationScore, type ObservationSource, ObserverPipeline, type ObserverPipelineOptions, type ObserverPipelineStats, OpenAIEmbeddingService, OperationCancelledError, type OperationResult, OperationType, OptimizedInvertedIndex, OptionalEntityNamesSchema, OptionalTagsSchema, type Outcome, PROCEDURE_ENTITY_TYPE, type PaginatedCacheEntry, type PaginatedResult, type PaginationParams, ParallelSearchExecutor, type ParallelSearchOptions, type ParallelSearchResult, type ParsePaginationOptions, type ParsedTemporalRange, type PathResult, PatternDetector, type PatternResult, type Permission, type PermissionMatrix, type PermissionMatrixRow, type PersonalFact, type PhaseDefinition, type PhraseNode, type PiiPattern, PiiRedactor, type PiiRedactorOptions, type PipelineStage, PlanManager, type PlanManagerConfig, type PoolEventCallback, type PostingListResult, type PreparedEntity, type ProceduralMemoryEntity, type ProcedureInvoker, ProcedureManager, type ProcedureManagerConfig, ProcedureStore, type ProfileConfig, type ProfileEntity, ProfileManager, type ProfileManagerConfig, type ProfileOptions, type ProfileResponse, type ProgressCallback, type ProgressInfo, type ProgressInfoCallback, type ProgressOptions, ProjectContextManager, type ProjectContextManagerConfig, type ProjectContextUpsertInput, type PromotionCriteria, type PromotionMarkOptions, type PromotionResult, type ProspectiveMemoryConfig, ProspectiveMemoryManager, ProspectivePromotionStage, type ProximityMatch, type ProximityMatchLocation, type ProximityNode, ProximitySearch, type PushSubGoalOptions, QUERY_LIMITS, QUERY_PREFIX, type QuantizationParams, type QuantizedSearchResult, QuantizedVectorStore, type QuantizedVectorStoreOptions, type QuantizedVectorStoreStats, type QueryAnalysis, QueryAnalyzer, type QueryCostEstimate, QueryCostEstimator, type QueryCostEstimatorOptions, type QueryLogEntry, QueryLogger, type QueryLoggerConfig, type QueryNode, QueryParser, type QueryPlan, QueryPlanCache, type QueryPlanCacheOptions, type QueryPlanCacheStats, QueryPlanner, QueryRewriter, type QueryStage, type QueryTrace, QueryTraceBuilder, type QueueStats, RankedSearch, type RateLimitVerdict, RateLimiter, type RateLimiterConfig, RbacMiddleware, type RbacMiddlewareOptions, type RbacPolicy, ReadOnlyMemoryGraphDataError, type ReadonlyKnowledgeGraph, type DistillationResult$1 as ReconstructionDistillationResult, type ReconstructionOptions, type ReconstructionResult, type ReconstructiveBacking, ReconstructiveMemory, type ReconstructiveMemoryConfig, type RecordOutcomeInput, type RedactionResult, type RedactionStats, type RedundancyGroup, RefConflictError, type RefEntry, RefIndex, type RefIndexStats, RefNotFoundError, type RefinementHistoryEntry, type ReflectionEntityOptions, type ReflectionInput, ReflectionManager$1 as ReflectionManager, ReflectionManager as ReflectionMemoryManager, type ReflectionManagerConfig as ReflectionMemoryManagerConfig, type ReflectionOptions, type ReflectionResult, ReflectionStage, type ReflectionStageConfig, type ReinforcementOptions, type RejectDecisionResult, type Relation, RelationBuilder, type RelationCreatedEvent, type RelationDeletedEvent, RelationIndex, type RelationInput, RelationManager, RelationNotFoundError, type RelationProperties, RelationSchema, type RelationValidationError, type RelationValidationResult, type RelationValidationWarning, type RelevanceOptions, type ResolutionResult, type ResourcePermissionOverrides, type ResourceType, type RestHandler, type RestMethod, type RestRequest, type RestResponse, RestRouter, type RestoreResult, type Result, type RetrievalContext, type RetrievalDecision, type RetrievalRound, type RetrieveContextOptions, type RewriteResult, type Role, type RoleAssignment, RoleAssignmentStore, type RoleAssignmentStoreOptions, type RoleProfile, type RouteDefinition, RowLevelFilter, type RowPredicate, type Rule, type RuleConditions, type RuleEvaluationResult, RuleEvaluator, SEARCH_LIMITS, SESSION_CHECKPOINT_ENTITY_TYPE, SIMILARITY_WEIGHTS, SNAPSHOTS_RELATION, SQLiteBackend, type SQLiteBackendOptions, SQLiteStorage, type SQLiteStorageWithEmbeddings, SQLiteVectorStore, STOPWORDS, STREAMING_CONFIG, type SalienceComponents, type SalienceContext, SalienceEngine, type SalienceEngineConfig, type SalienceWeights, type SavedSearch, type SavedSearchInput, SavedSearchInputSchema, SavedSearchManager, type SavedSearchUpdateInput, SavedSearchUpdateSchema, type ScheduleOptions, SchemaValidator, type ScoreBoost, type ScoreOptions, type ScoredEntity, type ScoredKeyword, type ScoredResult, type ScoringSignal, SearchCache, type SearchExplanation, SearchFilterChain, type SearchFilters, type SearchFunction, type SearchLayer, SearchManager, type SearchMethod, type SearchQuery, SearchQuerySchema, type SearchResult, SearchSuggestions, SemanticForget, type SemanticForgetOptions, type SemanticForgetResult, type SemanticIndexOptions, type SemanticLayerResult, type SemanticMemoryEntity, SemanticSearch, type SemanticSearchResult, type SessionCheckpointData, SessionCheckpointManager, type SessionConfig, type SessionEntity, type SessionHistoryOptions, SessionManager, type SessionMemoryFilter, type SessionOutcome, SessionQueryBuilder, type SessionSearchOptions, type SessionStatus, SpellChecker, type SpellCheckerConfig, type SpellSuggestion, type SpilloverResult, type SplitOptions, type SplitResult, type StageResult, type StartSessionOptions, StepSequencer, type StorageConfig, type StreamResult, StreamingExporter, type StructuredQuery, type SubQuery, type SuggestOptions, type SuggestToolOptions, type SummarizationConfig, type SummarizationResult, SummarizationService, type SupersedeDecisionResult, type SymbolicFilters, type SymbolicResult, SymbolicSearch, type SymbolicSearchResult, type SynthesisResult, TFIDFEventSync, type TFIDFIndex, TFIDFIndexManager, TOPIC_SUMMARIZES, type TagAlias, type TagAliasInput, TagAliasSchema, TagManager, type TagNode, type Task, type TaskBatchOptions, type TaskHandle, TaskPriority, TaskQueue, type TaskResult, TaskStatus, type TaskSubmitOptions, type TemporalFilterField, type TemporalFocus, TemporalQueryParser, type TemporalRange, type TemporalRelation, TemporalSearch, type TemporalSearchOptions, type TermNode, type TimelineOptions, type TokenBreakdown, type TokenEstimationOptions, type TokenizedEntity, ToolAffordanceManager, type ToolAffordanceManagerConfig, type ToolAffordanceStats, type ToolCallEvent, ToolCallObserver, type ToolResponse, type ToolSuggestion, type Trajectory, type TrajectoryCluster, TrajectoryCompressor, type TrajectoryCompressorConfig, type TrajectoryMergeStrategy, TransactionManager, type TransactionOperation, type TransactionResult, type TransitionEvent, type TransitionFilter, TransitionLedger, type TraversalActionType, type TraversalOptions, type TraversalResult, type TraversalStep, TypeIndex, type UpdateEntityInput, UpdateEntitySchema, type ValidatedPagination, ValidationError, type ValidationIssue, type ValidationReport, type ValidationResult$1 as ValidationResult, type ValidationWarning, type VectorSearchResult, VisibilityResolver, type VisualizeOptions, WORK_THREAD_ENTITY_TYPE, type WakeUpOptions, type WakeUpResult, type WeightedRelation, type WeightedTurn, type WildcardNode, type WorkThread, type WorkThreadFilter, WorkThreadManager, type WorkThreadStatus, type WorkerPoolConfig, WorkerPoolManager, WorkerTaskManager, type WorkerTaskManagerStats, type WorkingMemoryConfig, type WorkingMemoryEntity, WorkingMemoryManager, type WorkingMemoryOptions, WorldModelManager, type WorldModelManagerOptions, type WorldStateChange, type WorldStateEntity, WorldStateSnapshot, addUniqueTags, all, allRelationsValidMetadata, applyPagination, asWarning, batchProcess, batchProcessViaWorkers, buildTFVector, calculateIDF, calculateIDFFromTokenSets, calculateTF, calculateTFFromTokens, calculateTFIDF, calculateTextSimilarity, checkCancellation, chunkArray, cleanupAllCaches, clearAllSearchCaches, compress, compressFile, compressToBase64, computeEntropy, cosineSimilarity, createCustomProfile, createDetailedProgressReporter, createEmbeddingService, createMetadata, createObservableDataModelFromGraph, createProgress, createProgressInfo, createProgressReporter, createStorage, createStorageFromPath, createThrottledProgress, createUncompressedMetadata, createVectorStore, custom, customSync, debounce, decodeLegacyCheckpoint, decodeLegacyWorkThread, decodeProcedure, decompress, decompressFile, decompressFromBase64, defaultMemoryPath, email, ensureMemoryFilePath, entityExists, entityPassesFilters, entityToText, err, escapeCsvFormula, executeWithPhases, extractJson, extractToolName, filterByCreatedDate, filterByEntityType, filterByImportance, filterByModifiedDate, filterByTags, filterParallel, findEntitiesByNames, findEntityByName, fnv1aHash, formatErrorResponse, formatRawResponse, formatTextResponse, formatToolResponse, formatZodErrors, generateSuggestions, getAllCacheStats, getCompressionRatio, getCurrentTimestamp, getEntityIndex, getEntityNameSet, getPaginationMeta, getPoolStats, getQuickHint, getRoleProfile, getWorkerPoolManager, getWorkerTaskManager, globalMemoryMonitor, groupEntitiesByType, hasAllTags, hasBrotliExtension, hasConfidence, hasMatchingTag, isAgentEntity, isArtifactEntity, isBidirectionalRelation, isCurrentlyValid, isEpisodicMemory, isErr, isOk, isPrefixPattern, isProceduralMemory, isProfileEntity, isSemanticMemory, isSessionEntity, isTemporalRelation, isValidISODate, isWeightedRelation, isWithinDateRange, isWithinImportanceRange, isWorkingMemory, isoDate, l2Normalize, levenshteinDistance, listRoleProfiles, loadConfigFromEnv, logger, mapOk, mapParallel, matchesPhrase, matchesPrefix, max, maxItems, maxLength, mergeConfig, migrateLegacySessionCheckpoints, migrateLegacyWorkThreads, min, minItems, minLength, normalizeKey, normalizeTag, normalizeTags, ok, oneOf, paginate, paginateArray, parallelFilter, parallelLimit, parallelMap, parseDateRange, parsePaginationParams, passesEntropyFilter, pattern, permissionsForRole, processBatch, processBatchesWithProgress, processWithRetry, range, rateLimitedProcess, removeEntityByName, removeTags, required, resolveRoleProfile, sanitizeObject, searchCaches, shutdownParallelUtils, cosineSimilarity$1 as textCosineSimilarity, tokenize as textTokenize, throttle, tokenize$1 as tokenize, touchEntity, typeOf, unwrap, unwrapOr, url, validateArrayWithSchema, validateConfig, validateEntity, validateFilePath, validateImportance, validateNonEmpty, validateNonEmptyArray, validatePagination, validateRelation, validateRelationMetadata, validateRelationsMetadata, validateSafe, validateTags, validateWithSchema, when, withRetry };