moflo 4.8.16 → 4.8.19

package/src/@claude-flow/memory/dist/controller-registry.js

@@ -1,893 +0,0 @@
-/**
- * ControllerRegistry - Central controller lifecycle management for AgentDB v3
- *
- * Wraps the AgentDB class and adds CLI-specific controllers from @claude-flow/memory.
- * Manages initialization (level-based ordering), health checks, and graceful shutdown.
- *
- * Per ADR-053: Replaces memory-initializer.js's raw sql.js usage with a unified
- * controller ecosystem routing all memory operations through AgentDB v3.
- *
- * @module @claude-flow/memory/controller-registry
- */
-import { EventEmitter } from 'node:events';
-import * as path from 'node:path';
-import { LearningBridge } from './learning-bridge.js';
-import { MemoryGraph } from './memory-graph.js';
-import { TieredCacheManager } from './cache-manager.js';
-// ===== Initialization Levels =====
-/**
- * Level-based initialization order per ADR-053.
- * Controllers at each level can be initialized in parallel.
- * Each level must complete before the next begins.
- */
-export const INIT_LEVELS = [
-    // Level 0: Foundation - already exists
-    { level: 0, controllers: [] },
-    // Level 1: Core intelligence
-    { level: 1, controllers: ['reasoningBank', 'hierarchicalMemory', 'learningBridge', 'hybridSearch', 'tieredCache'] },
-    // Level 2: Graph & security
-    { level: 2, controllers: ['memoryGraph', 'agentMemoryScope', 'vectorBackend', 'mutationGuard', 'gnnService'] },
-    // Level 3: Specialization
-    { level: 3, controllers: ['skills', 'explainableRecall', 'reflexion', 'attestationLog', 'batchOperations', 'memoryConsolidation'] },
-    // Level 4: Causal & routing
-    { level: 4, controllers: ['causalGraph', 'nightlyLearner', 'learningSystem', 'semanticRouter'] },
-    // Level 5: Advanced services
-    { level: 5, controllers: ['graphTransformer', 'sonaTrajectory', 'contextSynthesizer', 'rvfOptimizer', 'mmrDiversityRanker', 'guardedVectorBackend'] },
-    // Level 6: Session management
-    { level: 6, controllers: ['federatedSession', 'graphAdapter'] },
-];
-// ===== ControllerRegistry =====
-/**
- * Central registry for AgentDB v3 controller lifecycle management.
- *
- * Handles:
- * - Level-based initialization ordering (levels 0-6)
- * - Graceful degradation (each controller fails independently)
- * - Config-driven activation (controllers only instantiate when enabled)
- * - Health check aggregation across all controllers
- * - Ordered shutdown (reverse initialization order)
- *
- * @example
- * ```typescript
- * const registry = new ControllerRegistry();
- * await registry.initialize({
- *   dbPath: './data/memory.db',
- *   dimension: 384,
- *   memory: {
- *     enableHNSW: true,
- *     learningBridge: { sonaMode: 'balanced' },
- *     memoryGraph: { pageRankDamping: 0.85 },
- *   },
- * });
- *
- * const reasoning = registry.get<ReasoningBank>('reasoningBank');
- * const graph = registry.get<MemoryGraph>('memoryGraph');
- *
- * await registry.shutdown();
- * ```
- */
-export class ControllerRegistry extends EventEmitter {
-    controllers = new Map();
-    agentdb = null;
-    backend = null;
-    config = {};
-    initialized = false;
-    initTimeMs = 0;
-    /**
-     * Initialize all controllers in level-based order.
-     *
-     * Each level's controllers are initialized in parallel within the level.
-     * Failures are isolated: a controller that fails to init is marked as
-     * unavailable but does not block other controllers.
-     */
-    async initialize(config = {}) {
-        if (this.initialized)
-            return;
-        this.initialized = true; // Set early to prevent concurrent re-entry
-        this.config = config;
-        const startTime = performance.now();
-        // Step 1: Initialize AgentDB (the core)
-        await this.initAgentDB(config);
-        // Step 2: Set up the backend
-        this.backend = config.backend || null;
-        // Step 3: Initialize controllers level by level
-        for (const level of INIT_LEVELS) {
-            const controllersToInit = level.controllers.filter((name) => this.isControllerEnabled(name));
-            if (controllersToInit.length === 0)
-                continue;
-            // Initialize all controllers in this level in parallel
-            const results = await Promise.allSettled(controllersToInit.map((name) => this.initController(name, level.level)));
-            // Process results
-            for (let i = 0; i < results.length; i++) {
-                const result = results[i];
-                const name = controllersToInit[i];
-                if (result.status === 'rejected') {
-                    const errorMsg = result.reason instanceof Error
-                        ? result.reason.message
-                        : String(result.reason);
-                    this.controllers.set(name, {
-                        name,
-                        instance: null,
-                        level: level.level,
-                        initTimeMs: 0,
-                        enabled: false,
-                        error: errorMsg,
-                    });
-                    this.emit('controller:failed', { name, error: errorMsg, level: level.level });
-                }
-            }
-        }
-        this.initTimeMs = performance.now() - startTime;
-        this.emit('initialized', {
-            initTimeMs: this.initTimeMs,
-            activeControllers: this.getActiveCount(),
-            totalControllers: this.controllers.size,
-        });
-    }
-    /**
-     * Shutdown all controllers in reverse initialization order.
-     */
-    async shutdown() {
-        if (!this.initialized)
-            return;
-        // Shutdown in reverse level order
-        const reverseLevels = [...INIT_LEVELS].reverse();
-        for (const level of reverseLevels) {
-            const controllersToShutdown = level.controllers
-                .filter((name) => {
-                const entry = this.controllers.get(name);
-                return entry?.enabled && entry?.instance;
-            });
-            await Promise.allSettled(controllersToShutdown.map((name) => this.shutdownController(name)));
-        }
-        // Shutdown AgentDB
-        if (this.agentdb) {
-            try {
-                if (typeof this.agentdb.close === 'function') {
-                    await this.agentdb.close();
-                }
-            }
-            catch {
-                // Best-effort cleanup
-            }
-            this.agentdb = null;
-        }
-        this.controllers.clear();
-        this.initialized = false;
-        this.emit('shutdown');
-    }
-    /**
-     * Get a controller instance by name.
-     * Returns null if the controller is not initialized or unavailable.
-     */
-    get(name) {
-        // First check CLI-layer controllers
-        const entry = this.controllers.get(name);
-        if (entry?.enabled && entry?.instance) {
-            return entry.instance;
-        }
-        // Fall back to AgentDB internal controllers
-        if (this.agentdb && typeof this.agentdb.getController === 'function') {
-            try {
-                const controller = this.agentdb.getController(name);
-                if (controller)
-                    return controller;
-            }
-            catch {
-                // Controller not available in AgentDB
-            }
-        }
-        return null;
-    }
-    /**
-     * Check if a controller is enabled and initialized.
-     */
-    isEnabled(name) {
-        const entry = this.controllers.get(name);
-        if (entry?.enabled)
-            return true;
-        // Check AgentDB internal controllers
-        if (this.agentdb && typeof this.agentdb.getController === 'function') {
-            try {
-                return this.agentdb.getController(name) !== null;
-            }
-            catch {
-                return false;
-            }
-        }
-        return false;
-    }
-    /**
-     * Aggregate health check across all controllers.
-     */
-    async healthCheck() {
-        const controllerHealth = [];
-        for (const [name, entry] of this.controllers) {
-            controllerHealth.push({
-                name,
-                status: entry.enabled
-                    ? 'healthy'
-                    : entry.error
-                        ? 'unavailable'
-                        : 'degraded',
-                initTimeMs: entry.initTimeMs,
-                error: entry.error,
-            });
-        }
-        // Check AgentDB health
-        let agentdbAvailable = false;
-        if (this.agentdb) {
-            try {
-                agentdbAvailable = typeof this.agentdb.getController === 'function';
-            }
-            catch {
-                agentdbAvailable = false;
-            }
-        }
-        const active = controllerHealth.filter((c) => c.status === 'healthy').length;
-        const unavailable = controllerHealth.filter((c) => c.status === 'unavailable').length;
-        let status = 'healthy';
-        if (unavailable > 0 && active === 0) {
-            status = 'unhealthy';
-        }
-        else if (unavailable > 0) {
-            status = 'degraded';
-        }
-        return {
-            status,
-            controllers: controllerHealth,
-            agentdbAvailable,
-            initTimeMs: this.initTimeMs,
-            timestamp: Date.now(),
-            activeControllers: active,
-            totalControllers: controllerHealth.length,
-        };
-    }
-    /**
-     * Get the underlying AgentDB instance.
-     */
-    getAgentDB() {
-        return this.agentdb;
-    }
-    /**
-     * Get the memory backend.
-     */
-    getBackend() {
-        return this.backend;
-    }
-    /**
-     * Check if the registry is initialized.
-     */
-    isInitialized() {
-        return this.initialized;
-    }
-    /**
-     * Get the number of active (successfully initialized) controllers.
-     */
-    getActiveCount() {
-        let count = 0;
-        for (const entry of this.controllers.values()) {
-            if (entry.enabled)
-                count++;
-        }
-        return count;
-    }
-    /**
-     * List all registered controller names and their status.
-     */
-    listControllers() {
-        return Array.from(this.controllers.entries()).map(([name, entry]) => ({
-            name,
-            enabled: entry.enabled,
-            level: entry.level,
-        }));
-    }
-    // ===== Private Methods =====
-    /**
-     * Initialize AgentDB instance with dynamic import and fallback chain.
-     */
-    async initAgentDB(config) {
-        try {
-            // Validate dbPath to prevent path traversal
-            const dbPath = config.dbPath || ':memory:';
-            if (dbPath !== ':memory:') {
-                const resolved = path.resolve(dbPath);
-                if (resolved.includes('..')) {
-                    this.emit('agentdb:unavailable', { reason: 'Invalid dbPath' });
-                    return;
-                }
-            }
-            const agentdbModule = await import('agentdb');
-            const AgentDBClass = agentdbModule.AgentDB || agentdbModule.default;
-            if (!AgentDBClass) {
-                this.emit('agentdb:unavailable', { reason: 'No AgentDB class found' });
-                return;
-            }
-            this.agentdb = new AgentDBClass({ dbPath });
-            // Suppress agentdb's noisy info-level output during init
-            // using stderr redirect instead of monkey-patching console.log
-            const origLog = console.log;
-            const suppressFilter = (args) => {
-                const msg = String(args[0] ?? '');
-                return msg.includes('Transformers.js') ||
-                    msg.includes('[AgentDB]');
-            };
-            console.log = (...args) => {
-                if (!suppressFilter(args))
-                    origLog.apply(console, args);
-            };
-            try {
-                await this.agentdb.initialize();
-            }
-            finally {
-                console.log = origLog;
-            }
-            this.emit('agentdb:initialized');
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            this.emit('agentdb:unavailable', { reason: msg.substring(0, 200) });
-            this.agentdb = null;
-        }
-    }
-    /**
-     * Check whether a controller should be initialized based on config.
-     */
-    isControllerEnabled(name) {
-        // Explicit enable/disable from config
-        if (this.config.controllers) {
-            const explicit = this.config.controllers[name];
-            if (explicit !== undefined)
-                return explicit;
-        }
-        // Default behavior: enable based on category
-        switch (name) {
-            // Core intelligence — enabled by default
-            case 'reasoningBank':
-            case 'learningBridge':
-            case 'tieredCache':
-            case 'hierarchicalMemory':
-                return true;
-            // Graph — enabled if backend available
-            case 'memoryGraph':
-                return !!(this.config.memory?.memoryGraph || this.backend);
-            // Security — enabled if AgentDB available
-            case 'mutationGuard':
-            case 'attestationLog':
-            case 'vectorBackend':
-            case 'guardedVectorBackend':
-                return this.agentdb !== null;
-            // AgentDB-internal controllers — only if AgentDB available
-            case 'skills':
-            case 'reflexion':
-            case 'causalGraph':
-            case 'causalRecall':
-            case 'learningSystem':
-            case 'explainableRecall':
-            case 'nightlyLearner':
-            case 'graphTransformer':
-            case 'graphAdapter':
-            case 'gnnService':
-            case 'memoryConsolidation':
-            case 'batchOperations':
-            case 'contextSynthesizer':
-            case 'rvfOptimizer':
-            case 'mmrDiversityRanker':
-                return this.agentdb !== null;
-            // SemanticRouter — auto-enable if agentdb available (exported since alpha.10)
-            case 'semanticRouter':
-                return this.agentdb !== null;
-            // Optional controllers
-            case 'hybridSearch':
-            case 'agentMemoryScope':
-            case 'sonaTrajectory':
-            case 'federatedSession':
-                return false; // Require explicit enabling
-            default:
-                return false;
-        }
-    }
-    /**
-     * Initialize a single controller with error isolation.
-     */
-    async initController(name, level) {
-        const startTime = performance.now();
-        try {
-            const instance = await this.createController(name);
-            const initTimeMs = performance.now() - startTime;
-            this.controllers.set(name, {
-                name,
-                instance,
-                level,
-                initTimeMs,
-                enabled: instance !== null,
-                error: instance === null ? 'Controller returned null' : undefined,
-            });
-            if (instance !== null) {
-                this.emit('controller:initialized', { name, level, initTimeMs });
-            }
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            const initTimeMs = performance.now() - startTime;
-            this.controllers.set(name, {
-                name,
-                instance: null,
-                level,
-                initTimeMs,
-                enabled: false,
-                error: errorMsg,
-            });
-            throw error;
-        }
-    }
-    /**
-     * Factory method to create a controller instance.
-     * Handles CLI-layer controllers; AgentDB-internal controllers are
-     * accessed via agentdb.getController().
-     */
-    async createController(name) {
-        switch (name) {
-            // ----- CLI-layer controllers -----
-            case 'learningBridge': {
-                if (!this.backend)
-                    return null;
-                const config = this.config.memory?.learningBridge || {};
-                const bridge = new LearningBridge(this.backend, {
-                    sonaMode: config.sonaMode || this.config.neural?.sonaMode || 'balanced',
-                    confidenceDecayRate: config.confidenceDecayRate,
-                    accessBoostAmount: config.accessBoostAmount,
-                    consolidationThreshold: config.consolidationThreshold,
-                    enabled: true,
-                });
-                return bridge;
-            }
-            case 'memoryGraph': {
-                const config = this.config.memory?.memoryGraph || {};
-                const graph = new MemoryGraph({
-                    pageRankDamping: config.pageRankDamping,
-                    maxNodes: config.maxNodes,
-                    ...config,
-                });
-                // Build from backend if available
-                if (this.backend) {
-                    try {
-                        await graph.buildFromBackend(this.backend);
-                    }
-                    catch {
-                        // Graph build from backend failed — empty graph is still usable
-                    }
-                }
-                return graph;
-            }
-            case 'tieredCache': {
-                const config = this.config.memory?.tieredCache || {};
-                const cache = new TieredCacheManager({
-                    maxSize: config.maxSize || 10000,
-                    ttl: config.ttl || 300000,
-                    lruEnabled: true,
-                    writeThrough: false,
-                    ...config,
-                });
-                return cache;
-            }
-            case 'hybridSearch':
-                // BM25 hybrid search — placeholder for future implementation
-                return null;
-            case 'agentMemoryScope':
-                // Agent memory scope — placeholder, activated when explicitly enabled
-                return null;
-            case 'semanticRouter': {
-                // SemanticRouter exported from agentdb 3.0.0-alpha.10 (ADR-062)
-                // Constructor: () — requires initialize() after construction
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const SR = agentdbModule.SemanticRouter;
-                    if (!SR)
-                        return null;
-                    const router = new SR();
-                    await router.initialize();
-                    return router;
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'sonaTrajectory':
-                // Delegate to AgentDB's SonaTrajectoryService if available
-                if (this.agentdb && typeof this.agentdb.getController === 'function') {
-                    try {
-                        return this.agentdb.getController('sonaTrajectory');
-                    }
-                    catch {
-                        return null;
-                    }
-                }
-                return null;
-            case 'hierarchicalMemory': {
-                // HierarchicalMemory exported from agentdb 3.0.0-alpha.10 (ADR-066 Phase P2-3)
-                // Constructor: (db, embedder, vectorBackend?, graphBackend?, config?)
-                if (!this.agentdb)
-                    return this.createTieredMemoryStub();
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const HM = agentdbModule.HierarchicalMemory;
-                    if (!HM)
-                        return this.createTieredMemoryStub();
-                    const embedder = this.createEmbeddingService();
-                    const hm = new HM(this.agentdb.database, embedder);
-                    await hm.initializeDatabase();
-                    return hm;
-                }
-                catch {
-                    return this.createTieredMemoryStub();
-                }
-            }
-            case 'memoryConsolidation': {
-                // MemoryConsolidation exported from agentdb 3.0.0-alpha.10 (ADR-066 Phase P2-3)
-                // Constructor: (db, hierarchicalMemory, embedder, vectorBackend?, graphBackend?, config?)
-                if (!this.agentdb)
-                    return this.createConsolidationStub();
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const MC = agentdbModule.MemoryConsolidation;
-                    if (!MC)
-                        return this.createConsolidationStub();
-                    // Get the HierarchicalMemory instance (must be initialized at level 1 before us at level 3)
-                    const hm = this.get('hierarchicalMemory');
-                    if (!hm || typeof hm.recall !== 'function' || typeof hm.store !== 'function') {
-                        return this.createConsolidationStub();
-                    }
-                    const embedder = this.createEmbeddingService();
-                    const mc = new MC(this.agentdb.database, hm, embedder);
-                    await mc.initializeDatabase();
-                    return mc;
-                }
-                catch {
-                    return this.createConsolidationStub();
-                }
-            }
-            case 'federatedSession':
-                // Federated session — placeholder for Phase 4
-                return null;
-            // ----- AgentDB-internal controllers (via getController) -----
-            // AgentDB.getController() only supports: reflexion/memory, skills, causalGraph/causal
-            case 'reasoningBank': {
-                // ReasoningBank is exported directly, not via getController
-                if (!this.agentdb)
-                    return null;
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const RB = agentdbModule.ReasoningBank;
-                    if (!RB)
-                        return null;
-                    return new RB(this.agentdb.database);
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'skills':
-            case 'reflexion':
-            case 'causalGraph': {
-                if (!this.agentdb || typeof this.agentdb.getController !== 'function')
-                    return null;
-                try {
-                    return this.agentdb.getController(name) ?? null;
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'causalRecall': {
-                if (!this.agentdb)
-                    return null;
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const CR = agentdbModule.CausalRecall;
-                    if (!CR)
-                        return null;
-                    return new CR(this.agentdb.database);
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'learningSystem': {
-                if (!this.agentdb)
-                    return null;
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const LS = agentdbModule.LearningSystem;
-                    if (!LS)
-                        return null;
-                    return new LS(this.agentdb.database);
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'explainableRecall': {
-                if (!this.agentdb)
-                    return null;
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const ER = agentdbModule.ExplainableRecall;
-                    if (!ER)
-                        return null;
-                    return new ER(this.agentdb.database);
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'nightlyLearner': {
-                if (!this.agentdb)
-                    return null;
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const NL = agentdbModule.NightlyLearner;
-                    if (!NL)
-                        return null;
-                    return new NL(this.agentdb.database);
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'graphTransformer': {
-                if (!this.agentdb)
-                    return null;
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const GT = agentdbModule.CausalMemoryGraph;
-                    if (!GT)
-                        return null;
-                    return new GT(this.agentdb.database);
-                }
-                catch {
-                    return null;
-                }
-            }
-            // ----- Direct-instantiation controllers -----
-            case 'batchOperations': {
-                if (!this.agentdb)
-                    return null;
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const BO = agentdbModule.BatchOperations;
-                    if (!BO)
-                        return null;
-                    const embedder = this.config.embeddingGenerator || null;
-                    return new BO(this.agentdb.database, embedder);
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'contextSynthesizer': {
-                // ContextSynthesizer.synthesize is static — return the class itself
-                try {
-                    const agentdbModule = await import('agentdb');
-                    return agentdbModule.ContextSynthesizer ?? null;
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'mmrDiversityRanker': {
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const MMR = agentdbModule.MMRDiversityRanker;
-                    if (!MMR)
-                        return null;
-                    return new MMR();
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'mutationGuard': {
-                // MutationGuard exported from agentdb 3.0.0-alpha.10 (ADR-060)
-                // Constructor: (config?) where config.dimension, config.maxElements, config.enableWasmProofs
-                if (!this.agentdb)
-                    return null;
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const MG = agentdbModule.MutationGuard;
-                    if (!MG)
-                        return null;
-                    return new MG({ dimension: this.config.dimension || 384 });
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'attestationLog': {
-                // AttestationLog exported from agentdb 3.0.0-alpha.10 (ADR-060)
-                // Constructor: (db) — uses database for append-only audit log
-                if (!this.agentdb)
-                    return null;
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const AL = agentdbModule.AttestationLog;
-                    if (!AL)
-                        return null;
-                    return new AL(this.agentdb.database);
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'gnnService': {
-                // GNNService exported from agentdb 3.0.0-alpha.10 (ADR-062)
-                // Constructor: (config?) — requires initialize() after construction
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const GNN = agentdbModule.GNNService;
-                    if (!GNN)
-                        return null;
-                    const gnn = new GNN({ inputDim: this.config.dimension || 384 });
-                    await gnn.initialize();
-                    return gnn;
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'rvfOptimizer': {
-                // RVFOptimizer exported from agentdb 3.0.0-alpha.10 (ADR-062/065)
-                // Constructor: (config?) — no-arg for defaults
-                try {
-                    const agentdbModule = await import('agentdb');
-                    const RVF = agentdbModule.RVFOptimizer;
-                    if (!RVF)
-                        return null;
-                    return new RVF();
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'guardedVectorBackend': {
-                // GuardedVectorBackend exported from agentdb 3.0.0-alpha.10 (ADR-060)
-                // Constructor: (innerBackend, mutationGuard, attestationLog?)
-                // Requires vectorBackend and mutationGuard to be initialized first (level 2)
-                if (!this.agentdb)
-                    return null;
-                try {
-                    const vb = this.get('vectorBackend');
-                    const guard = this.get('mutationGuard');
-                    if (!vb || !guard)
-                        return null;
-                    const agentdbModule = await import('agentdb');
-                    const GVB = agentdbModule.GuardedVectorBackend;
-                    if (!GVB)
-                        return null;
-                    const log = this.get('attestationLog');
-                    return new GVB(vb, guard, log || undefined);
-                }
-                catch {
-                    return null;
-                }
-            }
-            case 'vectorBackend':
-            case 'graphAdapter': {
-                // These are accessed via AgentDB internal state, not direct construction
-                if (!this.agentdb)
-                    return null;
-                try {
-                    if (typeof this.agentdb.getController === 'function') {
-                        return this.agentdb.getController(name) ?? null;
-                    }
-                }
-                catch { /* fallthrough */ }
-                return null;
-            }
-            default:
-                return null;
-        }
-    }
-    /**
-     * Shutdown a single controller gracefully.
-     */
-    async shutdownController(name) {
-        const entry = this.controllers.get(name);
-        if (!entry?.instance)
-            return;
-        try {
-            const instance = entry.instance;
-            // Try known shutdown methods (always await for safety)
-            if (typeof instance.destroy === 'function') {
-                await instance.destroy();
-            }
-            else if (typeof instance.shutdown === 'function') {
-                await instance.shutdown();
-            }
-            else if (typeof instance.close === 'function') {
-                await instance.close();
-            }
-        }
-        catch {
-            // Best-effort cleanup
-        }
-        entry.enabled = false;
-        entry.instance = null;
-    }
-    /**
-     * Create an EmbeddingService for controllers that need it.
-     * Uses the config's embedding generator or creates a minimal local service.
-     */
-    createEmbeddingService() {
-        // If user provided an embedding generator, wrap it
-        if (this.config.embeddingGenerator) {
-            return {
-                embed: async (text) => this.config.embeddingGenerator(text),
-                embedBatch: async (texts) => Promise.all(texts.map(t => this.config.embeddingGenerator(t))),
-                initialize: async () => { },
-            };
-        }
-        // Return a minimal stub — HierarchicalMemory falls back to manualSearch without embeddings
-        return {
-            embed: async () => new Float32Array(this.config.dimension || 384),
-            embedBatch: async (texts) => texts.map(() => new Float32Array(this.config.dimension || 384)),
-            initialize: async () => { },
-        };
-    }
-    /**
-     * Lightweight in-memory tiered store (fallback when HierarchicalMemory
-     * cannot be initialized from agentdb).
-     * Enforces per-tier size limits to prevent unbounded memory growth.
-     */
-    createTieredMemoryStub() {
-        const MAX_PER_TIER = 5000;
-        const tiers = {
-            working: new Map(),
-            episodic: new Map(),
-            semantic: new Map(),
-        };
-        return {
-            store(key, value, tier = 'working') {
-                const t = tiers[tier] || tiers.working;
-                // Evict oldest if at capacity
-                if (t.size >= MAX_PER_TIER) {
-                    const oldest = t.keys().next().value;
-                    if (oldest !== undefined)
-                        t.delete(oldest);
-                }
-                t.set(key, { value: value.substring(0, 100_000), ts: Date.now() });
-            },
-            recall(query, topK = 5) {
-                const safeTopK = Math.min(Math.max(1, topK), 100);
-                const q = query.toLowerCase().substring(0, 10_000);
-                const results = [];
-                for (const [tierName, map] of Object.entries(tiers)) {
-                    for (const [key, entry] of map) {
-                        if (key.toLowerCase().includes(q) || entry.value.toLowerCase().includes(q)) {
-                            results.push({ key, value: entry.value, tier: tierName, ts: entry.ts });
-                            if (results.length >= safeTopK * 3)
-                                break; // Early exit for large stores
-                        }
-                    }
-                }
-                return results.sort((a, b) => b.ts - a.ts).slice(0, safeTopK);
-            },
-            getTierStats() {
-                return Object.fromEntries(Object.entries(tiers).map(([name, map]) => [name, map.size]));
-            },
-        };
-    }
-    /**
-     * No-op consolidation stub (fallback when MemoryConsolidation
-     * cannot be initialized from agentdb).
-     */
-    createConsolidationStub() {
-        return {
-            consolidate() {
-                return { promoted: 0, pruned: 0, timestamp: Date.now() };
-            },
-        };
-    }
-}
-export default ControllerRegistry;
-//# sourceMappingURL=controller-registry.js.map