@monoes/memory 1.0.0

package/dist/tiers/short-term.js

@@ -0,0 +1,89 @@
+/**
+ * ShortTermMemory — In-memory Map-based buffer (Task 09)
+ *
+ * Holds entries for the current run only. Supports FIFO eviction
+ * when capacity is exceeded and bulk flush to a long-term backend.
+ *
+ * @module v1/memory/tiers/short-term
+ */
+export class ShortTermMemory {
+    /** Insertion-ordered map for FIFO eviction */
+    buffer = new Map();
+    capacity;
+    constructor(capacity = 500) {
+        this.capacity = capacity;
+    }
+    // ---- Mutation ----
+    /**
+     * Store an entry. If the buffer exceeds capacity the oldest entry
+     * (first inserted) is evicted.
+     */
+    store(entry) {
+        // If key already exists, delete first so re-insertion moves it to end
+        if (this.buffer.has(entry.id)) {
+            this.buffer.delete(entry.id);
+        }
+        this.buffer.set(entry.id, entry);
+        // FIFO eviction — remove oldest entries until within capacity
+        while (this.buffer.size > this.capacity) {
+            const oldest = this.buffer.keys().next().value;
+            if (oldest !== undefined) {
+                this.buffer.delete(oldest);
+            }
+        }
+    }
+    // ---- Retrieval ----
+    retrieve(id) {
+        return this.buffer.get(id);
+    }
+    /**
+     * Simple substring search across entry content and key fields.
+     * Returns up to `limit` matches ordered by most-recent insertion.
+     */
+    search(query, limit = 10) {
+        const lowerQuery = query.toLowerCase();
+        const results = [];
+        // Iterate in reverse insertion order (newest first)
+        const entries = Array.from(this.buffer.values()).reverse();
+        for (const entry of entries) {
+            if (results.length >= limit)
+                break;
+            const haystack = `${entry.key} ${entry.content}`.toLowerCase();
+            if (haystack.includes(lowerQuery)) {
+                results.push(entry);
+            }
+        }
+        return results;
+    }
+    // ---- Lifecycle ----
+    /**
+     * Return a stable copy of all currently buffered entries without mutating
+     * the buffer. Used by callers (e.g. TierManager) that need to process
+     * entries alongside a flush operation.
+     */
+    snapshot() {
+        return Array.from(this.buffer.values());
+    }
+    /**
+     * Promote all buffered entries to the given long-term backend,
+     * then clear the buffer. Returns the number of flushed entries.
+     */
+    async flush(longTermStore) {
+        const entries = Array.from(this.buffer.values());
+        if (entries.length === 0)
+            return 0;
+        await longTermStore.bulkInsert(entries);
+        const count = entries.length;
+        this.buffer.clear();
+        return count;
+    }
+    /** Remove all entries from the buffer. */
+    clear() {
+        this.buffer.clear();
+    }
+    /** Current number of entries in the buffer. */
+    get size() {
+        return this.buffer.size;
+    }
+}
+//# sourceMappingURL=short-term.js.map

package/dist/tiers/short-term.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"short-term.js","sourceRoot":"","sources":["../../src/tiers/short-term.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,MAAM,OAAO,eAAe;IAC1B,8CAA8C;IACtC,MAAM,GAA6B,IAAI,GAAG,EAAE,CAAC;IACpC,QAAQ,CAAS;IAElC,YAAY,QAAQ,GAAG,GAAG;QACxB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED,qBAAqB;IAErB;;;OAGG;IACH,KAAK,CAAC,KAAkB;QACtB,sEAAsE;QACtE,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC;YAC9B,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/B,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;QAEjC,8DAA8D;QAC9D,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YACxC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;YAC/C,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACzB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAC7B,CAAC;QACH,CAAC;IACH,CAAC;IAED,sBAAsB;IAEtB,QAAQ,CAAC,EAAU;QACjB,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAa,EAAE,KAAK,GAAG,EAAE;QAC9B,MAAM,UAAU,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;QACvC,MAAM,OAAO,GAAkB,EAAE,CAAC;QAElC,oDAAoD;QACpD,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;QAE3D,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC5B,IAAI,OAAO,CAAC,MAAM,IAAI,KAAK;gBAAE,MAAM;YACnC,MAAM,QAAQ,GAAG,GAAG,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC,WAAW,EAAE,CAAC;YAC/D,IAAI,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;gBAClC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACtB,CAAC;QACH,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,sBAAsB;IAEtB;;;;OAIG;IACH,QAAQ;QACN,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,KAAK,CAAC,aAA6B;QACvC,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;QACjD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,CAAC,CAAC;QAEnC,MAAM,aAAa,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACxC,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACpB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,0CAA0C;IAC1C,KAAK;QACH,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAED,+CAA+C;IAC/C,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IAC1B,CAAC;CACF"}

