moflo 4.8.30 → 4.8.32

package/src/@claude-flow/memory/dist/hybrid-backend.d.ts

@@ -1,245 +0,0 @@
-/**
- * HybridBackend - Combines SQLite (structured queries) + AgentDB (vector search)
- *
- * Per ADR-009: "HybridBackend (SQLite + AgentDB) as default"
- * - SQLite for: Structured queries, ACID transactions, exact matches
- * - AgentDB for: Semantic search, vector similarity, RAG
- *
- * @module v3/memory/hybrid-backend
- */
-import { EventEmitter } from 'node:events';
-import { IMemoryBackend, MemoryEntry, MemoryEntryUpdate, MemoryQuery, SearchOptions, SearchResult, BackendStats, HealthCheckResult, EmbeddingGenerator } from './types.js';
-import { SQLiteBackend, SQLiteBackendConfig } from './sqlite-backend.js';
-import { AgentDBBackend, AgentDBBackendConfig } from './agentdb-backend.js';
-/**
- * Configuration for HybridBackend
- */
-export interface HybridBackendConfig {
-    /** SQLite configuration */
-    sqlite?: Partial<SQLiteBackendConfig>;
-    /** AgentDB configuration */
-    agentdb?: Partial<AgentDBBackendConfig>;
-    /** Default namespace */
-    defaultNamespace?: string;
-    /** Embedding generator function */
-    embeddingGenerator?: EmbeddingGenerator;
-    /** Query routing strategy */
-    routingStrategy?: 'auto' | 'sqlite-first' | 'agentdb-first';
-    /** Enable dual-write (write to both backends) */
-    dualWrite?: boolean;
-    /** Semantic search threshold for hybrid queries */
-    semanticThreshold?: number;
-    /** Maximum results to fetch from each backend in hybrid queries */
-    hybridMaxResults?: number;
-}
-/**
- * Structured Query Interface
- * Optimized for SQLite's strengths
- */
-export interface StructuredQuery {
-    /** Exact key match */
-    key?: string;
-    /** Key prefix match */
-    keyPrefix?: string;
-    /** Namespace filter */
-    namespace?: string;
-    /** Owner filter */
-    ownerId?: string;
-    /** Type filter */
-    type?: string;
-    /** Time range filters */
-    createdAfter?: number;
-    createdBefore?: number;
-    updatedAfter?: number;
-    updatedBefore?: number;
-    /** Pagination */
-    limit?: number;
-    offset?: number;
-}
-/**
- * Semantic Query Interface
- * Optimized for AgentDB's vector search
- */
-export interface SemanticQuery {
-    /** Content to search for (will be embedded) */
-    content?: string;
-    /** Pre-computed embedding */
-    embedding?: Float32Array;
-    /** Number of results */
-    k?: number;
-    /** Similarity threshold (0-1) */
-    threshold?: number;
-    /** Additional filters */
-    filters?: Partial<MemoryQuery>;
-}
-/**
- * Hybrid Query Interface
- * Combines structured + semantic search
- */
-export interface HybridQuery {
-    /** Semantic component */
-    semantic: SemanticQuery;
-    /** Structured component */
-    structured?: StructuredQuery;
-    /** How to combine results */
-    combineStrategy?: 'union' | 'intersection' | 'semantic-first' | 'structured-first';
-    /** Weights for score combination */
-    weights?: {
-        semantic: number;
-        structured: number;
-    };
-}
-/**
- * HybridBackend Implementation
- *
- * Intelligently routes queries between SQLite and AgentDB:
- * - Exact matches, prefix queries → SQLite
- * - Semantic search, similarity → AgentDB
- * - Complex hybrid queries → Both backends with intelligent merging
- */
-export declare class HybridBackend extends EventEmitter implements IMemoryBackend {
-    private sqlite;
-    private agentdb;
-    private config;
-    private initialized;
-    private stats;
-    constructor(config?: HybridBackendConfig);
-    /**
-     * Initialize both backends
-     */
-    initialize(): Promise<void>;
-    /**
-     * Shutdown both backends
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Store in both backends (dual-write for consistency)
-     */
-    store(entry: MemoryEntry): Promise<void>;
-    /**
-     * Get from AgentDB (has caching enabled)
-     */
-    get(id: string): Promise<MemoryEntry | null>;
-    /**
-     * Get by key (SQLite optimized for exact matches)
-     */
-    getByKey(namespace: string, key: string): Promise<MemoryEntry | null>;
-    /**
-     * Update in both backends
-     */
-    update(id: string, update: MemoryEntryUpdate): Promise<MemoryEntry | null>;
-    /**
-     * Delete from both backends
-     */
-    delete(id: string): Promise<boolean>;
-    /**
-     * Query routing - semantic goes to AgentDB, structured to SQLite
-     */
-    query(query: MemoryQuery): Promise<MemoryEntry[]>;
-    /**
-     * Structured queries (SQL)
-     * Routes to SQLite for optimal performance
-     */
-    queryStructured(query: StructuredQuery): Promise<MemoryEntry[]>;
-    /**
-     * Semantic queries (vector)
-     * Routes to AgentDB for HNSW-based vector search
-     */
-    querySemantic(query: SemanticQuery): Promise<MemoryEntry[]>;
-    /**
-     * Hybrid queries (combine both)
-     * Intelligently merges results from both backends
-     */
-    queryHybrid(query: HybridQuery): Promise<MemoryEntry[]>;
-    /**
-     * Semantic vector search (routes to AgentDB)
-     */
-    search(embedding: Float32Array, options: SearchOptions): Promise<SearchResult[]>;
-    /**
-     * Bulk insert to both backends
-     */
-    bulkInsert(entries: MemoryEntry[]): Promise<void>;
-    /**
-     * Bulk delete from both backends
-     */
-    bulkDelete(ids: string[]): Promise<number>;
-    /**
-     * Count entries (use SQLite for efficiency)
-     */
-    count(namespace?: string): Promise<number>;
-    /**
-     * List namespaces (use SQLite)
-     */
-    listNamespaces(): Promise<string[]>;
-    /**
-     * Clear namespace in both backends
-     */
-    clearNamespace(namespace: string): Promise<number>;
-    /**
-     * Get combined statistics from both backends
-     */
-    getStats(): Promise<BackendStats>;
-    /**
-     * Health check for both backends
-     */
-    healthCheck(): Promise<HealthCheckResult>;
-    /**
-     * Auto-route queries based on properties
-     */
-    private autoRoute;
-    /**
-     * Internal hybrid query implementation
-     */
-    private queryHybridInternal;
-    /**
-     * Combine results using union (all unique results)
-     */
-    private combineUnion;
-    /**
-     * Combine results using intersection (only common results)
-     */
-    private combineIntersection;
-    /**
-     * Semantic-first: Prefer semantic results, add structured if not present
-     */
-    private combineSemanticFirst;
-    /**
-     * Structured-first: Prefer structured results, add semantic if not present
-     */
-    private combineStructuredFirst;
-    /**
-     * Record feedback for a memory entry.
-     * Delegates to AgentDB's recordFeedback when available.
-     * Gracefully degrades to a no-op when AgentDB is unavailable.
-     */
-    recordFeedback(entryId: string, feedback: {
-        score: number;
-        label?: string;
-        context?: Record<string, unknown>;
-    }): Promise<boolean>;
-    /**
-     * Verify a witness chain for a memory entry.
-     * Delegates to AgentDB's verifyWitnessChain when available.
-     */
-    verifyWitnessChain(entryId: string): Promise<{
-        valid: boolean;
-        chainLength: number;
-        errors: string[];
-    }>;
-    /**
-     * Get the witness chain for a memory entry.
-     * Delegates to AgentDB's getWitnessChain when available.
-     */
-    getWitnessChain(entryId: string): Promise<Array<{
-        hash: string;
-        timestamp: number;
-        operation: string;
-    }>>;
-    /**
-     * Get underlying backends for advanced operations
-     */
-    getSQLiteBackend(): SQLiteBackend;
-    getAgentDBBackend(): AgentDBBackend;
-}
-export default HybridBackend;
-//# sourceMappingURL=hybrid-backend.d.ts.map

