@framers/agentos 0.1.126 → 0.1.128

package/dist/api/AgentOS.js

@@ -40,37 +40,30 @@
  */
 import { AGENTOS_PENDING_EXTERNAL_TOOL_REQUEST_METADATA_KEY } from './types/AgentOSExternalToolRequest.js';
 import { AgentOSResponseChunkType, isActionableToolCallRequestChunk, } from './types/AgentOSResponse.js';
-import { AgentOSOrchestrator, } from './AgentOSOrchestrator.js';
+import { AgentOSOrchestrator, } from './runtime/AgentOSOrchestrator.js';
 import { GMIManager } from '../cognitive_substrate/GMIManager.js';
 import { AIModelProviderManager, } from '../core/llm/providers/AIModelProviderManager.js';
 import { PromptEngine } from '../core/llm/PromptEngine.js';
 import { ToolOrchestrator } from '../core/tools/ToolOrchestrator.js';
 import { ToolExecutor } from '../core/tools/ToolExecutor.js';
 import { ToolPermissionManager } from '../core/tools/permissions/ToolPermissionManager.js';
-import { LLMUtilityAI } from '../core/ai_utilities/LLMUtilityAI.js';
+import { LLMUtilityAI } from '../nlp/ai_utilities/LLMUtilityAI.js';
 import { ConversationManager, } from '../core/conversation/ConversationManager.js';
 import { StreamingManager, } from '../core/streaming/StreamingManager.js';
-import { GMIError, GMIErrorCode } from '../utils/errors.js';
-import { uuidv4 } from '../utils/uuid.js';
+import { GMIError, GMIErrorCode } from '../core/utils/errors.js';
+import { uuidv4 } from '../core/utils/uuid.js';
 import { createLogger } from '../logging/loggerFactory.js';
-import { configureAgentOSObservability, } from '../core/observability/otel.js';
-import { PersonalityMutationStore } from '../emergent/PersonalityMutationStore.js';
-import { GuardrailAction } from '../core/guardrails/IGuardrailService.js';
-import { evaluateInputGuardrails, createGuardrailBlockedStream, wrapOutputGuardrails, } from '../core/guardrails/guardrailDispatcher.js';
-import { ExtensionManager, EXTENSION_KIND_GUARDRAIL, EXTENSION_KIND_MESSAGING_CHANNEL, EXTENSION_KIND_PROVENANCE, EXTENSION_KIND_TOOL, EXTENSION_KIND_WORKFLOW, } from '../extensions/index.js';
-import { createMemoryToolsPack } from '../memory/extension/MemoryToolsExtension.js';
-import { createStandaloneMemoryLongTermRetriever, createStandaloneMemoryRollingSummarySink, } from '../memory/integration/StandaloneMemoryBridge.js';
-import { listExternalToolDefinitionsForLLM, normalizeExternalToolRegistry, } from './externalToolRegistry.js';
-import { adaptTools, adaptToolsToMap } from './toolAdapter.js';
+import { configureAgentOSObservability, } from '../evaluation/observability/otel.js';
+import { GuardrailAction } from '../safety/guardrails/IGuardrailService.js';
+import { evaluateInputGuardrails, createGuardrailBlockedStream, wrapOutputGuardrails, } from '../safety/guardrails/guardrailDispatcher.js';
+import { ExtensionManager, EXTENSION_KIND_GUARDRAIL, EXTENSION_KIND_PROVENANCE, EXTENSION_KIND_TOOL, EXTENSION_KIND_WORKFLOW, } from '../extensions/index.js';
+import { listExternalToolDefinitionsForLLM, normalizeExternalToolRegistry, } from './runtime/externalToolRegistry.js';
+import { adaptTools, adaptToolsToMap } from './runtime/toolAdapter.js';
 import { createSchemaOnDemandPack } from '../extensions/packs/schema-on-demand-pack.js';