package/dist/types/checkpoint.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Graph Checkpointing Types (Task 08)
+ *
+ * Defines the shape of agent snapshots, full swarm checkpoints,
+ * and lightweight checkpoint metadata used for listing / diffing.
+ */
+/** Snapshot of a single agent at checkpoint time. */
+export interface AgentState {
+    agentId: string;
+    agentSlug: string;
+    status: 'active' | 'idle' | 'completed' | 'failed';
+    messageHistory: unknown[];
+    toolCallStack: unknown[];
+    taskId?: string;
+    metadata: Record<string, unknown>;
+    snapshotAt: string;
+}
+/** Full swarm checkpoint containing every agent's state + queues + results. */
+export interface SwarmCheckpoint {
+    checkpointId: string;
+    swarmId: string;
+    sessionId: string;
+    step: number;
+    trigger: 'post-task' | 'session-end' | 'manual' | 'interrupt' | 'periodic';
+    agentStates: AgentState[];
+    messageQueues: Record<string, unknown[]>;
+    consensusState?: unknown;
+    taskResults: Record<string, unknown>;
+    stateHash: string;
+    createdAt: string;
+    parentCheckpointId?: string;
+}
+/** Lightweight metadata returned by list(). */
+export interface CheckpointMeta {
+    checkpointId: string;
+    swarmId: string;
+    sessionId: string;
+    step: number;
+    trigger: string;
+    agentCount: number;
+    stateHash: string;
+    createdAt: string;
+}
+//# sourceMappingURL=checkpoint.d.ts.map

package/dist/types/checkpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint.d.ts","sourceRoot":"","sources":["../../src/types/checkpoint.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,qDAAqD;AACrD,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,QAAQ,CAAC;IACnD,cAAc,EAAE,OAAO,EAAE,CAAC;IAC1B,aAAa,EAAE,OAAO,EAAE,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,+EAA+E;AAC/E,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,WAAW,GAAG,aAAa,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,CAAC;IAC3E,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;IACzC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,+CAA+C;AAC/C,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/types/checkpoint.js

@@ -0,0 +1,8 @@
+/**
+ * Graph Checkpointing Types (Task 08)
+ *
+ * Defines the shape of agent snapshots, full swarm checkpoints,
+ * and lightweight checkpoint metadata used for listing / diffing.
+ */
+export {};
+//# sourceMappingURL=checkpoint.js.map

package/dist/types/checkpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint.js","sourceRoot":"","sources":["../../src/types/checkpoint.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/types.d.ts