package/src/@claude-flow/memory/dist/hybrid-backend.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Tests for HybridBackend (ADR-009)
- *
- * Verifies that the hybrid backend correctly routes queries between
- * SQLite (structured) and AgentDB (semantic) backends.
- */
-export {};
-//# sourceMappingURL=hybrid-backend.test.d.ts.map

package/src/@claude-flow/memory/dist/index.d.ts

@@ -1,204 +0,0 @@
-/**
- * @claude-flow/memory - V3 Unified Memory System
- *
- * Provides a unified memory interface backed by AgentDB with HNSW indexing
- * for 150x-12,500x faster vector search compared to brute-force approaches.
- *
- * @module @claude-flow/memory
- *
- * @example
- * ```typescript
- * import { UnifiedMemoryService, query, QueryTemplates } from '@claude-flow/memory';
- *
- * // Initialize the memory service
- * const memory = new UnifiedMemoryService({
- *   dimensions: 1536,
- *   cacheEnabled: true,
- *   embeddingGenerator: async (text) => embeddings.embed(text),
- * });
- *
- * await memory.initialize();
- *
- * // Store entries
- * await memory.store({
- *   key: 'auth-patterns',
- *   content: 'OAuth 2.0 implementation patterns for secure authentication',
- *   tags: ['auth', 'security', 'patterns'],
- * });
- *
- * // Semantic search
- * const results = await memory.semanticSearch('user authentication best practices', 5);
- *
- * // Query with fluent builder
- * const entries = await memory.query(
- *   query()
- *     .semantic('security vulnerabilities')
- *     .inNamespace('security')
- *     .withTags(['critical'])
- *     .threshold(0.8)
- *     .limit(10)
- *     .build()
- * );
- * ```
- */
-export type { MemoryType, AccessLevel, ConsistencyLevel, DistanceMetric, MemoryEntry, MemoryEntryInput, MemoryEntryUpdate, QueryType, MemoryQuery, SearchResult, SearchOptions, HNSWConfig, HNSWStats, QuantizationConfig, IMemoryBackend, BackendStats, HealthCheckResult, ComponentHealth, CacheConfig, CacheStats, CachedEntry, MigrationSource, MigrationConfig, MigrationProgress, MigrationResult, MigrationError, MemoryEventType, MemoryEvent, MemoryEventHandler, SONAMode, LearningPattern, EmbeddingGenerator, } from './types.js';
-export { generateMemoryId, createDefaultEntry, PERFORMANCE_TARGETS, } from './types.js';
-export { AutoMemoryBridge, resolveAutoMemoryDir, findGitRoot } from './auto-memory-bridge.js';
-export type { AutoMemoryBridgeConfig, MemoryInsight, InsightCategory, SyncDirection, SyncMode, PruneStrategy, SyncResult, ImportResult, } from './auto-memory-bridge.js';
-export { LearningBridge } from './learning-bridge.js';
-export type { LearningBridgeConfig, LearningStats, ConsolidateResult, PatternMatch, } from './learning-bridge.js';
-export { RvfLearningStore } from './rvf-learning-store.js';
-export type { RvfLearningStoreConfig, PatternRecord, LoraRecord, EwcRecord, TrajectoryRecord, } from './rvf-learning-store.js';
-export { PersistentSonaCoordinator } from './persistent-sona.js';
-export type { PersistentSonaConfig } from './persistent-sona.js';
-export { RvfMigrator } from './rvf-migration.js';
-export type { RvfMigrationOptions, RvfMigrationResult } from './rvf-migration.js';
-export { MemoryGraph } from './memory-graph.js';
-export type { MemoryGraphConfig, GraphNode, GraphEdge, GraphStats, RankedResult, EdgeType, } from './memory-graph.js';
-export { resolveAgentMemoryDir, createAgentBridge, transferKnowledge, listAgentScopes, } from './agent-memory-scope.js';
-export type { AgentMemoryScope, AgentScopedConfig, TransferOptions, TransferResult, } from './agent-memory-scope.js';
-export { ControllerRegistry, INIT_LEVELS } from './controller-registry.js';
-export type { AgentDBControllerName, CLIControllerName, ControllerName, InitLevel, ControllerHealth, RegistryHealthReport, RuntimeConfig, } from './controller-registry.js';
-export { AgentDBAdapter } from './agentdb-adapter.js';
-export type { AgentDBAdapterConfig } from './agentdb-adapter.js';
-export { AgentDBBackend } from './agentdb-backend.js';
-export type { AgentDBBackendConfig } from './agentdb-backend.js';
-export { SqlJsBackend } from './sqljs-backend.js';
-export type { SqlJsBackendConfig } from './sqljs-backend.js';
-export { RvfBackend } from './rvf-backend.js';
-export type { RvfBackendConfig } from './rvf-backend.js';
-export { HnswLite, cosineSimilarity } from './hnsw-lite.js';
-export type { HnswSearchResult } from './hnsw-lite.js';
-export { HNSWIndex } from './hnsw-index.js';
-export { CacheManager, TieredCacheManager } from './cache-manager.js';
-export { QueryBuilder, query, QueryTemplates } from './query-builder.js';
-export type { SortDirection, SortField } from './query-builder.js';
-export { MemoryMigrator, createMigrator, migrateMultipleSources } from './migration.js';
-export { createDatabase, getPlatformInfo, getAvailableProviders } from './database-provider.js';
-export type { DatabaseProvider, DatabaseOptions } from './database-provider.js';
-import { EventEmitter } from 'node:events';
-import { IMemoryBackend, MemoryEntry, MemoryEntryInput, MemoryEntryUpdate, MemoryQuery, SearchResult, SearchOptions, BackendStats, HealthCheckResult, EmbeddingGenerator, MigrationSource, MigrationConfig, MigrationResult } from './types.js';
-import { AgentDBAdapter, AgentDBAdapterConfig } from './agentdb-adapter.js';
-/**
- * Configuration for UnifiedMemoryService
- */
-export interface UnifiedMemoryServiceConfig extends Partial<AgentDBAdapterConfig> {
-    /** Enable automatic embedding generation */
-    autoEmbed?: boolean;
-    /** Default embedding dimensions */
-    dimensions?: number;
-    /** Embedding generator function */
-    embeddingGenerator?: EmbeddingGenerator;
-}
-/**
- * Unified Memory Service
- *
- * High-level interface for the V3 memory system that provides:
- * - Simple API for common operations
- * - Automatic embedding generation
- * - Cross-agent memory sharing
- * - SONA integration for learning
- * - Event-driven notifications
- * - Performance monitoring
- */
-export declare class UnifiedMemoryService extends EventEmitter implements IMemoryBackend {
-    private adapter;
-    private config;
-    private initialized;
-    constructor(config?: UnifiedMemoryServiceConfig);
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    store(entry: MemoryEntry): Promise<void>;
-    get(id: string): Promise<MemoryEntry | null>;
-    getByKey(namespace: string, key: string): Promise<MemoryEntry | null>;
-    update(id: string, update: MemoryEntryUpdate): Promise<MemoryEntry | null>;
-    delete(id: string): Promise<boolean>;
-    query(query: MemoryQuery): Promise<MemoryEntry[]>;
-    search(embedding: Float32Array, options: SearchOptions): Promise<SearchResult[]>;
-    bulkInsert(entries: MemoryEntry[]): Promise<void>;
-    bulkDelete(ids: string[]): Promise<number>;
-    count(namespace?: string): Promise<number>;
-    listNamespaces(): Promise<string[]>;
-    clearNamespace(namespace: string): Promise<number>;
-    getStats(): Promise<BackendStats>;
-    healthCheck(): Promise<HealthCheckResult>;
-    /**
-     * Store an entry from simple input
-     */
-    storeEntry(input: MemoryEntryInput): Promise<MemoryEntry>;
-    /**
-     * Semantic search by content string
-     */
-    semanticSearch(content: string, k?: number, threshold?: number): Promise<SearchResult[]>;
-    /**
-     * Find similar entries to a given entry
-     */
-    findSimilar(id: string, k?: number): Promise<SearchResult[]>;
-    /**
-     * Get or create an entry
-     */
-    getOrCreate(namespace: string, key: string, creator: () => MemoryEntryInput | Promise<MemoryEntryInput>): Promise<MemoryEntry>;
-    /**
-     * Append content to an existing entry
-     */
-    appendContent(id: string, content: string): Promise<MemoryEntry | null>;
-    /**
-     * Add tags to an existing entry
-     */
-    addTags(id: string, tags: string[]): Promise<MemoryEntry | null>;
-    /**
-     * Remove tags from an existing entry
-     */
-    removeTags(id: string, tags: string[]): Promise<MemoryEntry | null>;
-    /**
-     * Migrate from a legacy memory source
-     */
-    migrateFrom(source: MigrationSource, sourcePath: string, options?: Partial<MigrationConfig>): Promise<MigrationResult>;
-    /**
-     * Share an entry with another agent
-     */
-    shareWith(id: string, agentId: string): Promise<MemoryEntry | null>;
-    /**
-     * Get entries shared with a specific agent
-     */
-    getSharedWith(agentId: string): Promise<MemoryEntry[]>;
-    /**
-     * Get the underlying adapter for advanced operations
-     */
-    getAdapter(): AgentDBAdapter;
-    /**
-     * Check if the service is initialized
-     */
-    isInitialized(): boolean;
-}
-/**
- * Create a simple in-memory service (for testing)
- */
-export declare function createInMemoryService(): UnifiedMemoryService;
-/**
- * Create a persistent memory service
- */
-export declare function createPersistentService(path: string): UnifiedMemoryService;
-/**
- * Create a memory service with embedding support
- */
-export declare function createEmbeddingService(embeddingGenerator: EmbeddingGenerator, dimensions?: number): UnifiedMemoryService;
-/**
- * Create a hybrid memory service (SQLite + AgentDB)
- * This is the DEFAULT recommended configuration per ADR-009
- *
- * @example
- * ```typescript
- * const memory = createHybridService('./data/memory.db', embeddingFn);
- * await memory.initialize();
- *
- * // Structured queries go to SQLite
- * const user = await memory.getByKey('users', 'john@example.com');
- *
- * // Semantic queries go to AgentDB
- * const similar = await memory.semanticSearch('authentication patterns', 10);
- * ```
- */
-export declare function createHybridService(databasePath: string, embeddingGenerator: EmbeddingGenerator, dimensions?: number): UnifiedMemoryService;
-export default UnifiedMemoryService;
-//# sourceMappingURL=index.d.ts.map