-import { WorkflowRuntime } from '../core/workflows/runtime/WorkflowRuntime.js';
-import { AgencyRegistry } from '../core/agency/AgencyRegistry.js';
-import { AgentOSTurnPlanner, } from '../core/orchestration/TurnPlanner.js';
-import { CapabilityDiscoveryEngine, createDiscoverCapabilitiesTool } from '../discovery/index.js';
-import { EmbeddingManager } from '../rag/EmbeddingManager.js';
-import { InMemoryVectorStore } from '../rag/implementations/vector_stores/InMemoryVectorStore.js';
-import { WorkflowEngine } from '../core/workflows/WorkflowEngine.js';
-import { InMemoryWorkflowStore } from '../core/workflows/storage/InMemoryWorkflowStore.js';
+import { WorkflowFacade } from './runtime/WorkflowFacade.js';
+import { CapabilityDiscoveryInitializer } from './runtime/CapabilityDiscoveryInitializer.js';
+import { SelfImprovementSessionManager } from './runtime/SelfImprovementSessionManager.js';
+import { RagMemoryInitializer } from './runtime/RagMemoryInitializer.js';
 function wrapStorageAdapterWithWriteHooks(adapter, hooks, options) {
     const inTransaction = options?.inTransaction === true;
     const runWithHooks = async (statement, parameters) => {
@@ -157,11 +150,6 @@ function wrapStorageAdapterWithWriteHooks(adapter, hooks, options) {
 // Re-export from extracted module
 import { AgentOSServiceError } from './errors.js';
 export { AgentOSServiceError } from './errors.js';
-const DISCOVERY_EMBEDDING_DEFAULTS = {
-    openai: { modelId: 'text-embedding-3-small', dimension: 1536 },
-    openrouter: { modelId: 'openai/text-embedding-3-small', dimension: 1536 },
-    ollama: { modelId: 'nomic-embed-text', dimension: 768 },
-};
 /**
  * @class AgentOS
  * @implements {IAgentOS}
@@ -180,8 +168,6 @@ export class AgentOS {
     constructor(logger = createLogger('AgentOS')) {
         this.logger = logger;
         this.initialized = false;
-        this.managedStandaloneMemoryClosers = [];
-        this.manageRetrievalAugmentorLifecycle = false;
     }
     /**
      * Initializes the `AgentOS` service and all its core dependencies.
@@ -202,7 +188,7 @@ export class AgentOS {
             return;
         }
         this.validateConfiguration(config);
-        const resolvedConfig = this.resolveStandaloneMemoryConfig(config);
+        const resolvedConfig = RagMemoryInitializer.resolveConfig(config);
         const normalizedConfigTools = adaptToolsToMap(resolvedConfig.tools);
         const normalizedExternalTools = normalizeExternalToolRegistry(resolvedConfig.externalTools);
         const { externalTools: _externalTools, tools: _tools, ...resolvedConfigWithoutNormalizedTools } = resolvedConfig;
@@ -212,14 +198,31 @@ export class AgentOS {
             ...(Object.keys(normalizedConfigTools).length > 0 ? { tools: normalizedConfigTools } : {}),
             ...(normalizedExternalTools ? { externalTools: normalizedExternalTools } : {}),
         });
-        this.configureManagedStandaloneMemory();
+        // Initialize self-improvement session manager early (before emergent deps are assembled).
+        this.selfImprovementManager = new SelfImprovementSessionManager(this.logger);
+        this.selfImprovementManager.setConfiguredSkillsGetter(() => {
+            try {
+                const turnPlanningSkills = this.config.turnPlanning?.discovery?.sources?.skills;
+                if (Array.isArray(turnPlanningSkills)) {
+                    return turnPlanningSkills;
+                }
+                const legacySkills = this.config.capabilityDiscovery?.sources?.skills;
+                if (Array.isArray(legacySkills)) {
+                    return legacySkills;
+                }
+            }
+            catch {
+                // Fall through to empty set.
+            }
+            return [];
+        });
         // Observability is opt-in (config + env). Safe no-op if OTEL is not installed by host.
         configureAgentOSObservability(this.config.observability);
         // Initialize LanguageService early if configured so downstream orchestration can use it.
         if (config.languageConfig) {
             try {
                 // Dynamic import may fail under certain bundler path resolutions; using explicit relative path.
-                const { LanguageService } = await import('../core/language/index.js');
+                const { LanguageService } = await import('../nlp/language/index.js');
                 this.languageService = new LanguageService(config.languageConfig);
                 await this.languageService.initialize();
                 this.logger.info('AgentOS LanguageService initialized');
@@ -261,7 +264,15 @@ export class AgentOS {
             await this.extensionManager.loadPackFromFactory(pack, 'schema-on-demand', undefined, extensionLifecycleContext);
             this.logger.info('[AgentOS] Schema-on-demand tools enabled');
         }
-        await this.registerConfigMemoryTools(extensionLifecycleContext);
+        // Create RagMemoryInitializer now that extensionManager is available.
+        // modelProviderManager is wired later (after AI model provider init).
+        this.ragMemoryInitializer = new RagMemoryInitializer({
+            extensionManager: this.extensionManager,
+            modelProviderManager: undefined,
+            logger: this.logger,
+        });
+        this.ragMemoryInitializer.configureManaged(this.config);
+        await this.ragMemoryInitializer.registerMemoryTools(this.config.memoryTools, extensionLifecycleContext);
         let storageAdapter = this.config.storageAdapter;
         if (storageAdapter) {
             try {
@@ -283,13 +294,26 @@ export class AgentOS {
             }
         }
         try {
-            await this.initializeWorkflowRuntime(extensionLifecycleContext);
+            this.workflowFacade = new WorkflowFacade({
+                extensionManager: this.extensionManager,
+                logger: this.logger,
+                workflowEngineConfig: this.config.workflowEngineConfig,
+                workflowStore: this.config.workflowStore,
+            });
+            await this.workflowFacade.initialize(extensionLifecycleContext);
             // Initialize AI Model Provider Manager
             this.modelProviderManager = new AIModelProviderManager();
             await this.modelProviderManager.initialize(this.config.modelProviderManagerConfig);
             console.log('AgentOS: AIModelProviderManager initialized.');
             await this.ensureUtilityAIService();
-            await this.initializeRagSubsystem(storageAdapter);
+            // Re-create RagMemoryInitializer with model provider now available.
+            this.ragMemoryInitializer = new RagMemoryInitializer({
+                extensionManager: this.extensionManager,
+                modelProviderManager: this.modelProviderManager,
+                logger: this.logger,
+            });
+            this.ragMemoryInitializer.configureManaged(this.config);
+            await this.ragMemoryInitializer.initializeRag(this.config, storageAdapter);
             // Initialize Prompt Engine
             this.promptEngine = new PromptEngine();
             const peUtility = this.utilityAIService;
@@ -330,146 +354,11 @@ export class AgentOS {
                             exec: async (sql) => storageAdapter.exec(sql),
                         }
                         : undefined,
-                    // ---------------------------------------------------------------
-                    // Self-improvement deps — only assembled when the feature is
-                    // enabled. All hooks are lazy closures that resolve against the
-                    // fully initialised runtime at tool-call time (NOT at bootstrap).
-                    // ---------------------------------------------------------------
                     selfImprovementDeps: this.config.emergentConfig?.selfImprovement?.enabled
-                        ? (() => {
-                            // PersonalityMutationStore reuses the same storage adapter
-                            // that the EmergentToolRegistry already depends on.
-                            const mutationStore = storageAdapter
-                                ? new PersonalityMutationStore({
-                                    run: async (sql, params) => storageAdapter.run(sql, params),
-                                    get: async (sql, params) => storageAdapter.get(sql, params),
-                                    all: async (sql, params) => storageAdapter.all(sql, params),
-                                    exec: async (sql) => storageAdapter.exec(sql),
-                                })
-                                : undefined;
-                            return {
-                                // --- Personality (HEXACO) ---
-                                // Reads/writes the active GMI's persona personalityTraits map.
-                                // Falls back to an empty map when no GMI or persona is active.
-                                getPersonality: () => {
-                                    try {
-                                        const gmi = this.gmiManager?.activeGMIs?.values().next().value;
-                                        const traits = gmi?.getPersona()?.personalityTraits;
-                                        if (traits && typeof traits === 'object') {
-                                            const result = {};
-                                            for (const [k, v] of Object.entries(traits)) {
-                                                if (typeof v === 'number')
-                                                    result[k] = v;
-                                            }
-                                            return result;
-                                        }
-                                    }
-                                    catch { /* GMI not ready yet — return empty. */ }
-                                    return {};
-                                },
-                                setPersonality: (trait, value) => {
-                                    try {
-                                        const gmi = this.gmiManager?.activeGMIs?.values().next().value;
-                                        const persona = gmi?.getPersona();
-                                        if (persona) {
-                                            if (!persona.personalityTraits) {
-                                                persona.personalityTraits = {};
-                                            }
-                                            persona.personalityTraits[trait] = value;
-                                        }
-                                    }
-                                    catch { /* GMI not ready — ignore. */ }
-                                },
-                                mutationStore,
-                                // --- Skills ---
-                                // The SkillRegistry is not directly held by AgentOS, so
-                                // these hooks use the config.capabilityDiscovery.sources
-                                // skill data when available, falling back to empty arrays.
-                                getActiveSkills: () => {
-                                    try {
-                                        const skills = this.config.capabilityDiscovery?.sources?.skills;
-                                        if (Array.isArray(skills)) {
-                                            return skills.map((s) => ({
-                                                skillId: s.id ?? s.name ?? 'unknown',
-                                                name: s.name ?? 'unknown',
-                                                category: s.category ?? 'general',
-                                            }));
-                                        }
-                                    }
-                                    catch { /* no skills available */ }
-                                    return [];
-                                },
-                                getLockedSkills: () => [],
-                                loadSkill: async (id) => {
-                                    // Skill loading is a no-op stub. The ManageSkillsTool
-                                    // internally handles the result; returning metadata is
-                                    // sufficient for the tool to function.
-                                    return { skillId: id, name: id, category: 'dynamic' };
-                                },
-                                unloadSkill: (_id) => { },
-                                searchSkills: (query) => {
-                                    try {
-                                        const skills = this.config.capabilityDiscovery?.sources?.skills;
-                                        if (Array.isArray(skills)) {
-                                            const q = query.toLowerCase();
-                                            return skills
-                                                .filter((s) => (s.name ?? '').toLowerCase().includes(q) ||
-                                                (s.description ?? '').toLowerCase().includes(q))
-                                                .map((s) => ({
-                                                skillId: s.id ?? s.name ?? 'unknown',
-                                                name: s.name ?? 'unknown',
-                                                category: s.category ?? 'general',
-                                                description: s.description ?? '',
-                                            }));
-                                        }
-                                    }
-                                    catch { /* no skills available */ }
-                                    return [];
-                                },
-                                // --- Tools ---
-                                // Wire directly to the ToolOrchestrator. At tool-call
-                                // time the orchestrator is guaranteed to be initialised.
-                                executeTool: async (name, args) => {
-                                    const tool = await this.toolOrchestrator.getTool(name);
-                                    if (!tool) {
-                                        throw new Error(`Tool "${name}" not found in orchestrator.`);
-                                    }
-                                    const result = await tool.execute((args ?? {}), {
-                                        gmiId: 'self-improvement',
-                                        personaId: 'self-improvement',
-                                        userContext: { userId: 'system' },
-                                    });
-                                    return result;
-                                },
-                                listTools: () => {
-                                    try {
-                                        return this.toolOrchestrator.toolExecutor
-                                            ?.listAvailableTools()
-                                            ?.map((t) => t.name) ?? [];
-                                    }
-                                    catch {
-                                        return [];
-                                    }
-                                },
-                                // --- Memory ---
-                                // Persist self-improvement traces into the first active
-                                // GMI's cognitive memory when available.
-                                storeMemory: async (trace) => {
-                                    try {
-                                        const gmi = this.gmiManager?.activeGMIs?.values().next().value;
-                                        const mem = gmi?.getCognitiveMemoryManager?.();
-                                        if (mem) {
-                                            await mem.encode(`[self-improvement:${trace.type}] ${trace.content}`, { valence: 0, arousal: 0, dominance: 0.5 }, 'neutral', {
-                                                type: 'semantic',
-                                                scope: (trace.scope ?? 'agent'),
-                                                tags: trace.tags,
-                                            });
-                                        }
-                                    }
-                                    catch { /* Memory not available — silently skip. */ }
-                                },
-                            };
-                        })()
+                        ? this.selfImprovementManager.buildToolDeps(storageAdapter, {
+                            getActiveGMI: () => this.gmiManager?.activeGMIs?.values().next().value,
+                            getToolOrchestrator: () => this.toolOrchestrator,
+                        })
                         : undefined,
                 }
                 : undefined;