@@ -0,0 +1,526 @@
+/**
+ * V1 Unified Memory Types
+ *
+ * Type definitions for the unified memory system based on AgentDB with HNSW indexing.
+ * Supports 150x-12,500x faster vector search compared to brute-force approaches.
+ *
+ * @module v1/memory/types
+ */
+/**
+ * Memory entry type classification
+ */
+export type MemoryType = 'episodic' | 'semantic' | 'procedural' | 'working' | 'cache';
+/** Which memory tier this entry belongs to */
+export type MemoryTier = 'short-term' | 'long-term' | 'entity' | 'contextual';
+/**
+ * Access level for memory entries
+ */
+export type AccessLevel = 'private' | 'team' | 'swarm' | 'public' | 'system';
+/**
+ * Consistency level for distributed memory operations
+ */
+export type ConsistencyLevel = 'strong' | 'eventual' | 'session' | 'weak';
+/**
+ * Distance metrics for vector similarity search
+ */
+export type DistanceMetric = 'cosine' | 'euclidean' | 'dot' | 'manhattan';
+/**
+ * Core memory entry structure with vector embedding support
+ */
+export interface MemoryEntry {
+    /** Unique identifier */
+    id: string;
+    /** Human-readable key for retrieval */
+    key: string;
+    /** Actual content of the memory */
+    content: string;
+    /** Vector embedding for semantic search (Float32Array for efficiency) */
+    embedding?: Float32Array;
+    /** Type of memory */
+    type: MemoryType;
+    /** Namespace for organization */
+    namespace: string;
+    /** Tags for categorization and filtering */
+    tags: string[];
+    /** Additional metadata */
+    metadata: Record<string, unknown>;
+    /** Owner agent ID */
+    ownerId?: string;
+    /** Access level */
+    accessLevel: AccessLevel;
+    /** Creation timestamp */
+    createdAt: number;
+    /** Last update timestamp */
+    updatedAt: number;
+    /** Expiration timestamp (optional) */
+    expiresAt?: number;
+    /** Event time — when the event occurred (vs createdAt = ingestion time).
+     *  Bi-temporal model: separates T (event) from T' (record).
+     *  Source: https://arxiv.org/abs/2501.13956 (Zep/Graphiti) */
+    eventAt?: number;
+    /** Version number for optimistic locking */
+    version: number;
+    /** References to other memory entries */
+    references: string[];
+    /** Access count for usage tracking */
+    accessCount: number;
+    /** Importance score for FOREVER forgetting-curve replay (default 1.0) */
+    importanceScore?: number;
+    /** Last access timestamp */
+    lastAccessedAt: number;
+}
+/**
+ * Input for creating a new memory entry
+ */
+export interface MemoryEntryInput {
+    key: string;
+    content: string;
+    type?: MemoryType;
+    namespace?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    ownerId?: string;
+    accessLevel?: AccessLevel;
+    expiresAt?: number;
+    references?: string[];
+    tier?: MemoryTier;
+}
+/**
+ * Partial update for a memory entry
+ */
+export interface MemoryEntryUpdate {
+    content?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    accessLevel?: AccessLevel;
+    expiresAt?: number;
+    references?: string[];
+}
+/**
+ * Query type for memory retrieval
+ */
+export type QueryType = 'semantic' | 'exact' | 'prefix' | 'tag' | 'hybrid';
+/**
+ * Memory query specification
+ */
+export interface MemoryQuery {
+    /** Type of query to perform */
+    type: QueryType;
+    /** Content for semantic search (will be embedded) */
+    content?: string;
+    /** Pre-computed embedding for semantic search */
+    embedding?: Float32Array;
+    /** Exact key to match */
+    key?: string;
+    /** Key prefix to match */
+    keyPrefix?: string;
+    /** Namespace filter */
+    namespace?: string;
+    /** Tag filters (entries must have all specified tags) */
+    tags?: string[];
+    /** Memory type filter */
+    memoryType?: MemoryType;
+    /** Access level filter */
+    accessLevel?: AccessLevel;
+    /** Owner filter */
+    ownerId?: string;
+    /** Metadata filters */
+    metadata?: Record<string, unknown>;
+    /** Time range filters (ingestion time) */
+    createdAfter?: number;
+    createdBefore?: number;
+    updatedAfter?: number;
+    updatedBefore?: number;
+    /**
+     * Bi-temporal event-time filters (T vs T').
+     * Use these to query by WHEN THE EVENT OCCURRED rather than when it was recorded.
+     * Source: arXiv:2501.13956 — Zep/Graphiti bi-temporal knowledge graph.
+     */
+    eventAfter?: number;
+    eventBefore?: number;
+    /** Maximum number of results */
+    limit: number;
+    /** Offset for pagination */
+    offset?: number;
+    /** Minimum similarity threshold (0-1) for semantic search */
+    threshold?: number;
+    /** Include expired entries */
+    includeExpired?: boolean;
+    /** Distance metric for semantic search */
+    distanceMetric?: DistanceMetric;
+    /** Field to sort results by (backends that support it) */
+    sortField?: 'createdAt' | 'updatedAt' | 'lastAccessedAt' | 'accessCount' | 'key' | 'score';
+    /** Sort direction — 'desc' (default) or 'asc' */
+    sortDirection?: 'asc' | 'desc';
+}
+/**
+ * Search result with similarity score
+ */
+export interface SearchResult {
+    /** The memory entry */
+    entry: MemoryEntry;
+    /** Similarity score (0-1, higher is better) */
+    score: number;
+    /** Distance from query vector */
+    distance: number;
+}
+/**
+ * Search options for HNSW vector search
+ */
+export interface SearchOptions {
+    /** Number of results to return */
+    k: number;
+    /** Search expansion factor (higher = more accurate, slower) */
+    ef?: number;
+    /** Minimum similarity threshold (0-1) */
+    threshold?: number;
+    /** Distance metric */
+    metric?: DistanceMetric;
+    /** Additional filters to apply post-search */
+    filters?: MemoryQuery;
+}
+/**
+ * HNSW index configuration
+ */
+export interface HNSWConfig {
+    /** Vector dimensions (e.g., 1536 for OpenAI embeddings) */
+    dimensions: number;
+    /** Maximum number of connections per layer (default: 16) */
+    M: number;
+    /** Size of the dynamic candidate list during construction (default: 200) */
+    efConstruction: number;
+    /** Maximum elements the index can hold */
+    maxElements: number;
+    /** Distance metric */
+    metric: DistanceMetric;
+    /** Enable quantization for memory efficiency */
+    quantization?: QuantizationConfig;
+}
+/**
+ * Quantization configuration for memory reduction
+ */
+export interface QuantizationConfig {
+    /** Quantization type */
+    type: 'binary' | 'scalar' | 'product';
+    /** Number of bits for scalar quantization */
+    bits?: 4 | 8 | 16;
+    /** Number of subquantizers for product quantization */
+    subquantizers?: number;
+    /** Codebook size for product quantization */
+    codebookSize?: number;
+}
+/**
+ * HNSW index statistics
+ */
+export interface HNSWStats {
+    /** Total number of vectors in the index */
+    vectorCount: number;
+    /** Memory usage in bytes */
+    memoryUsage: number;
+    /** Average search time in milliseconds */
+    avgSearchTime: number;
+    /** Index build time in milliseconds */
+    buildTime: number;
+    /** Compression ratio if quantization is enabled */
+    compressionRatio?: number;
+}
+/**
+ * Memory backend interface for storage and retrieval
+ */
+export interface IMemoryBackend {
+    /** Initialize the backend */
+    initialize(): Promise<void>;
+    /** Shutdown the backend */
+    shutdown(): Promise<void>;
+    /** Store a memory entry */
+    store(entry: MemoryEntry): Promise<void>;
+    /** Retrieve a memory entry by ID */
+    get(id: string): Promise<MemoryEntry | null>;
+    /** Retrieve a memory entry by key within a namespace */
+    getByKey(namespace: string, key: string): Promise<MemoryEntry | null>;
+    /** Update a memory entry */
+    update(id: string, update: MemoryEntryUpdate): Promise<MemoryEntry | null>;
+    /** Delete a memory entry */
+    delete(id: string): Promise<boolean>;
+    /** Query memory entries */
+    query(query: MemoryQuery): Promise<MemoryEntry[]>;
+    /** Semantic vector search */
+    search(embedding: Float32Array, options: SearchOptions): Promise<SearchResult[]>;
+    /** Bulk insert entries */
+    bulkInsert(entries: MemoryEntry[]): Promise<void>;
+    /** Bulk delete entries */
+    bulkDelete(ids: string[]): Promise<number>;
+    /** Get entry count */
+    count(namespace?: string): Promise<number>;
+    /** List all namespaces */
+    listNamespaces(): Promise<string[]>;
+    /** Clear all entries in a namespace */
+    clearNamespace(namespace: string): Promise<number>;
+    /** Get backend statistics */
+    getStats(): Promise<BackendStats>;
+    /** Perform health check */
+    healthCheck(): Promise<HealthCheckResult>;
+}
+/**
+ * Backend statistics
+ */
+export interface BackendStats {
+    /** Total number of entries */
+    totalEntries: number;
+    /** Entries by namespace */
+    entriesByNamespace: Record<string, number>;
+    /** Entries by type */
+    entriesByType: Record<MemoryType, number>;
+    /** Total memory usage in bytes */
+    memoryUsage: number;
+    /** HNSW index statistics */
+    hnswStats?: HNSWStats;
+    /** Cache statistics */
+    cacheStats?: CacheStats;
+    /** Average query time in milliseconds */
+    avgQueryTime: number;
+    /** Average search time in milliseconds */
+    avgSearchTime: number;
+}
+/**
+ * Health check result
+ */
+export interface HealthCheckResult {
+    /** Overall health status */
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    /** Individual component health */
+    components: {
+        storage: ComponentHealth;
+        index: ComponentHealth;
+        cache: ComponentHealth;
+    };
+    /** Health check timestamp */
+    timestamp: number;
+    /** Any issues detected */
+    issues: string[];
+    /** Recommendations for improvement */
+    recommendations: string[];
+}
+/**
+ * Individual component health status
+ */
+export interface ComponentHealth {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    latency: number;
+    message?: string;
+}
+/**
+ * Cache configuration
+ */
+export interface CacheConfig {
+    /** Maximum number of entries in the cache */
+    maxSize: number;
+    /** Default TTL in milliseconds */
+    ttl: number;
+    /** Enable LRU eviction */
+    lruEnabled: boolean;
+    /** Maximum memory usage in bytes */
+    maxMemory?: number;
+    /** Enable write-through caching */
+    writeThrough: boolean;
+}
+/**
+ * Cache statistics
+ */
+export interface CacheStats {
+    /** Number of entries in cache */
+    size: number;
+    /** Cache hit rate (0-1) */
+    hitRate: number;
+    /** Total cache hits */
+    hits: number;
+    /** Total cache misses */
+    misses: number;
+    /** Total evictions */
+    evictions: number;
+    /** Memory usage in bytes */
+    memoryUsage: number;
+}
+/**
+ * Cached entry wrapper
+ */
+export interface CachedEntry<T> {
+    /** The cached data */
+    data: T;
+    /** When the entry was cached */
+    cachedAt: number;
+    /** When the entry expires */
+    expiresAt: number;
+    /** Last access timestamp */
+    lastAccessedAt: number;
+    /** Access count */
+    accessCount: number;
+}
+/**
+ * Migration source type
+ */
+export type MigrationSource = 'sqlite' | 'markdown' | 'json' | 'memory-manager' | 'swarm-memory' | 'distributed-memory';
+/**
+ * Migration configuration
+ */
+export interface MigrationConfig {
+    /** Source backend type */
+    source: MigrationSource;
+    /** Source path or connection string */
+    sourcePath: string;
+    /** Batch size for migration */
+    batchSize: number;
+    /** Generate embeddings during migration */
+    generateEmbeddings: boolean;
+    /** Validate data during migration */
+    validateData: boolean;
+    /** Continue on error */
+    continueOnError: boolean;
+    /** Namespace mapping */
+    namespaceMapping?: Record<string, string>;
+    /** Type mapping */
+    typeMapping?: Record<string, MemoryType>;
+}
+/**
+ * Migration progress
+ */
+export interface MigrationProgress {
+    /** Total entries to migrate */
+    total: number;
+    /** Entries migrated so far */
+    migrated: number;
+    /** Entries failed */
+    failed: number;
+    /** Entries skipped */
+    skipped: number;
+    /** Current batch number */
+    currentBatch: number;
+    /** Total batches */
+    totalBatches: number;
+    /** Progress percentage (0-100) */
+    percentage: number;
+    /** Estimated time remaining in milliseconds */
+    estimatedTimeRemaining: number;
+    /** Errors encountered */
+    errors: MigrationError[];
+}
+/**
+ * Migration error
+ */
+export interface MigrationError {
+    /** Entry ID or key that failed */
+    entryId: string;
+    /** Error message */
+    message: string;
+    /** Error code */
+    code: string;
+    /** Whether the error is recoverable */
+    recoverable: boolean;
+}
+/**
+ * Migration result
+ */
+export interface MigrationResult {
+    /** Whether migration completed successfully */
+    success: boolean;
+    /** Final progress state */
+    progress: MigrationProgress;
+    /** Total time taken in milliseconds */
+    duration: number;
+    /** Summary message */
+    summary: string;
+}
+/**
+ * Memory event types
+ */
+export type MemoryEventType = 'entry:created' | 'entry:updated' | 'entry:deleted' | 'entry:accessed' | 'entry:expired' | 'cache:hit' | 'cache:miss' | 'cache:eviction' | 'index:rebuilt' | 'migration:started' | 'migration:progress' | 'migration:completed' | 'migration:failed';
+/**
+ * Memory event payload
+ */
+export interface MemoryEvent {
+    type: MemoryEventType;
+    timestamp: number;
+    data: Record<string, unknown>;
+}
+/**
+ * Memory event handler
+ */
+export type MemoryEventHandler = (event: MemoryEvent) => void | Promise<void>;
+/**
+ * SONA learning mode for adaptive memory
+ */
+export type SONAMode = 'real-time' | 'balanced' | 'research' | 'edge' | 'batch';
+/**
+ * Learning pattern from SONA integration
+ */
+export interface LearningPattern {
+    /** Pattern ID */
+    id: string;
+    /** Pattern data */
+    data: Record<string, unknown>;
+    /** SONA mode used */
+    mode: SONAMode;
+    /** Reward signal */
+    reward: number;
+    /** Trajectory data */
+    trajectory: unknown[];
+    /** Adaptation time in milliseconds */
+    adaptationTime: number;
+    /** Creation timestamp */
+    createdAt: number;
+}
+/**
+ * Embedding generator function type
+ */
+export type EmbeddingGenerator = (content: string) => Promise<Float32Array>;
+/**
+ * Generates a unique memory ID
+ */
+export declare function generateMemoryId(): string;
+/**
+ * Creates a default memory entry
+ */
+export declare function createDefaultEntry(input: MemoryEntryInput): MemoryEntry;
+/**
+ * Performance targets for V1 memory system
+ */
+export declare const PERFORMANCE_TARGETS: {
+    /** Maximum vector search time for 100k vectors */
+    readonly MAX_SEARCH_TIME_100K: 1;
+    /** Maximum write time per entry */
+    readonly MAX_WRITE_TIME: 5;
+    /** Maximum batch insert time per entry */
+    readonly MAX_BATCH_INSERT_TIME: 1;
+    /** Target memory reduction from legacy systems */
+    readonly MEMORY_REDUCTION_TARGET: 0.5;
+    /** Minimum search improvement over brute force */
+    readonly MIN_SEARCH_IMPROVEMENT: 150;
+    /** Maximum search improvement over brute force */
+    readonly MAX_SEARCH_IMPROVEMENT: 12500;
+};
+export type { LearningBridgeConfig, LearningStats, ConsolidateResult, PatternMatch, } from './learning-bridge.js';
+export type { MemoryGraphConfig, GraphNode, GraphEdge, GraphStats, RankedResult, EdgeType, } from './memory-graph.js';
+export type { AgentMemoryScope, AgentScopedConfig, TransferOptions, TransferResult, } from './agent-memory-scope.js';
+export interface TierManagerConfig {
+    shortTermCapacity: number;
+    entityStorePath: string;
+    contextualNamespace: string;
+    autoFlushOnSessionEnd: boolean;
+}
+export interface Episode {
+    episodeId: string;
+    sessionId: string;
+    runIds: string[];
+    summary: string;
+    startedAt: number;
+    endedAt: number;
+    agentSlugs: string[];
+    taskTypes: string[];
+    tokenEstimate: number;
+}
+export interface EpisodicStoreConfig {
+    filePath: string;
+    maxRunsPerEpisode: number;
+    summarizer?: (content: string) => Promise<string>;
+}
+//# sourceMappingURL=types.d.ts.map