package/src/@claude-flow/memory/dist/infrastructure/index.d.ts

@@ -1,17 +0,0 @@
-/**
- * Memory Infrastructure Layer - Public Exports
- *
- * Exports all infrastructure implementations including repositories,
- * adapters, and external service integrations.
- *
- * @module v3/memory/infrastructure
- */
-export { HybridMemoryRepository, type HybridRepositoryConfig, } from './repositories/hybrid-memory-repository.js';
-export { AgentDBAdapter } from '../agentdb-adapter.js';
-export type { AgentDBAdapterConfig } from '../agentdb-adapter.js';
-export { HNSWIndex } from '../hnsw-index.js';
-export type { HNSWConfig } from '../types.js';
-export { CacheManager } from '../cache-manager.js';
-export type { CacheConfig } from '../types.js';
-export { MemoryMigrator } from '../migration.js';
-//# sourceMappingURL=index.d.ts.map

package/src/@claude-flow/memory/dist/infrastructure/repositories/hybrid-memory-repository.d.ts

@@ -1,66 +0,0 @@
-/**
- * Hybrid Memory Repository - Infrastructure Layer
- *
- * Implements IMemoryRepository using SQLite + AgentDB hybrid backend.
- * Per ADR-009, this is the default memory backend.
- *
- * @module v3/memory/infrastructure/repositories
- */
-import { MemoryEntry, MemoryType, MemoryStatus } from '../../domain/entities/memory-entry.js';
-import { IMemoryRepository, MemoryQueryOptions, VectorSearchOptions, VectorSearchResult, BulkOperationResult, MemoryStatistics } from '../../domain/repositories/memory-repository.interface.js';
-/**
- * Repository configuration
- */
-export interface HybridRepositoryConfig {
-    sqlitePath: string;
-    agentDbPath?: string;
-    enableVectorSearch?: boolean;
-    cacheSize?: number;
-    verbose?: boolean;
-}
-/**
- * Hybrid Memory Repository
- *
- * Uses SQLite for metadata and AgentDB for vectors.
- * Implements hot caching for frequently accessed entries.
- */
-export declare class HybridMemoryRepository implements IMemoryRepository {
-    private readonly config;
-    private entries;
-    private namespaceIndex;
-    private vectorIndex;
-    private cache;
-    private initialized;
-    constructor(config: HybridRepositoryConfig);
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    clear(): Promise<void>;
-    save(entry: MemoryEntry): Promise<void>;
-    findById(id: string): Promise<MemoryEntry | null>;
-    findByKey(namespace: string, key: string): Promise<MemoryEntry | null>;
-    findByCompositeKey(compositeKey: string): Promise<MemoryEntry | null>;
-    delete(id: string): Promise<boolean>;
-    exists(id: string): Promise<boolean>;
-    saveMany(entries: MemoryEntry[]): Promise<BulkOperationResult>;
-    findByIds(ids: string[]): Promise<MemoryEntry[]>;
-    deleteMany(ids: string[]): Promise<BulkOperationResult>;
-    findAll(options?: MemoryQueryOptions): Promise<MemoryEntry[]>;
-    findByNamespace(namespace: string, options?: Omit<MemoryQueryOptions, 'namespace'>): Promise<MemoryEntry[]>;
-    findByType(type: MemoryType, options?: Omit<MemoryQueryOptions, 'type'>): Promise<MemoryEntry[]>;
-    findByStatus(status: MemoryStatus, options?: Omit<MemoryQueryOptions, 'status'>): Promise<MemoryEntry[]>;
-    searchByVector(options: VectorSearchOptions): Promise<VectorSearchResult[]>;
-    findSimilar(entryId: string, limit?: number): Promise<VectorSearchResult[]>;
-    findExpired(): Promise<MemoryEntry[]>;
-    deleteExpired(): Promise<number>;
-    findCold(milliseconds: number): Promise<MemoryEntry[]>;
-    archiveCold(milliseconds: number): Promise<number>;
-    getStatistics(): Promise<MemoryStatistics>;
-    count(options?: MemoryQueryOptions): Promise<number>;
-    listNamespaces(): Promise<string[]>;
-    deleteNamespace(namespace: string): Promise<number>;
-    getNamespaceSize(namespace: string): Promise<number>;
-    private ensureInitialized;
-    private updateCache;
-    private cosineSimilarity;
-}
-//# sourceMappingURL=hybrid-memory-repository.d.ts.map