@@ -482,11 +371,20 @@ export class AgentOS {
                     toolNames: initialConfigTools.map((tool) => tool.name),
                 });
             }
-            await this.initializeTurnPlanner();
-            if (this.capabilityDiscoveryEngine && this.toolOrchestrator.setEmergentDiscoveryIndexer) {
+            this.discoveryInitializer = new CapabilityDiscoveryInitializer({
+                toolOrchestrator: this.toolOrchestrator,
+                extensionManager: this.extensionManager,
+                modelProviderManager: this.modelProviderManager,
+                modelProviderManagerConfig: this.config.modelProviderManagerConfig,
+                turnPlanningConfig: this.config.turnPlanning,
+                configTools: this.config.tools,
+                logger: this.logger,
+            });
+            await this.discoveryInitializer.initialize();
+            if (this.discoveryInitializer.discoveryEngine && this.toolOrchestrator.setEmergentDiscoveryIndexer) {
                 this.toolOrchestrator.setEmergentDiscoveryIndexer(async (tools) => {
-                    if (this.capabilityDiscoveryEngine?.indexEmergentTools) {
-                        await this.capabilityDiscoveryEngine.indexEmergentTools(tools);
+                    if (this.discoveryInitializer?.discoveryEngine?.indexEmergentTools) {
+                        await this.discoveryInitializer.discoveryEngine.indexEmergentTools(tools);
                     }
                 });
             }
@@ -503,10 +401,17 @@ export class AgentOS {
             // Initialize GMI Manager
             this.gmiManager = new GMIManager(this.config.gmiManagerConfig, this.subscriptionService, this.authService, this.conversationManager, // Removed Prisma parameter
             this.promptEngine, this.modelProviderManager, this.utilityAIService, // Pass the potentially dual-role utility service
-            this.toolOrchestrator, this.retrievalAugmentor, this.config.personaLoader);
+            this.toolOrchestrator, this.ragMemoryInitializer.retrievalAugmentor, this.config.personaLoader);
             await this.gmiManager.initialize();
             console.log('AgentOS: GMIManager initialized.');
-            await this.startWorkflowRuntime();
+            if (this.workflowFacade) {
+                this.workflowFacade.setRuntimeDependencies({
+                    gmiManager: this.gmiManager,
+                    streamingManager: this.streamingManager,
+                    toolOrchestrator: this.toolOrchestrator,
+                });
+                await this.workflowFacade.startRuntime();
+            }
             // Initialize AgentOS Orchestrator
             const orchestratorDependencies = {
                 gmiManager: this.gmiManager,
@@ -514,7 +419,7 @@ export class AgentOS {
                 conversationManager: this.conversationManager,
                 streamingManager: this.streamingManager,
                 modelProviderManager: this.modelProviderManager,
-                turnPlanner: this.turnPlanner,
+                turnPlanner: this.discoveryInitializer?.turnPlanner,
                 rollingSummaryMemorySink: this.config.rollingSummaryMemorySink,
                 longTermMemoryRetriever: this.config.longTermMemoryRetriever,
                 taskOutcomeTelemetryStore: this.config.taskOutcomeTelemetryStore,
@@ -522,6 +427,15 @@ export class AgentOS {
             this.agentOSOrchestrator = new AgentOSOrchestrator();
             await this.agentOSOrchestrator.initialize(this.config.orchestratorConfig, orchestratorDependencies);
             this.logger.info('AgentOS orchestrator initialized');
+            // Wire the orchestrator into the workflow facade for progress broadcasts.
+            if (this.workflowFacade) {
+                this.workflowFacade.setRuntimeDependencies({
+                    gmiManager: this.gmiManager,
+                    streamingManager: this.streamingManager,
+                    toolOrchestrator: this.toolOrchestrator,
+                    orchestrator: this.agentOSOrchestrator,
+                });
+            }
         }
         catch (error) {
             this.logger.error('AgentOS initialization failed', { error });
@@ -633,366 +547,6 @@ export class AgentOS {
             metadata: { origin: 'config' },
         }, context);
     }
-    resolveStandaloneMemoryConfig(config) {
-        const standalone = config.standaloneMemory;
-        if (!standalone || standalone.enabled === false) {
-            return { ...config };
-        }
-        const resolved = { ...config };
-        const memory = standalone.memory;
-        if (!resolved.memoryTools && standalone.tools) {
-            resolved.memoryTools = {
-                memory: memory,
-                ...(standalone.tools === true ? {} : standalone.tools),
-            };
-        }
-        if (!resolved.longTermMemoryRetriever && standalone.longTermRetriever) {
-            resolved.longTermMemoryRetriever = createStandaloneMemoryLongTermRetriever(memory, standalone.longTermRetriever === true ? undefined : standalone.longTermRetriever);
-        }
-        if (!resolved.rollingSummaryMemorySink && standalone.rollingSummarySink) {
-            resolved.rollingSummaryMemorySink = createStandaloneMemoryRollingSummarySink(memory, standalone.rollingSummarySink === true ? undefined : standalone.rollingSummarySink);
-        }
-        return resolved;
-    }
-    configureManagedStandaloneMemory() {
-        this.managedStandaloneMemoryClosers = [];
-        const standalone = this.config.standaloneMemory;
-        if (!standalone || standalone.enabled === false || standalone.manageLifecycle !== true) {
-            return;
-        }
-        if (this.config.memoryTools?.manageLifecycle === true) {
-            return;
-        }
-        if (typeof standalone.memory.close !== 'function') {
-            return;
-        }
-        this.managedStandaloneMemoryClosers.push(async () => {
-            await standalone.memory.close?.();
-        });
-    }
-    async registerConfigMemoryTools(context) {
-        if (!this.config.memoryTools || this.config.memoryTools.enabled === false) {
-            return;
-        }
-        const { memory, enabled: _enabled, identifier, manageLifecycle, ...packOptions } = this.config.memoryTools;
-        const pack = createMemoryToolsPack(memory, packOptions);
-        const packIdentifier = identifier ?? 'config-memory-tools';
-        if (manageLifecycle) {
-            const existingOnDeactivate = pack.onDeactivate;
-            pack.onDeactivate = async (lifecycleContext) => {
-                await existingOnDeactivate?.(lifecycleContext);
-                await memory.close?.();
-            };
-        }
-        await this.extensionManager.loadPackFromFactory(pack, packIdentifier, undefined, context);
-        this.logger.info('[AgentOS] Config memory tools enabled', {
-            identifier: packIdentifier,
-            packName: pack.name,
-            toolCount: pack.descriptors.length,
-        });
-    }
-    async initializeWorkflowRuntime(_context) {
-        this.workflowStore = this.config.workflowStore ?? new InMemoryWorkflowStore();
-        this.workflowEngine = new WorkflowEngine();
-        const workflowLogger = this.logger.child?.({ component: 'WorkflowEngine' }) ?? this.logger;
-        await this.workflowEngine.initialize(this.config.workflowEngineConfig ?? {}, {
-            store: this.workflowStore,
-            logger: workflowLogger,
-        });
-        const agencyLogger = this.logger.child?.({ component: 'AgencyRegistry' }) ?? this.logger;
-        this.agencyRegistry = new AgencyRegistry(agencyLogger);
-        await this.registerWorkflowDescriptorsFromRegistry();
-        this.workflowExtensionListener = async (event) => {
-            if (!this.workflowEngine) {
-                return;
-            }
-            if (event.type === 'descriptor:activated' && event.kind === EXTENSION_KIND_WORKFLOW) {
-                const descriptor = event.descriptor;
-                await this.handleWorkflowDescriptorActivated({
-                    id: descriptor.id,
-                    payload: descriptor.payload,
-                });
-            }
-            else if (event.type === 'descriptor:deactivated' &&
-                event.kind === EXTENSION_KIND_WORKFLOW) {
-                const descriptor = event.descriptor;
-                await this.handleWorkflowDescriptorDeactivated({
-                    id: descriptor.id,
-                    payload: descriptor.payload,
-                });
-            }
-        };
-        this.extensionManager.on(this.workflowExtensionListener);
-        this.workflowEngineListener = async (event) => {
-            await this.handleWorkflowEngineEvent(event);
-        };
-        this.workflowEngine.onEvent(this.workflowEngineListener);
-    }
-    async startWorkflowRuntime() {
-        if (!this.workflowEngine) {
-            return;
-        }
-        if (this.workflowRuntime) {
-            return;
-        }
-        if (!this.gmiManager || !this.streamingManager || !this.toolOrchestrator) {
-            this.logger.warn('Workflow runtime start skipped because core dependencies are not ready.');
-            return;
-        }
-        if (!this.agencyRegistry) {
-            const agencyLogger = this.logger.child?.({ component: 'AgencyRegistry' }) ?? this.logger;
-            this.agencyRegistry = new AgencyRegistry(agencyLogger);
-        }
-        const runtimeLogger = this.logger.child?.({ component: 'WorkflowRuntime' }) ?? this.logger;
-        this.workflowRuntime = new WorkflowRuntime({
-            workflowEngine: this.workflowEngine,
-            gmiManager: this.gmiManager,
-            streamingManager: this.streamingManager,
-            toolOrchestrator: this.toolOrchestrator,
-            extensionManager: this.extensionManager,
-            agencyRegistry: this.agencyRegistry,
-            logger: runtimeLogger,
-        });
-        await this.workflowRuntime.start();
-    }
-    async registerWorkflowDescriptorsFromRegistry() {
-        const registry = this.extensionManager.getRegistry(EXTENSION_KIND_WORKFLOW);
-        const activeDescriptors = registry.listActive();
-        for (const descriptor of activeDescriptors) {
-            await this.handleWorkflowDescriptorActivated({
-                id: descriptor.id,
-                payload: descriptor.payload,
-            });
-        }
-    }
-    async handleWorkflowDescriptorActivated(descriptor) {
-        try {
-            await this.workflowEngine.registerWorkflowDescriptor(descriptor.payload);
-            this.logger.debug?.('Workflow descriptor registered', {
-                descriptorId: descriptor.id,
-                workflowDefinitionId: descriptor.payload.definition.id,
-            });
-        }
-        catch (error) {
-            this.logger.error('Failed to register workflow descriptor', {
-                descriptorId: descriptor.id,
-                workflowDefinitionId: descriptor.payload.definition.id,
-                error,
-            });
-        }
-    }
-    async handleWorkflowDescriptorDeactivated(descriptor) {
-        try {
-            await this.workflowEngine.unregisterWorkflowDescriptor(descriptor.payload.definition.id);
-            this.logger.debug?.('Workflow descriptor unregistered', {
-                descriptorId: descriptor.id,
-                workflowDefinitionId: descriptor.payload.definition.id,
-            });
-        }
-        catch (error) {
-            this.logger.error('Failed to unregister workflow descriptor', {
-                descriptorId: descriptor.id,
-                workflowDefinitionId: descriptor.payload.definition.id,
-                error,
-            });
-        }
-    }
-    async handleWorkflowEngineEvent(event) {
-        try {
-            await this.emitWorkflowUpdate(event.workflowId);
-        }
-        catch (error) {
-            this.logger.error('Failed to handle workflow engine event', {
-                workflowId: event.workflowId,
-                eventType: event.type,
-                error,
-            });
-        }
-    }
-    async emitWorkflowUpdate(workflowId) {
-        if (!this.workflowEngine) {
-            return;
-        }
-        try {
-            const update = await this.workflowEngine.getWorkflowProgress(workflowId);
-            if (!update) {
-                return;
-            }
-            this.logger.debug?.('Workflow progress update ready', {
-                workflowId,
-                status: update.workflow.status,
-            });
-            if (typeof this.agentOSOrchestrator?.broadcastWorkflowUpdate === 'function') {
-                await this.agentOSOrchestrator.broadcastWorkflowUpdate(update);
-            }
-            else {
-                this.logger.warn('Workflow update could not be broadcast - orchestrator unavailable', {
-                    workflowId,
-                });
-            }
-        }
-        catch (error) {
-            this.logger.error('Failed to generate workflow progress update', { workflowId, error });
-        }
-    }
-    async initializeTurnPlanner() {
-        const turnPlanningConfig = this.config.turnPlanning;
-        if (turnPlanningConfig?.enabled === false) {
-            this.turnPlanner = undefined;
-            this.capabilityDiscoveryEngine = undefined;
-            return;
-        }
-        let discoveryEngine = turnPlanningConfig?.discovery?.engine;
-        if (!discoveryEngine && turnPlanningConfig?.discovery?.enabled !== false) {
-            try {
-                discoveryEngine = await this.initializeCapabilityDiscoveryEngine(turnPlanningConfig ?? {});
-            }
-            catch (error) {
-                this.logger.warn('Capability discovery initialization failed; planner will continue without discovery', {
-                    error: error?.message ?? error,
-                });
-            }
-        }
-        this.turnPlanner = new AgentOSTurnPlanner(turnPlanningConfig, discoveryEngine, this.logger.child?.({ component: 'TurnPlanner' }) ?? this.logger);
-        this.capabilityDiscoveryEngine = discoveryEngine;
-        this.logger.info('AgentOS turn planner initialized', {
-            discoveryEnabled: Boolean(discoveryEngine?.isInitialized?.()),
-            defaultToolFailureMode: turnPlanningConfig?.defaultToolFailureMode ?? 'fail_open',
-            defaultToolSelectionMode: turnPlanningConfig?.discovery?.defaultToolSelectionMode ?? 'discovered',
-        });
-    }
-    async initializeCapabilityDiscoveryEngine(turnPlanningConfig) {
-        const discoveryConfig = turnPlanningConfig.discovery;
-        if (discoveryConfig?.enabled === false) {
-            return undefined;
-        }
-        if (discoveryConfig?.autoInitializeEngine === false) {
-            return undefined;
-        }
-        const defaultProvider = this.modelProviderManager.getDefaultProvider() ??
-            this.modelProviderManager.getProvider(this.config.modelProviderManagerConfig.providers.find((p) => p.enabled)?.providerId || '');
-        const providerId = defaultProvider?.providerId;
-        if (!providerId) {
-            this.logger.warn('Capability discovery disabled: no model provider available');
-            return undefined;
-        }
-        const embeddingDefaults = DISCOVERY_EMBEDDING_DEFAULTS[providerId];
-        if (!embeddingDefaults) {
-            this.logger.warn('Capability discovery disabled: no embedding defaults for provider', {
-                providerId,
-            });
-            return undefined;
-        }
-        const embeddingModelId = discoveryConfig?.embeddingModelId ?? embeddingDefaults.modelId;
-        const embeddingDimension = discoveryConfig?.embeddingDimension ?? embeddingDefaults.dimension;
-        const embeddingManager = new EmbeddingManager();
-        await embeddingManager.initialize({
-            embeddingModels: [
-                {
-                    modelId: embeddingModelId,
-                    providerId,
-                    dimension: embeddingDimension,
-                    isDefault: true,
-                },
-            ],
-            defaultModelId: embeddingModelId,
-            enableCache: true,
-            cacheMaxSize: 500,
-            cacheTTLSeconds: 3600,
-        }, this.modelProviderManager);
-        const vectorStore = new InMemoryVectorStore();
-        await vectorStore.initialize({
-            id: 'agentos-capability-discovery',
-            type: 'in_memory',
-        });
-        const engine = new CapabilityDiscoveryEngine(embeddingManager, vectorStore, discoveryConfig?.config);
-        const sources = this.buildCapabilityIndexSources(discoveryConfig?.sources);
-        await engine.initialize(sources, discoveryConfig?.sources?.presetCoOccurrences);
-        if (discoveryConfig?.registerMetaTool !== false) {
-            const existing = await this.toolOrchestrator.getTool('discover_capabilities');
-            if (!existing) {
-                await this.toolOrchestrator.registerTool(createDiscoverCapabilitiesTool(engine));
-            }
-        }
-        this.discoveryEmbeddingManager = embeddingManager;
-        this.discoveryVectorStore = vectorStore;
-        this.logger.info('Capability discovery engine initialized', {
-            providerId,
-            embeddingModelId,
-            indexedCapabilities: engine.listCapabilityIds().length,
-        });
-        return engine;
-    }
-    buildCapabilityIndexSources(overrides) {
-        const titleCase = (value) => value
-            .replace(/[-_]+/g, ' ')
-            .replace(/\s+/g, ' ')
-            .trim()
-            .replace(/\b\w/g, (c) => c.toUpperCase());
-        const toolRegistry = this.extensionManager.getRegistry(EXTENSION_KIND_TOOL);
-        const runtimeTools = new Map();
-        for (const tool of toolRegistry
-            .listActive()
-            .map((descriptor) => descriptor.payload)
-            .filter(Boolean)) {
-            runtimeTools.set(tool.name, tool);
-        }
-        for (const tool of adaptTools(this.config.tools)) {
-            runtimeTools.set(tool.name, tool);
-        }
-        const tools = Array.from(runtimeTools.values()).map((tool) => ({
-            id: tool.id || `tool:${tool.name}`,
-            name: tool.name,
-            displayName: tool.displayName || titleCase(tool.name),
-            description: tool.description || '',
-            category: tool.category || 'general',
-            inputSchema: tool.inputSchema,
-            outputSchema: tool.outputSchema,
-            requiredCapabilities: tool.requiredCapabilities,
-            hasSideEffects: tool.hasSideEffects,
-        }));
-        const loadedPacks = this.extensionManager.listLoadedPacks();
-        const packExtensions = loadedPacks.map((pack) => ({
-            id: `extension:${pack.key}`,
-            name: pack.name,
-            displayName: titleCase(pack.name),
-            description: `Extension pack${pack.version ? ` v${pack.version}` : ''}`,
-            category: 'extensions',
-            available: true,
-        }));
-        const workflowRegistry = this.extensionManager.getRegistry(EXTENSION_KIND_WORKFLOW);
-        const workflowExtensions = workflowRegistry
-            .listActive()
-            .map((descriptor) => ({
-            id: `workflow:${descriptor.payload.definition.id}`,
-            name: descriptor.payload.definition.id,
-            displayName: descriptor.payload.definition.displayName || titleCase(descriptor.payload.definition.id),
-            description: descriptor.payload.definition.description || 'Workflow automation capability',
-            category: 'workflow',
-            requiredSecrets: descriptor.payload.definition.metadata?.requiredSecrets,
-            available: true,
-        }));
-        const messagingRegistry = this.extensionManager.getRegistry(EXTENSION_KIND_MESSAGING_CHANNEL);
-        const channels = messagingRegistry
-            .listActive()
-            .map((descriptor) => descriptor.payload)
-            .filter(Boolean)
-            .map((channel) => ({
-            platform: channel.platform,
-            displayName: channel.displayName || titleCase(channel.platform),
-            description: `${channel.displayName || titleCase(channel.platform)} messaging channel`,
-            capabilities: Array.isArray(channel.capabilities)
-                ? channel.capabilities.map((cap) => String(cap))
-                : [],
-        }));
-        return {
-            tools,
-            extensions: [...packExtensions, ...workflowExtensions, ...(overrides?.extensions ?? [])],
-            channels: [...channels, ...(overrides?.channels ?? [])],
-            skills: overrides?.skills,
-            manifests: overrides?.manifests,
-        };
-    }
     getActiveGuardrailServices() {
         const services = [];
         if (this.extensionManager) {
@@ -1100,8 +654,8 @@ export class AgentOS {
                 extensionManager: Boolean(this.extensionManager),
                 toolOrchestrator: Boolean(this.toolOrchestrator),
                 modelProviderManager: Boolean(this.modelProviderManager),
-                retrievalAugmentor: Boolean(this.retrievalAugmentor),
-                workflowEngine: Boolean(this.workflowEngine),
+                retrievalAugmentor: Boolean(this.ragMemoryInitializer?.retrievalAugmentor),
+                workflowEngine: Boolean(this.workflowFacade),
             },
             providers: {
                 configured: providerIds,
@@ -1210,10 +764,12 @@ export class AgentOS {
             }
             return;
         }
-        const orchestratorInput = {
+        const orchestratorInput = this.selfImprovementManager.applySessionOverrides({
             ...guardrailInputOutcome.sanitizedInput,
             selectedPersonaId: effectivePersonaId,
-        };
+            skillPromptContext: this.selfImprovementManager.buildSkillPromptContext(guardrailInputOutcome.sanitizedInput.sessionId),
+            disabledSessionSkillIds: this.selfImprovementManager.listDisabledSkillIds(this.selfImprovementManager.buildSessionRuntimeKey(guardrailInputOutcome.sanitizedInput.sessionId)),
+        });
         // Language negotiation (non-blocking)
         let languageNegotiation = null;
         if (this.languageService && this.config.languageConfig) {
@@ -1439,46 +995,31 @@ export class AgentOS {
     }
     listWorkflowDefinitions() {
         this.ensureInitialized();
-        return this.workflowEngine.listWorkflowDefinitions();
+        return this.workflowFacade.listWorkflowDefinitions();
     }
     async startWorkflow(definitionId, input, options = {}) {
         this.ensureInitialized();
-        const definition = this.workflowEngine
-            .listWorkflowDefinitions()
-            .find((item) => item.id === definitionId);
-        if (!definition) {
-            throw new AgentOSServiceError(`Workflow definition '${definitionId}' not found.`, GMIErrorCode.CONFIGURATION_ERROR, { definitionId });
-        }
-        return this.workflowEngine.startWorkflow({
-            input,
-            definition,
-            workflowId: options.workflowId,
-            conversationId: options.conversationId,
-            createdByUserId: options.createdByUserId,
-            context: options.context,
-            roleAssignments: options.roleAssignments,
-            metadata: options.metadata,
-        });
+        return this.workflowFacade.startWorkflow(definitionId, input, options);
     }
     async getWorkflow(workflowId) {
         this.ensureInitialized();
-        return this.workflowEngine.getWorkflow(workflowId);
+        return this.workflowFacade.getWorkflow(workflowId);
     }
     async listWorkflows(options) {
         this.ensureInitialized();
-        return this.workflowEngine.listWorkflows(options);
+        return this.workflowFacade.listWorkflows(options);
     }
     async getWorkflowProgress(workflowId, sinceTimestamp) {
         this.ensureInitialized();
-        return this.workflowEngine.getWorkflowProgress(workflowId, sinceTimestamp);
+        return this.workflowFacade.getWorkflowProgress(workflowId, sinceTimestamp);
     }
     async updateWorkflowStatus(workflowId, status) {
         this.ensureInitialized();
-        return this.workflowEngine.updateWorkflowStatus(workflowId, status);
+        return this.workflowFacade.updateWorkflowStatus(workflowId, status);
     }
     async applyWorkflowTaskUpdates(workflowId, updates) {
         this.ensureInitialized();
-        return this.workflowEngine.applyTaskUpdates(workflowId, updates);
+        return this.workflowFacade.applyWorkflowTaskUpdates(workflowId, updates);
     }
     /**
      * Lists all available personas that the requesting user (if specified) has access to.
@@ -1661,19 +1202,7 @@ export class AgentOS {
         // 3. Streaming Manager (closes active client connections)
         // 4. Other services (ConversationManager, ToolOrchestrator, PromptEngine, ModelProviderManager)
         try {
-            if (this.workflowEngineListener && this.workflowEngine) {
-                this.workflowEngine.offEvent(this.workflowEngineListener);
-                this.workflowEngineListener = undefined;
-            }
-            if (this.workflowExtensionListener && this.extensionManager) {
-                this.extensionManager.off(this.workflowExtensionListener);
-                this.workflowExtensionListener = undefined;
-            }
-            if (this.workflowRuntime) {
-                await this.workflowRuntime.stop();
-                this.workflowRuntime = undefined;
-            }
-            this.agencyRegistry = undefined;
+            await this.workflowFacade?.shutdown();
             if (this.agentOSOrchestrator?.shutdown) {
                 await this.agentOSOrchestrator.shutdown();
                 console.log('AgentOS: AgentOSOrchestrator shut down.');
@@ -1695,24 +1224,8 @@ export class AgentOS {
                 await this.toolOrchestrator.shutdown();
                 console.log('AgentOS: ToolOrchestrator shut down.');
             }
-            if (this.discoveryVectorStore?.shutdown) {
-                await this.discoveryVectorStore.shutdown();
-                this.discoveryVectorStore = undefined;
-            }
-            if (this.discoveryEmbeddingManager?.shutdown) {
-                await this.discoveryEmbeddingManager.shutdown();
-                this.discoveryEmbeddingManager = undefined;
-            }
-            this.turnPlanner = undefined;
-            if (this.manageRetrievalAugmentorLifecycle && this.retrievalAugmentor?.shutdown) {
-                await this.retrievalAugmentor.shutdown();
-                console.log('AgentOS: RetrievalAugmentor shut down.');
-            }
-            if (this.manageRetrievalAugmentorLifecycle &&
-                this.ragVectorStoreManager?.shutdownAllProviders) {
-                await this.ragVectorStoreManager.shutdownAllProviders();
-                console.log('AgentOS: VectorStore providers shut down.');
-            }
+            await this.discoveryInitializer?.shutdown();
+            await this.ragMemoryInitializer?.shutdown();
             // PromptEngine might have a cleanup method like clearCache
             if (this.promptEngine && typeof this.promptEngine.clearCache === 'function') {
                 await this.promptEngine.clearCache();
@@ -1726,10 +1239,7 @@ export class AgentOS {
                 await this.extensionManager.shutdown({ logger: this.logger });
                 console.log('AgentOS: ExtensionManager shut down.');
             }
-            for (const closeMemory of this.managedStandaloneMemoryClosers) {
-                await closeMemory();
-            }
-            this.managedStandaloneMemoryClosers = [];
+            // Standalone memory closers are handled by ragMemoryInitializer.shutdown() above.
             // Other services like authService, subscriptionService, prisma might not have explicit async shutdown methods
             // if they manage connections passively or are handled by process exit.
             console.log('AgentOS Service: Graceful shutdown completed successfully.');
@@ -1745,55 +1255,6 @@ export class AgentOS {
             this.initialized = false; // Mark as uninitialized regardless of shutdown errors.
         }
     }
-    async initializeRagSubsystem(storageAdapter) {
-        // Prefer caller-provided augmentor instance.
-        if (this.config.retrievalAugmentor) {
-            this.retrievalAugmentor = this.config.retrievalAugmentor;
-            this.manageRetrievalAugmentorLifecycle =
-                this.config.manageRetrievalAugmentorLifecycle === true;
-            return;
-        }
-        const ragConfig = this.config.ragConfig;
-        if (!ragConfig || ragConfig.enabled === false) {
-            return;
-        }
-        try {
-            const { EmbeddingManager } = await import('../rag/EmbeddingManager.js');
-            const { VectorStoreManager } = await import('../rag/VectorStoreManager.js');
-            const { RetrievalAugmentor } = await import('../rag/RetrievalAugmentor.js');
-            const embeddingManager = new EmbeddingManager();
-            await embeddingManager.initialize(ragConfig.embeddingManagerConfig, this.modelProviderManager);
-            const bindToStorageAdapter = ragConfig.bindToStorageAdapter === undefined
-                ? true
-                : ragConfig.bindToStorageAdapter === true;
-            const patchedVectorStoreConfig = {
-                ...ragConfig.vectorStoreManagerConfig,
-                providers: ragConfig.vectorStoreManagerConfig.providers.map((provider) => {
-                    if (bindToStorageAdapter &&
-                        storageAdapter &&
-                        provider?.type === 'sql' &&
-                        !provider.adapter &&
-                        !provider.storage) {
-                        return { ...provider, adapter: storageAdapter };
-                    }
-                    return provider;
-                }),
-            };
-            const vectorStoreManager = new VectorStoreManager();
-            await vectorStoreManager.initialize(patchedVectorStoreConfig, ragConfig.dataSourceConfigs);
-            const retrievalAugmentor = new RetrievalAugmentor();
-            await retrievalAugmentor.initialize(ragConfig.retrievalAugmentorConfig, embeddingManager, vectorStoreManager);
-            this.retrievalAugmentor = retrievalAugmentor;
-            this.ragVectorStoreManager = vectorStoreManager;
-            this.manageRetrievalAugmentorLifecycle = ragConfig.manageLifecycle !== false;
-            console.log('AgentOS: RAG subsystem initialized.');
-        }
-        catch (error) {
-            this.logger.error('AgentOS: Failed to initialize RAG subsystem; continuing without retrieval augmentor.', {
-                error: error?.message ?? error,
-            });
-        }
-    }
 }
 // Imported from extracted module
 import { AsyncStreamClientBridge } from '../core/streaming/AsyncStreamClientBridge.js';