@claude-flow/memory 3.0.0-alpha.10 → 3.0.0-alpha.12

package/dist/controller-registry.js

@@ -0,0 +1,893 @@
+/**
+ * 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 { 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 = require('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('better-sqlite3') ||
+                    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