package/src/@claude-flow/memory/dist/learning-bridge.d.ts

@@ -1,137 +0,0 @@
-/**
- * LearningBridge - Connects AutoMemoryBridge to NeuralLearningSystem
- *
- * When insights are recorded via AutoMemoryBridge, this module triggers
- * neural learning trajectories so the system continuously improves from
- * its own discoveries. The NeuralLearningSystem dependency is optional:
- * when unavailable, all operations degrade gracefully to no-ops.
- *
- * @module @claude-flow/memory/learning-bridge
- */
-import { EventEmitter } from 'node:events';
-import type { IMemoryBackend, SONAMode } from './types.js';
-import type { MemoryInsight } from './auto-memory-bridge.js';
-/**
- * Factory function that returns a neural system instance.
- * Used for dependency injection so tests can supply a mock.
- */
-export type NeuralLoader = () => Promise<any>;
-/** Configuration for the LearningBridge */
-export interface LearningBridgeConfig {
-    /** SONA operating mode (default: 'balanced') */
-    sonaMode?: SONAMode;
-    /** Per-hour confidence decay rate (default: 0.005) */
-    confidenceDecayRate?: number;
-    /** Confidence boost per access (default: 0.03) */
-    accessBoostAmount?: number;
-    /** Maximum confidence value (default: 1.0) */
-    maxConfidence?: number;
-    /** Minimum confidence floor (default: 0.1) */
-    minConfidence?: number;
-    /** EWC regularization strength (default: 2000) */
-    ewcLambda?: number;
-    /** Min active trajectories before consolidation runs (default: 10) */
-    consolidationThreshold?: number;
-    /** Enable the bridge (default: true). When false all methods are no-ops */
-    enabled?: boolean;
-    /**
-     * Optional factory for the neural learning system.
-     * When provided, this replaces the default dynamic import of @claude-flow/neural.
-     * Primarily used for testing.
-     */
-    neuralLoader?: NeuralLoader;
-}
-/** Aggregated learning statistics */
-export interface LearningStats {
-    totalTrajectories: number;
-    completedTrajectories: number;
-    activeTrajectories: number;
-    totalConsolidations: number;
-    totalDecays: number;
-    avgConfidenceBoost: number;
-    neuralAvailable: boolean;
-}
-/** Result returned by consolidate() */
-export interface ConsolidateResult {
-    trajectoriesCompleted: number;
-    patternsLearned: number;
-    entriesUpdated: number;
-    durationMs: number;
-}
-/** A single pattern match returned by findSimilarPatterns() */
-export interface PatternMatch {
-    content: string;
-    similarity: number;
-    category: string;
-    confidence: number;
-}
-/**
- * Connects AutoMemoryBridge insights to the NeuralLearningSystem.
- *
- * @example
- * ```typescript
- * const bridge = new LearningBridge(memoryBackend);
- * await bridge.onInsightRecorded(insight, entryId);
- * await bridge.onInsightAccessed(entryId);
- * const result = await bridge.consolidate();
- * ```
- */
-export declare class LearningBridge extends EventEmitter {
-    private neural;
-    private backend;
-    private config;
-    private activeTrajectories;
-    private stats;
-    private destroyed;
-    private neuralInitPromise;
-    constructor(backend: IMemoryBackend, config?: LearningBridgeConfig);
-    /**
-     * Notify the bridge that an insight has been recorded in AgentDB.
-     * Creates a learning trajectory so the neural system can track the
-     * insight's lifecycle.
-     */
-    onInsightRecorded(insight: MemoryInsight, entryId: string): Promise<void>;
-    /**
-     * Notify the bridge that an insight entry was accessed.
-     * Boosts confidence in the backend and records a step in the
-     * trajectory if one exists.
-     */
-    onInsightAccessed(entryId: string): Promise<void>;
-    /**
-     * Consolidate active trajectories by completing them in the neural system.
-     * Only runs when there are enough active trajectories to justify the cost.
-     */
-    consolidate(): Promise<ConsolidateResult>;
-    /**
-     * Apply time-based confidence decay to entries in the given namespace.
-     * Entries not accessed for more than one hour see their confidence reduced
-     * proportionally to the hours elapsed, down to minConfidence.
-     *
-     * @returns number of entries whose confidence was lowered
-     */
-    decayConfidences(namespace: string): Promise<number>;
-    /**
-     * Find patterns similar to the given content using the neural system.
-     * Returns an empty array when the neural system is unavailable.
-     */
-    findSimilarPatterns(content: string, k?: number): Promise<PatternMatch[]>;
-    /** Return aggregated learning statistics */
-    getStats(): LearningStats;
-    /** Tear down the bridge. Subsequent method calls become no-ops. */
-    destroy(): void;
-    /**
-     * Lazily attempt to load and initialize the NeuralLearningSystem.
-     * The promise is cached so that repeated calls do not re-attempt
-     * after a failure.
-     */
-    private initNeural;
-    private loadNeural;
-    /**
-     * Create a deterministic hash-based embedding for content.
-     * This is a lightweight stand-in for a real embedding model,
-     * suitable for pattern matching within the neural trajectory system.
-     */
-    private createHashEmbedding;
-}
-export default LearningBridge;
-//# sourceMappingURL=learning-bridge.d.ts.map

package/src/@claude-flow/memory/dist/learning-bridge.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Tests for LearningBridge
- *
- * TDD London School (mock-first) tests for the bridge that connects
- * AutoMemoryBridge insights to the NeuralLearningSystem.
- */
-export {};
-//# sourceMappingURL=learning-bridge.test.d.ts.map