@framers/agentos 0.1.125 → 0.1.127

package/dist/cognitive_substrate/GMI.js

@@ -9,16 +9,18 @@
  * @see ./IGMI.ts for the interface definition.
  * @see ./personas/IPersonaDefinition.ts for persona structure.
  * @see ../core/tools/IToolOrchestrator.ts for tool orchestration.
- * @see ../core/ai_utilities/IUtilityAI.ts for utility functions.
+ * @see ../nlp/ai_utilities/IUtilityAI.ts for utility functions.
  */
-import { uuidv4 } from '../utils/uuid.js';
+import { uuidv4 } from '../core/utils/uuid.js';
 import { GMIOutputChunkType, GMIPrimeState, GMIMood, ReasoningEntryType, GMIInteractionType,
 // AudioOutputConfig, ImageOutputConfig are part of GMIOutput
  } from './IGMI.js';
 import { RagMemoryCategory } from '../rag/IRetrievalAugmentor.js';
-import { createConversationMessage, MessageRole } from '../core/conversation/ConversationMessage.js';
-import { GMIError, GMIErrorCode, createGMIErrorFromError } from '../utils/errors.js';
-import { GMIEventType, createGMIEvent } from './GMIEvent.js';
+import { GMIError, GMIErrorCode, createGMIErrorFromError } from '../core/utils/errors.js';
+import { ConversationHistoryManager } from './ConversationHistoryManager.js';
+import { CognitiveMemoryBridge } from './CognitiveMemoryBridge.js';
+import { SentimentTracker } from './SentimentTracker.js';
+import { MetapromptExecutor } from './MetapromptExecutor.js';
 const DEFAULT_MAX_CONVERSATION_HISTORY_TURNS = 20;
 const DEFAULT_SELF_REFLECTION_INTERVAL_TURNS = 5;
 const MAX_REASONING_TRACE_ENTRIES = 500; // Limit trace size in memory
@@ -36,10 +38,9 @@ export class GMI {
      */
     constructor(gmiId) {
         this.isInitialized = false; // Maintained as per user-provided GMI.ts
-        // Sentiment & Event Tracking
-        this.pendingGMIEvents = new Set();
-        this.eventHistory = []; // Last 20 events for debugging
-        this.metaPromptTriggerCounters = new Map();
+        // (Self-reflection state is owned by MetapromptExecutor)
+        // Cognitive Memory Bridge
+        this.memoryBridge = null;
         this.gmiId = gmiId || `gmi-${uuidv4()}`;
         this.creationTimestamp = new Date();
         this.state = GMIPrimeState.IDLE;
@@ -47,9 +48,7 @@ export class GMI {
         this.currentUserContext = { userId: 'uninitialized-user', skillLevel: 'novice', preferences: {} };
         this.currentTaskContext = { taskId: `task-${uuidv4()}`, domain: 'general', complexity: 'low', status: 'not_started' };
         this.reasoningTrace = { gmiId: this.gmiId, personaId: '', entries: [] };
-        this.conversationHistory = [];
-        this.selfReflectionIntervalTurns = DEFAULT_SELF_REFLECTION_INTERVAL_TURNS;
-        this.turnsSinceLastReflection = 0;
+        this.conversationHistoryManager = new ConversationHistoryManager();
     }
     /**
      * @inheritdoc
@@ -59,7 +58,7 @@ export class GMI {
             console.warn(`GMI (ID: ${this.gmiId}) already initialized (state: ${this.state}). Re-initializing parts.`);
             // Selective re-initialization logic can be more granular if needed
             this.reasoningTrace = { gmiId: this.gmiId, personaId: '', entries: [] };
-            this.conversationHistory = [];
+            this.conversationHistoryManager.clear();
         }
         this.validateInitializationInputs(persona, config);
         this.activePersona = persona;
@@ -71,15 +70,66 @@ export class GMI {
         this.llmProviderManager = config.llmProviderManager;
         this.utilityAI = config.utilityAI;
         this.cognitiveMemory = config.cognitiveMemory;
+        // Initialize cognitive memory bridge if cognitive memory is provided
+        if (this.cognitiveMemory) {
+            this.memoryBridge = new CognitiveMemoryBridge(this.cognitiveMemory, () => this.currentGmiMood, () => this.currentUserContext, () => this.getCurrentPrimaryPersonaId(), () => this.gmiId, (type, message, details) => this.addTraceEntry(type, message, details));
+        }
+        else {
+            this.memoryBridge = null;
+        }
         this.reasoningTrace.personaId = this.activePersona.id;
         await this.workingMemory.initialize(this.gmiId, this.activePersona.customFields?.defaultWorkingMemoryConfig || {});
         this.addTraceEntry(ReasoningEntryType.LIFECYCLE, 'GMI Initializing with Persona and Config.', { personaId: persona.id });
         await this.loadStateFromMemoryAndPersona();
+        // Initialize sentiment tracker
+        this.sentimentTracker = new SentimentTracker(this.utilityAI, this.workingMemory, () => this.activePersona, () => this.conversationHistoryManager.history, () => this.reasoningTrace.entries, () => this.currentUserContext, async (ctx) => {
+            this.currentUserContext = ctx;
+            await this.workingMemory.set('currentUserContext', this.currentUserContext);
+        }, (type, message, details) => this.addTraceEntry(type, message, details), () => this.gmiId);
+        // Initialize metaprompt executor
+        this.metapromptExecutor = new MetapromptExecutor({
+            workingMemory: this.workingMemory,
+            llmProviderManager: this.llmProviderManager,
+            utilityAI: this.utilityAI,
+            getPersona: () => this.activePersona,
+            addTraceEntry: (type, message, details) => this.addTraceEntry(type, message, details),
+            getModelAndProvider: (preferredModel, preferredProvider) => this.getModelAndProviderForLLMCall(preferredModel, preferredProvider, this.activePersona.defaultModelId || this.config.defaultLlmModelId, this.activePersona.defaultProviderId || this.config.defaultLlmProviderId),
+            onMoodUpdate: (mood) => {
+                this.currentGmiMood = mood;
+                this.workingMemory.set('currentGmiMood', this.currentGmiMood);
+            },
+            onUserContextUpdate: (updates) => {
+                Object.assign(this.currentUserContext, updates);
+                this.workingMemory.set('currentUserContext', this.currentUserContext);
+            },
+            onTaskContextUpdate: (updates) => {
+                Object.assign(this.currentTaskContext, updates);
+                this.workingMemory.set('currentTaskContext', this.currentTaskContext);
+            },
+            onMemoryImprint: async (content, tags) => {
+                await this.memoryBridge?.encode(content, {
+                    type: 'semantic',
+                    sourceType: 'agent_inference',
+                    role: 'system',
+                    tags,
+                });
+            },
+            getPendingEvents: () => this.sentimentTracker.pendingEvents,
+            getEventHistory: () => this.sentimentTracker.events,
+            getConversationHistory: () => this.conversationHistoryManager.history,
+            getReasoningTraceEntries: () => this.reasoningTrace.entries,
+            getMood: () => this.currentGmiMood,
+            getUserContext: () => this.currentUserContext,
+            getTaskContext: () => this.currentTaskContext,
+            setState: (state) => { this.state = state; },
+            getState: () => this.state,
+            getGmiId: () => this.gmiId,
+        });
         const reflectionMetaPrompt = this.activePersona.metaPrompts?.find(mp => mp.id === 'gmi_self_trait_adjustment');
-        this.selfReflectionIntervalTurns = reflectionMetaPrompt?.trigger?.type === 'turn_interval' && typeof reflectionMetaPrompt.trigger.intervalTurns === 'number'
+        this.metapromptExecutor.selfReflectionIntervalTurns = reflectionMetaPrompt?.trigger?.type === 'turn_interval' && typeof reflectionMetaPrompt.trigger.intervalTurns === 'number'
             ? reflectionMetaPrompt.trigger.intervalTurns
             : DEFAULT_SELF_REFLECTION_INTERVAL_TURNS;
-        this.turnsSinceLastReflection = 0;
+        this.metapromptExecutor.turnsSinceLastReflection = 0;
         this.isInitialized = true; // Set after all essential initializations
         this.state = GMIPrimeState.READY;
         this.addTraceEntry(ReasoningEntryType.LIFECYCLE, 'GMI Initialization complete. State: READY.');
@@ -203,27 +253,6 @@ export class GMI {
         };
         this.reasoningTrace.entries.push(entry);
     }
-    getCurrentPadState() {
-        switch (this.currentGmiMood) {
-            case GMIMood.EMPATHETIC:
-                return { valence: 0.55, arousal: 0.15, dominance: 0.25 };
-            case GMIMood.CURIOUS:
-                return { valence: 0.35, arousal: 0.45, dominance: 0.15 };
-            case GMIMood.ASSERTIVE:
-                return { valence: 0.15, arousal: 0.35, dominance: 0.7 };
-            case GMIMood.ANALYTICAL:
-                return { valence: 0.1, arousal: -0.1, dominance: 0.45 };
-            case GMIMood.FOCUSED:
-                return { valence: 0.2, arousal: 0.1, dominance: 0.55 };
-            case GMIMood.FRUSTRATED:
-                return { valence: -0.65, arousal: 0.6, dominance: 0.2 };
-            case GMIMood.CREATIVE:
-                return { valence: 0.45, arousal: 0.35, dominance: 0.35 };
-            case GMIMood.NEUTRAL:
-            default:
-                return { valence: 0, arousal: 0, dominance: 0 };
-        }
-    }
     stringifyTurnContent(content) {
         if (typeof content === 'string') {
             const trimmed = content.trim();
@@ -237,77 +266,6 @@ export class GMI {
             return null;
         }
     }
-    buildMemoryTags(role) {
-        const tags = [
-            role,
-            this.activePersona?.id,
-            this.currentUserContext?.userId,
-            this.currentTaskContext?.domain,
-        ].filter((value) => typeof value === 'string' && value.trim().length > 0);
-        return Array.from(new Set(tags));
-    }
-    async assembleCognitiveMemoryContext(query) {
-        if (!this.cognitiveMemory || !query.trim()) {
-            return null;
-        }
-        try {
-            const context = await this.cognitiveMemory.assembleForPrompt(query, 1600, this.getCurrentPadState());
-            if (context.contextText.trim()) {
-                this.addTraceEntry(ReasoningEntryType.DEBUG, 'Cognitive memory context assembled.', {
-                    tokensUsed: context.tokensUsed,
-                    includedMemoryIds: context.includedMemoryIds,
-                });
-            }
-            return context;
-        }
-        catch (error) {
-            this.addTraceEntry(ReasoningEntryType.WARNING, 'Cognitive memory assembly failed.', {
-                error: error?.message ?? String(error),
-            });
-            return null;
-        }
-    }
-    async encodeCognitiveMemory(content, options) {
-        if (!this.cognitiveMemory || !content.trim()) {
-            return;
-        }
-        try {
-            await this.cognitiveMemory.observe?.(options.role, content, this.getCurrentPadState());
-            await this.cognitiveMemory.encode(content, this.getCurrentPadState(), this.currentGmiMood, {
-                type: options.type,
-                scope: 'user',
-                scopeId: options.scopeId ?? this.currentUserContext.userId ?? this.gmiId,
-                sourceType: options.sourceType,
-                tags: this.buildMemoryTags(options.role),
-            });
-        }
-        catch (error) {
-            this.addTraceEntry(ReasoningEntryType.WARNING, 'Cognitive memory encoding failed.', {
-                role: options.role,
-                error: error?.message ?? String(error),
-            });
-        }
-    }
-    async syncCognitiveMemoryForTurn(turnInput, responseText) {
-        const inputText = this.stringifyTurnContent(turnInput.content);
-        if (inputText && (turnInput.type === GMIInteractionType.TEXT ||
-            turnInput.type === GMIInteractionType.MULTIMODAL_CONTENT)) {
-            await this.encodeCognitiveMemory(inputText, {
-                type: 'episodic',
-                sourceType: 'user_statement',
-                scopeId: this.currentUserContext.userId,
-                role: 'user',
-            });
-        }
-        if (responseText.trim()) {
-            await this.encodeCognitiveMemory(responseText, {
-                type: 'semantic',
-                sourceType: 'agent_inference',
-                scopeId: turnInput.sessionId ?? this.currentUserContext.userId ?? this.gmiId,
-                role: 'assistant',
-            });
-        }
-    }
     getConversationIdForTurn(turnInput) {
         const metadataConversationId = typeof turnInput.metadata?.conversationId === 'string'
             ? turnInput.metadata.conversationId.trim()
@@ -365,128 +323,8 @@ export class GMI {
             ...extras,
         };
     }
-    /**
-     * Updates the internal conversation history with new input.
-     * @private
-     */
-    updateConversationHistory(turnInput) {
-        let messageToAdd = null;
-        switch (turnInput.type) {
-            case GMIInteractionType.TEXT:
-                messageToAdd = { role: 'user', content: turnInput.content, name: turnInput.metadata?.userName || turnInput.userId };
-                break;
-            case GMIInteractionType.MULTIMODAL_CONTENT:
-                messageToAdd = { role: 'user', content: turnInput.content, name: turnInput.metadata?.userName || turnInput.userId };
-                break;
-            case GMIInteractionType.TOOL_RESPONSE: {
-                const results = Array.isArray(turnInput.content) ? turnInput.content : [turnInput.content];
-                results.forEach(result => {
-                    this.conversationHistory.push({
-                        role: 'tool',
-                        tool_call_id: result.toolCallId,
-                        name: result.toolName,
-                        content: typeof result.output === 'string' ? result.output : JSON.stringify(result.output),
-                    });
-                });
-                break;
-            }
-            case GMIInteractionType.SYSTEM_MESSAGE:
-                messageToAdd = { role: 'system', content: turnInput.content };
-                break;
-        }
-        if (messageToAdd)
-            this.conversationHistory.push(messageToAdd);
-        const maxHistoryMessages = this.activePersona.conversationContextConfig?.maxMessages ||
-            this.activePersona.memoryConfig?.conversationContext?.maxMessages ||
-            DEFAULT_MAX_CONVERSATION_HISTORY_TURNS;
-        if (this.conversationHistory.length > maxHistoryMessages) {
-            const removeCount = this.conversationHistory.length - maxHistoryMessages;
-            this.conversationHistory.splice(0, removeCount);
-            this.addTraceEntry(ReasoningEntryType.DEBUG, `Conversation history trimmed to ${maxHistoryMessages} messages.`);
-        }
-    }
-    /**
-     * Adds a tool call result to the GMI's internal conversation history.
-     * @private
-     * @param {ToolCallResult} toolCallResult - The result from the tool execution.
-     */
-    updateConversationHistoryWithToolResult(toolCallResult) {
-        this.conversationHistory.push({
-            role: 'tool',
-            tool_call_id: toolCallResult.toolCallId,
-            name: toolCallResult.toolName, // Name of the tool
-            content: toolCallResult.isError
-                ? `Error from tool '${toolCallResult.toolName}': ${JSON.stringify(toolCallResult.errorDetails || toolCallResult.output)}`
-                : (typeof toolCallResult.output === 'string' ? toolCallResult.output : JSON.stringify(toolCallResult.output)),
-        });
-    }
-    /**
-     * Creates a conversation-history snapshot compatible with `PromptComponents`.
-     * @private
-     */
-    buildConversationHistoryForPrompt() {
-        return this.conversationHistory.map(msg => this.convertChatMessageToConversationMessage(msg));
-    }
-    convertChatMessageToConversationMessage(chatMsg) {
-        const conversationMessage = createConversationMessage(this.mapChatRoleToMessageRole(chatMsg.role), this.normalizeChatMessageContent(chatMsg.content), {
-            name: chatMsg.name,
-            tool_call_id: chatMsg.tool_call_id,
-        });
-        if (chatMsg.tool_calls && chatMsg.tool_calls.length > 0) {
-            conversationMessage.tool_calls = chatMsg.tool_calls
-                .filter(tc => !!tc?.function?.name)
-                .map(tc => ({
-                id: tc.id,
-                name: tc.function.name,
-                arguments: this.parseToolCallArguments(tc.function.arguments),
-            }));
-        }
-        return conversationMessage;
-    }
-    convertConversationMessageToChatMessage(message) {
-        if (message.role === MessageRole.ERROR || message.role === MessageRole.THOUGHT) {
-            return null;
-        }
-        const role = message.role === MessageRole.SYSTEM || message.role === MessageRole.SUMMARY
-            ? 'system'
-            : message.role === MessageRole.ASSISTANT
-                ? 'assistant'
-                : message.role === MessageRole.TOOL
-                    ? 'tool'
-                    : 'user';
-        const content = message.role === MessageRole.SUMMARY && typeof message.content === 'string'
-            ? `[Conversation Summary]\n${message.content}`
-            : this.normalizeConversationMessageContent(message.content);
-        return {
-            role,
-            content,
-            name: message.name,
-            tool_call_id: message.tool_call_id,
-            tool_calls: Array.isArray(message.tool_calls)
-                ? message.tool_calls.map((toolCall) => ({
-                    id: toolCall.id,
-                    type: 'function',
-                    function: {
-                        name: toolCall.name,
-                        arguments: JSON.stringify(toolCall.arguments ?? {}),
-                    },
-                }))
-                : undefined,
-        };
-    }
-    normalizeConversationMessageContent(content) {
-        if (content === null || typeof content === 'string') {
-            return content;
-        }
-        if (Array.isArray(content)) {
-            return content.map((part) => ({ ...part }));
-        }
-        return JSON.stringify(content);
-    }
     hydrateConversationHistory(conversationHistory) {
-        this.conversationHistory = conversationHistory
-            .map((message) => this.convertConversationMessageToChatMessage(message))
-            .filter((message) => message !== null);
+        this.conversationHistoryManager.hydrate(conversationHistory);
     }
     hydrateTurnContext(context) {
         if (typeof context.sessionId === 'string' && context.sessionId.trim()) {
@@ -499,47 +337,6 @@ export class GMI {
             this.reasoningTrace.organizationId = context.organizationId.trim();
         }
     }
-    mapChatRoleToMessageRole(role) {
-        switch (role) {
-            case 'system':
-                return MessageRole.SYSTEM;
-            case 'assistant':
-                return MessageRole.ASSISTANT;
-            case 'tool':
-                return MessageRole.TOOL;
-            default:
-                return MessageRole.USER;
-        }
-    }
-    normalizeChatMessageContent(content) {
-        if (typeof content === 'undefined') {
-            return null;
-        }
-        if (content === null || typeof content === 'string') {
-            return content;
-        }
-        if (Array.isArray(content)) {
-            return content.map(part => ({ ...part }));
-        }
-        return content;
-    }
-    parseToolCallArguments(args) {
-        if (!args) {
-            return {};
-        }
-        if (typeof args === 'string') {
-            try {
-                return JSON.parse(args);
-            }
-            catch {
-                return {};
-            }
-        }
-        if (typeof args === 'object') {
-            return args;
-        }
-        return {};
-    }
     /**
      * Builds the PromptExecutionContext for the PromptEngine.
      * @private
@@ -568,17 +365,54 @@ export class GMI {
      * @param {string} query - The current user query.
      * @returns {boolean} True if RAG should be triggered, false otherwise.
      */
-    shouldTriggerRAGRetrieval(query) {
+    shouldTriggerRAGRetrieval(query, context) {
         if (!query || query.trim() === '')
             return false;
         const ragConfig = this.activePersona.memoryConfig?.ragConfig;
         const retrievalTriggers = ragConfig?.retrievalTriggers;
-        if (retrievalTriggers?.onUserQuery) {
+        if (!retrievalTriggers)
+            return false;
+        if (retrievalTriggers.onUserQuery)
             return true;
+        if (retrievalTriggers.onToolFailure?.length && context?.lastToolFailed) {
+            return true;
+        }
+        if (retrievalTriggers.onIntentDetected?.length && context?.detectedIntents?.length) {
+            const matched = retrievalTriggers.onIntentDetected.some(intent => context.detectedIntents.includes(intent));
+            if (matched)
+                return true;
         }
-        // TODO: Implement more sophisticated logic based on other retrievalTriggers
-        // (e.g., onIntentDetected, onToolFailure, customLogicFunctionName)
-        return false; // Default
+        return false;
+    }
+    /**
+     * Determines the prompt format type based on model provider.
+     * @param modelDetails - Model metadata from the provider manager.
+     * @param providerId - The provider identifier.
+     * @returns The prompt format type string.
+     */
+    determinePromptFormat(modelDetails, providerId) {
+        const pid = (modelDetails?.providerId || providerId || '').toLowerCase();
+        if (pid.includes('anthropic'))
+            return 'anthropic_messages';
+        if (pid.includes('google') || pid.includes('gemini'))
+            return 'google_gemini';
+        if (pid.includes('cohere'))
+            return 'cohere_chat';
+        return 'openai_chat';
+    }
+    /**
+     * Determines the tool calling format based on model provider.
+     * @param modelDetails - Model metadata from the provider manager.
+     * @param providerId - The provider identifier.
+     * @returns The tool format string.
+     */
+    determineToolFormat(modelDetails, providerId) {
+        const pid = (modelDetails?.providerId || providerId || '').toLowerCase();
+        if (pid.includes('anthropic'))
+            return 'anthropic_tools';
+        if (pid.includes('google') || pid.includes('gemini'))
+            return 'google_function_calling';
+        return 'openai_functions';
     }
     /** @inheritdoc */
     async *processTurnStream(turnInput) {
@@ -604,7 +438,18 @@ export class GMI {
         let lastErrorForOutput = undefined;
         try {
             if (turnInput.userContextOverride) {
-                this.currentUserContext = { ...this.currentUserContext, ...turnInput.userContextOverride };
+                const mergedPreferences = turnInput.userContextOverride.preferences &&
+                    typeof turnInput.userContextOverride.preferences === 'object'
+                    ? {
+                        ...(this.currentUserContext.preferences ?? {}),
+                        ...turnInput.userContextOverride.preferences,
+                    }
+                    : this.currentUserContext.preferences;
+                this.currentUserContext = {
+                    ...this.currentUserContext,
+                    ...turnInput.userContextOverride,
+                    ...(mergedPreferences ? { preferences: mergedPreferences } : {}),
+                };
                 await this.workingMemory.set('currentUserContext', this.currentUserContext);
             }
             if (turnInput.taskContextOverride) {
@@ -615,17 +460,20 @@ export class GMI {
                 this.currentUserContext.userId = turnInput.userId;
                 await this.workingMemory.set('currentUserContext', this.currentUserContext);
             }
-            this.updateConversationHistory(turnInput);
+            const maxHistoryMessages = this.activePersona.conversationContextConfig?.maxMessages ||
+                this.activePersona.memoryConfig?.conversationContext?.maxMessages ||
+                DEFAULT_MAX_CONVERSATION_HISTORY_TURNS;
+            this.conversationHistoryManager.update(turnInput, maxHistoryMessages);
             // Analyze sentiment of user input only when sentiment tracking is enabled
             if (this.activePersona.sentimentTracking?.enabled) {
-                const lastMsg = this.conversationHistory.length > 0
-                    ? this.conversationHistory[this.conversationHistory.length - 1]
+                const lastMsg = this.conversationHistoryManager.history.length > 0
+                    ? this.conversationHistoryManager.history[this.conversationHistoryManager.history.length - 1]
                     : null;
                 if (lastMsg?.role === 'user' && lastMsg?.content) {
                     const userInputText = typeof lastMsg.content === 'string'
                         ? lastMsg.content
                         : JSON.stringify(lastMsg.content);
-                    await this.analyzeTurnSentiment(turnId, userInputText);
+                    await this.sentimentTracker.analyzeTurnSentiment(turnId, userInputText);
                 }
             }
             // -------------------------------------------------------------------
@@ -662,7 +510,7 @@ export class GMI {
                     ? turnInput.metadata.longTermMemoryContext.trim()
                     : "";
                 let assembledMemoryContext = null;
-                const lastMessage = this.conversationHistory.length > 0 ? this.conversationHistory[this.conversationHistory.length - 1] : null;
+                const lastMessage = this.conversationHistoryManager.history.length > 0 ? this.conversationHistoryManager.history[this.conversationHistoryManager.history.length - 1] : null;
                 const isUserInitiatedTurn = lastMessage?.role === 'user';
                 const currentTurnText = isUserInitiatedTurn && lastMessage?.content
                     ? (typeof lastMessage.content === 'string'
@@ -673,10 +521,16 @@ export class GMI {
                     const currentQueryForRag = currentTurnText;
                     if (this.shouldTriggerRAGRetrieval(currentQueryForRag)) {
                         this.addTraceEntry(ReasoningEntryType.RAG_QUERY_START, "RAG retrieval triggered.", { queryPreview: currentQueryForRag.substring(0, 100) });
+                        const ragCfg = this.activePersona.memoryConfig?.ragConfig;
+                        const strategyMap = {
+                            similarity: 'similarity', mmr: 'mmr', hybrid_search: 'hybrid',
+                        };
                         const retrievalOptions = {
-                            topK: this.activePersona.memoryConfig?.ragConfig?.defaultRetrievalTopK || 5,
-                            targetDataSourceIds: this.activePersona.memoryConfig?.ragConfig?.dataSources?.filter(ds => ds.isEnabled).map(ds => ds.dataSourceNameOrId),
-                            // TODO: Populate other options like metadataFilter, strategy from persona config
+                            topK: ragCfg?.defaultRetrievalTopK || 5,
+                            targetDataSourceIds: ragCfg?.dataSources?.filter(ds => ds.isEnabled).map(ds => ds.dataSourceNameOrId),
+                            ...(ragCfg?.defaultRetrievalStrategy && {
+                                strategy: strategyMap[ragCfg.defaultRetrievalStrategy] ?? 'similarity',
+                            }),
                         };
                         const ragResult = await this.retrievalAugmentor.retrieveContext(currentQueryForRag, retrievalOptions);
                         augmentedContextFromRAG = ragResult.augmentedContext;
@@ -684,7 +538,7 @@ export class GMI {
                     }
                 }
                 if (isUserInitiatedTurn && currentTurnText) {
-                    assembledMemoryContext = await this.assembleCognitiveMemoryContext(currentTurnText);
+                    assembledMemoryContext = await this.memoryBridge?.assembleContext(currentTurnText) ?? null;
                 }
                 const promptExecContext = this.buildPromptExecutionContext();
                 const baseSystemPrompts = Array.isArray(this.activePersona.baseSystemPrompt)
@@ -722,12 +576,21 @@ export class GMI {
                         priority: 55,
                     });
                 }
+                const skillPromptContext = typeof turnInput.metadata?.skillPromptContext === 'string'
+                    ? turnInput.metadata.skillPromptContext.trim()
+                    : '';
+                if (skillPromptContext) {
+                    systemPrompts.push({
+                        content: skillPromptContext,
+                        priority: 57,
+                    });
+                }
                 const durableHistoryForPrompt = Array.isArray(turnInput.metadata?.conversationHistoryForPrompt) && turnInput.metadata?.conversationHistoryForPrompt.length > 0
                     ? turnInput.metadata?.conversationHistoryForPrompt
                     : null;
                 const promptComponents = {
                     systemPrompts,
-                    conversationHistory: durableHistoryForPrompt ?? this.buildConversationHistoryForPrompt(),
+                    conversationHistory: durableHistoryForPrompt ?? this.conversationHistoryManager.buildForPrompt(),
                     userInput: isUserInitiatedTurn ? currentTurnText : null,
                     retrievedContext: [
                         assembledMemoryContext?.contextText,
@@ -749,8 +612,11 @@ export class GMI {
                     providerId: modelDetails?.providerId || providerIdForModel || this.llmProviderManager.getProviderForModel(modelIdToUse)?.providerId || 'unknown',
                     maxContextTokens: modelDetails?.contextWindowSize || 8192, // Default fallback
                     capabilities: modelDetails?.capabilities || [],
-                    promptFormatType: 'openai_chat', // TODO: Determine from modelDetails or provider features
-                    toolSupport: { supported: modelDetails?.capabilities.includes('tool_use') || false, format: 'openai_functions' }, // TODO: Determine format
+                    promptFormatType: this.determinePromptFormat(modelDetails, providerIdForModel),
+                    toolSupport: {
+                        supported: modelDetails?.capabilities.includes('tool_use') || false,
+                        format: this.determineToolFormat(modelDetails, providerIdForModel),
+                    },
                 };
                 const promptEngineResult = await this.promptEngine.constructPrompt(promptComponents, modelTargetInfo, promptExecContext);
                 promptEngineResult.issues?.forEach(issue => this.addTraceEntry(ReasoningEntryType.WARNING, `Prompt Engine Issue: ${issue.message}`, issue));
@@ -842,7 +708,7 @@ export class GMI {
                 if (!textDeltaEmitted && aggregatedResponseText) {
                     yield this.createOutputChunk(turnInput.interactionId, GMIOutputChunkType.TEXT_DELTA, aggregatedResponseText);
                 }
-                this.conversationHistory.push({
+                this.conversationHistoryManager.push({
                     role: 'assistant',
                     content: currentIterationTextResponse || null,
                     tool_calls: currentIterationToolCallRequests.length > 0
@@ -876,7 +742,7 @@ export class GMI {
                             });
                         }
                     }
-                    toolExecutionResults.forEach(tcResult => this.updateConversationHistoryWithToolResult(tcResult));
+                    toolExecutionResults.forEach(tcResult => this.conversationHistoryManager.updateWithToolResult(tcResult));
                     currentIterationTextResponse = ""; // Reset for next iteration if any
                     currentIterationToolCallRequests = []; // Reset
                     this.state = GMIPrimeState.PROCESSING;
@@ -884,10 +750,10 @@ export class GMI {
                 }
                 break main_processing_loop; // Break if no tool calls
             }
-            await this.syncCognitiveMemoryForTurn(turnInput, aggregatedResponseText);
+            await this.memoryBridge?.syncForTurn(turnInput, aggregatedResponseText);
             await this.performPostTurnIngestion(this.stringifyTurnContent(turnInput.content) ?? '', aggregatedResponseText);
             // Check and trigger all metaprompts (turn_interval, event_based, manual)
-            await this.checkAndTriggerMetaprompts(turnId);
+            await this.metapromptExecutor.checkAndTriggerMetaprompts(turnId);
             // Prepare the final GMIOutput for the generator's return value
             const finalTurnOutput = {
                 isFinal: true,
@@ -968,7 +834,7 @@ export class GMI {
                 success: !toolResult.isError,
             })),
         });
-        toolResults.forEach((toolResult) => this.updateConversationHistoryWithToolResult(toolResult));
+        toolResults.forEach((toolResult) => this.conversationHistoryManager.updateWithToolResult(toolResult));
         // Construct a system turn input to represent the continuation after tool result
         const systemTurnInput = {
             interactionId,
@@ -1091,753 +957,9 @@ export class GMI {
             console.error(`GMI (ID: ${this.gmiId}): RAG Ingestion Error - ${gmiError.message}`, gmiError.details);
         }
     }
-    /**
-     * Analyzes sentiment of user input and updates sentiment history.
-     * Triggers event detection based on sentiment patterns.
-     *
-     * @param turnId - Current turn identifier
-     * @param userInput - User's input text
-     * @private
-     */
-    async analyzeTurnSentiment(turnId, userInput) {
-        // Skip if input is not a string or is empty
-        if (!userInput || typeof userInput !== 'string') {
-            return;
-        }
-        try {
-            // Analyze sentiment using configurable method from sentimentTracking config
-            const stConfig = this.activePersona.sentimentTracking;
-            const sentimentResult = await this.utilityAI.analyzeSentiment(userInput, {
-                method: stConfig?.method || 'lexicon_based',
-                modelId: stConfig?.modelId || this.activePersona.defaultModelId,
-                providerId: stConfig?.providerId || this.activePersona.defaultProviderId,
-                language: this.currentUserContext.language || 'en',
-            });
-            // Update UserContext with current sentiment
-            this.currentUserContext.currentSentiment = sentimentResult.polarity;
-            await this.workingMemory.set('currentUserContext', this.currentUserContext);
-            // Get or initialize sentiment history
-            let sentimentHistory = await this.workingMemory.get('gmi_sentiment_history');
-            if (!sentimentHistory) {
-                sentimentHistory = {
-                    trends: [],
-                    consecutiveFrustration: 0,
-                    consecutiveConfusion: 0,
-                    consecutiveSatisfaction: 0,
-                };
-            }
-            // Add to sentiment trends
-            const trend = {
-                turnId,
-                timestamp: new Date(),
-                score: sentimentResult.score,
-                polarity: sentimentResult.polarity,
-                intensity: sentimentResult.intensity || 0,
-                context: userInput.substring(0, 100), // First 100 chars
-            };
-            sentimentHistory.trends.push(trend);
-            // Keep only last N trends (configurable sliding window)
-            const historyWindow = stConfig?.historyWindow || 10;
-            if (sentimentHistory.trends.length > historyWindow) {
-                sentimentHistory.trends.shift();
-            }
-            // Update consecutive counters based on configurable thresholds
-            const frustrationThreshold = stConfig?.frustrationThreshold ?? -0.3;
-            const satisfactionThreshold = stConfig?.satisfactionThreshold ?? 0.3;
-            if (sentimentResult.score < frustrationThreshold) {
-                // Negative sentiment
-                sentimentHistory.consecutiveFrustration++;
-                sentimentHistory.consecutiveConfusion = 0;
-                sentimentHistory.consecutiveSatisfaction = 0;
-            }
-            else if (sentimentResult.score > satisfactionThreshold) {
-                // Positive sentiment
-                sentimentHistory.consecutiveSatisfaction++;
-                sentimentHistory.consecutiveFrustration = 0;
-                sentimentHistory.consecutiveConfusion = 0;
-            }
-            else {
-                // Neutral sentiment (or close to it)
-                sentimentHistory.consecutiveConfusion++;
-                sentimentHistory.consecutiveFrustration = 0;
-                sentimentHistory.consecutiveSatisfaction = 0;
-            }
-            sentimentHistory.lastAnalyzedTurnId = turnId;
-            // Store updated sentiment history
-            await this.workingMemory.set('gmi_sentiment_history', sentimentHistory);
-            this.addTraceEntry(ReasoningEntryType.DEBUG, 'Turn sentiment analyzed', {
-                sentiment: {
-                    score: sentimentResult.score,
-                    polarity: sentimentResult.polarity,
-                    intensity: sentimentResult.intensity,
-                },
-                consecutiveCounters: {
-                    frustration: sentimentHistory.consecutiveFrustration,
-                    confusion: sentimentHistory.consecutiveConfusion,
-                    satisfaction: sentimentHistory.consecutiveSatisfaction,
-                },
-            });
-            // Detect and emit events based on sentiment patterns
-            await this.detectAndEmitEvents(turnId, userInput, sentimentResult, sentimentHistory);
-        }
-        catch (error) {
-            // Don't fail the turn if sentiment analysis fails - log and continue
-            console.error(`GMI (ID: ${this.gmiId}): Sentiment analysis error:`, error);
-            this.addTraceEntry(ReasoningEntryType.WARNING, 'Sentiment analysis failed', { error: error.message });
-        }
-    }
-    /**
-     * Detects emotional patterns and emits appropriate GMI events.
-     *
-     * @param turnId - Current turn identifier
-     * @param userInput - User's input text
-     * @param sentimentResult - Sentiment analysis result
-     * @param sentimentHistory - Historical sentiment data
-     * @private
-     */
-    async detectAndEmitEvents(turnId, userInput, sentimentResult, sentimentHistory) {
-        // Read configurable thresholds
-        const stConfig = this.activePersona.sentimentTracking;
-        const frustThreshold = stConfig?.frustrationThreshold ?? -0.3;
-        const satisThreshold = stConfig?.satisfactionThreshold ?? 0.3;
-        const consecutiveRequired = stConfig?.consecutiveTurnsForTrigger ?? 2;
-        // Frustration detection
-        if ((sentimentResult.score < frustThreshold && (sentimentResult.intensity || 0) > 0.6) ||
-            sentimentHistory.consecutiveFrustration >= consecutiveRequired) {
-            this.emitEvent(createGMIEvent(GMIEventType.USER_FRUSTRATED, turnId, sentimentHistory.consecutiveFrustration >= 2 ? 'high' : 'medium', {
-                sentimentScore: sentimentResult.score,
-                sentimentPolarity: sentimentResult.polarity,
-                sentimentIntensity: sentimentResult.intensity,
-                consecutiveTurns: sentimentHistory.consecutiveFrustration,
-                triggeredBy: 'sentiment',
-            }));
-        }
-        // Confusion detection (keyword-based + sentiment)
-        const confusionKeywords = [
-            'confused',
-            "don't understand",
-            "dont understand",
-            'unclear',
-            'what do you mean',
-            'explain',
-            'clarify',
-            'huh',
-            '??',
-            "doesn't make sense",
-            "doesnt make sense",
-            'not sure',
-        ];
-        const lowerInput = userInput.toLowerCase();
-        const hasConfusionKeyword = confusionKeywords.some((keyword) => lowerInput.includes(keyword));
-        const triggerKeywords = hasConfusionKeyword
-            ? confusionKeywords.filter((keyword) => lowerInput.includes(keyword))
-            : [];
-        if (hasConfusionKeyword ||
-            (sentimentResult.polarity === 'neutral' &&
-                sentimentResult.negativeTokens &&
-                sentimentResult.negativeTokens.length > 2)) {
-            this.emitEvent(createGMIEvent(GMIEventType.USER_CONFUSED, turnId, sentimentHistory.consecutiveConfusion >= 2 ? 'high' : 'medium', {
-                triggeredBy: hasConfusionKeyword ? 'keyword' : 'sentiment',
-                consecutiveTurns: sentimentHistory.consecutiveConfusion,
-                evidencePreview: userInput.substring(0, 100),
-                triggerKeywords: hasConfusionKeyword ? triggerKeywords : undefined,
-            }));
-        }
-        // Satisfaction detection
-        if ((sentimentResult.score > satisThreshold && (sentimentResult.intensity || 0) > 0.5) ||
-            sentimentHistory.consecutiveSatisfaction >= (consecutiveRequired + 1)) {
-            this.emitEvent(createGMIEvent(GMIEventType.USER_SATISFIED, turnId, 'low', {
-                sentimentScore: sentimentResult.score,
-                sentimentPolarity: sentimentResult.polarity,
-                sentimentIntensity: sentimentResult.intensity,
-                consecutiveTurns: sentimentHistory.consecutiveSatisfaction,
-                triggeredBy: 'sentiment',
-            }));
-        }
-        // Error threshold detection (check reasoning trace for recent errors)
-        const recentErrors = this.reasoningTrace.entries
-            .slice(-10)
-            .filter((entry) => entry.type === ReasoningEntryType.ERROR);
-        if (recentErrors.length >= 2) {
-            this.emitEvent(createGMIEvent(GMIEventType.ERROR_THRESHOLD_EXCEEDED, turnId, 'high', {
-                triggeredBy: 'error',
-                errorCount: recentErrors.length,
-                consecutiveTurns: recentErrors.length,
-            }));
-        }
-        // Low engagement detection (consecutive neutral with short responses)
-        const recentUserMessages = this.conversationHistory
-            .slice(-5)
-            .filter((msg) => msg.role === 'user');
-        const avgLength = recentUserMessages.length > 0
-            ? recentUserMessages.reduce((sum, msg) => sum + String(msg.content).length, 0) / recentUserMessages.length
-            : 0;
-        if (sentimentHistory.consecutiveConfusion >= 4 && avgLength < 50) {
-            this.emitEvent(createGMIEvent(GMIEventType.LOW_ENGAGEMENT, turnId, 'medium', {
-                triggeredBy: 'pattern',
-                consecutiveTurns: sentimentHistory.consecutiveConfusion,
-                evidencePreview: `Avg response length: ${avgLength.toFixed(0)} chars`,
-            }));
-        }
-    }
-    /**
-     * Emits a GMI event and stores it in event history.
-     *
-     * @param event - The event to emit
-     * @private
-     */
-    emitEvent(event) {
-        // Add to pending events (will be consumed by trigger checking)
-        this.pendingGMIEvents.add(event.eventType);
-        // Add to event history for debugging (circular buffer, max 20)
-        this.eventHistory.push(event);
-        if (this.eventHistory.length > 20) {
-            this.eventHistory.shift();
-        }
-        this.addTraceEntry(ReasoningEntryType.DEBUG, `GMI Event Emitted: ${event.eventType}`, {
-            event: {
-                eventType: event.eventType,
-                turnId: event.turnId,
-                severity: event.severity,
-                metadata: event.metadata,
-            },
-        });
-    }
-    /**
-     * Checks all metaprompt triggers (turn_interval, event_based, manual) and executes triggered ones.
-     *
-     * @param turnId - Current turn identifier
-     * @private
-     */
-    async checkAndTriggerMetaprompts(turnId) {
-        if (!this.activePersona.metaPrompts || this.activePersona.metaPrompts.length === 0) {
-            return;
-        }
-        const triggeredMetaPrompts = [];
-        for (const metaPrompt of this.activePersona.metaPrompts) {
-            if (!metaPrompt.trigger)
-                continue;
-            if (metaPrompt.trigger.type === 'turn_interval') {
-                // Existing turn_interval logic
-                const counter = await this.getMetapromptTurnCounter(metaPrompt.id);
-                if (counter >= metaPrompt.trigger.intervalTurns) {
-                    triggeredMetaPrompts.push(metaPrompt);
-                    await this.resetMetapromptTurnCounter(metaPrompt.id);
-                }
-                else {
-                    await this.incrementMetapromptTurnCounter(metaPrompt.id);
-                }
-            }
-            else if (metaPrompt.trigger.type === 'event_based') {
-                // NEW: Event-based trigger checking
-                const eventName = metaPrompt.trigger.eventName;
-                if (this.pendingGMIEvents.has(eventName)) {
-                    triggeredMetaPrompts.push(metaPrompt);
-                    // Consume the event (remove from pending)
-                    this.pendingGMIEvents.delete(eventName);
-                }
-            }
-            else if (metaPrompt.trigger.type === 'manual') {
-                // NEW: Manual trigger checking
-                // Check for manual trigger flag in working memory
-                const manualFlag = await this.workingMemory.get(`manual_trigger_${metaPrompt.id}`);
-                if (manualFlag) {
-                    triggeredMetaPrompts.push(metaPrompt);
-                    // Clear the flag
-                    await this.workingMemory.delete(`manual_trigger_${metaPrompt.id}`);
-                }
-            }
-        }
-        if (triggeredMetaPrompts.length > 0) {
-            this.addTraceEntry(ReasoningEntryType.SELF_REFLECTION_TRIGGERED, `${triggeredMetaPrompts.length} metaprompt(s) triggered`, { ids: triggeredMetaPrompts.map((m) => m.id), turnId });
-            // Execute metaprompts (background task, don't block turn)
-            this.executeMetaprompts(triggeredMetaPrompts).catch((err) => {
-                console.error(`GMI (ID: ${this.gmiId}): Metaprompt execution error:`, err);
-                this.addTraceEntry(ReasoningEntryType.ERROR, 'Metaprompt execution failed', { error: err.message });
-            });
-        }
-    }
-    /**
-     * Gets the turn counter for a specific metaprompt.
-     *
-     * @param metapromptId - Metaprompt identifier
-     * @returns Current counter value
-     * @private
-     */
-    async getMetapromptTurnCounter(metapromptId) {
-        const counter = this.metaPromptTriggerCounters.get(metapromptId);
-        if (counter !== undefined) {
-            return counter;
-        }
-        // Try loading from working memory (for persistence across GMI instances)
-        const storedCounter = await this.workingMemory.get(`metaprompt_turn_counter_${metapromptId}`);
-        return storedCounter || 0;
-    }
-    /**
-     * Increments the turn counter for a specific metaprompt.
-     *
-     * @param metapromptId - Metaprompt identifier
-     * @private
-     */
-    async incrementMetapromptTurnCounter(metapromptId) {
-        const current = await this.getMetapromptTurnCounter(metapromptId);
-        const newValue = current + 1;
-        this.metaPromptTriggerCounters.set(metapromptId, newValue);
-        await this.workingMemory.set(`metaprompt_turn_counter_${metapromptId}`, newValue);
-    }
-    /**
-     * Resets the turn counter for a specific metaprompt to zero.
-     *
-     * @param metapromptId - Metaprompt identifier
-     * @private
-     */
-    async resetMetapromptTurnCounter(metapromptId) {
-        this.metaPromptTriggerCounters.set(metapromptId, 0);
-        await this.workingMemory.set(`metaprompt_turn_counter_${metapromptId}`, 0);
-    }
-    /**
-     * Executes multiple metaprompts in parallel or sequence.
-     * Replaces the single-metaprompt _triggerAndProcessSelfReflection().
-     *
-     * @param metaPrompts - Array of metaprompts to execute
-     * @private
-     */
-    async executeMetaprompts(metaPrompts) {
-        if (metaPrompts.length === 0)
-            return;
-        const previousState = this.state;
-        this.state = GMIPrimeState.REFLECTING;
-        this.addTraceEntry(ReasoningEntryType.SELF_REFLECTION_START, `Executing ${metaPrompts.length} metaprompt(s)`, { ids: metaPrompts.map((m) => m.id) });
-        try {
-            // Execute metaprompts in parallel using Promise.allSettled
-            // This allows all to run even if some fail
-            const results = await Promise.allSettled(metaPrompts.map((mp) => this.executeMetapromptHandler(mp)));
-            // Log any failures
-            results.forEach((result, idx) => {
-                if (result.status === 'rejected') {
-                    this.addTraceEntry(ReasoningEntryType.ERROR, `Metaprompt '${metaPrompts[idx].id}' failed: ${result.reason}`, { error: result.reason });
-                }
-            });
-        }
-        catch (error) {
-            const gmiError = createGMIErrorFromError(error, GMIErrorCode.GMI_PROCESSING_ERROR, undefined, 'Error during metaprompt execution');
-            this.addTraceEntry(ReasoningEntryType.ERROR, gmiError.message, gmiError.toPlainObject());
-        }
-        finally {
-            // Restore state
-            const disallowedStates = new Set([
-                GMIPrimeState.IDLE,
-                GMIPrimeState.INITIALIZING,
-            ]);
-            this.state = disallowedStates.has(previousState)
-                ? GMIPrimeState.READY
-                : previousState;
-            this.addTraceEntry(ReasoningEntryType.SELF_REFLECTION_COMPLETE, 'Metaprompt execution cycle complete');
-        }
-    }
-    /**
-     * Routes a metaprompt to its appropriate handler based on ID.
-     *
-     * @param metaPrompt - Metaprompt definition to execute
-     * @private
-     */
-    async executeMetapromptHandler(metaPrompt) {
-        // Handler routing map
-        switch (metaPrompt.id) {
-            case 'gmi_self_trait_adjustment':
-                return this.handleTraitAdjustment(metaPrompt);
-            case 'gmi_frustration_recovery':
-                return this.handleFrustrationRecovery(metaPrompt);
-            case 'gmi_confusion_clarification':
-                return this.handleConfusionClarification(metaPrompt);
-            case 'gmi_satisfaction_reinforcement':
-                return this.handleSatisfactionReinforcement(metaPrompt);
-            case 'gmi_error_recovery':
-                return this.handleErrorRecovery(metaPrompt);
-            case 'gmi_engagement_boost':
-                return this.handleEngagementBoost(metaPrompt);
-            default:
-                // Generic handler for custom metaprompts
-                return this.handleGenericMetaprompt(metaPrompt);
-        }
-    }
-    /**
-     * Handler for trait adjustment metaprompt (existing self-reflection logic).
-     *
-     * @param metaPrompt - Metaprompt definition
-     * @private
-     */
-    async handleTraitAdjustment(metaPrompt) {
-        // Gather evidence for self-reflection
-        const evidenceHistory = this.conversationHistory.slice(-10);
-        const evidenceTrace = this.reasoningTrace.entries.slice(-20);
-        const evidence = {
-            recentHistory: evidenceHistory,
-            recentReasoning: evidenceTrace,
-            currentMood: this.currentGmiMood,
-            userContext: this.currentUserContext,
-            taskContext: this.currentTaskContext,
-        };
-        const variables = {
-            evidence: JSON.stringify(evidence).substring(0, 4000), // Limit size
-            current_mood: this.currentGmiMood,
-            user_skill: this.currentUserContext.skillLevel || 'unknown',
-            task_complexity: this.currentTaskContext.complexity || 'unknown',
-        };
-        const response = await this.executeMetapromptWithVariables(metaPrompt, variables);
-        await this.applyMetapromptUpdates(response, metaPrompt.id);
-    }
-    /**
-     * Handler for frustration recovery metaprompt.
-     *
-     * @param metaPrompt - Metaprompt definition
-     * @private
-     */
-    async handleFrustrationRecovery(metaPrompt) {
-        const sentimentHistory = await this.workingMemory.get('gmi_sentiment_history');
-        const recentErrors = this.reasoningTrace.entries
-            .slice(-10)
-            .filter((e) => e.type === ReasoningEntryType.ERROR);
-        const variables = {
-            current_sentiment: this.currentUserContext.currentSentiment || 'negative',
-            sentiment_score: (sentimentHistory?.trends[sentimentHistory.trends.length - 1]?.score || -0.5).toString(),
-            consecutive_frustration: (sentimentHistory?.consecutiveFrustration || 1).toString(),
-            recent_conversation: JSON.stringify(this.conversationHistory.slice(-5)),
-            recent_errors: JSON.stringify(recentErrors.map((e) => e.message)),
-            current_mood: this.currentGmiMood,
-            user_skill: this.currentUserContext.skillLevel || 'unknown',
-            task_complexity: this.currentTaskContext.complexity || 'unknown',
-        };
-        const response = await this.executeMetapromptWithVariables(metaPrompt, variables);
-        await this.applyMetapromptUpdates(response, metaPrompt.id);
-    }
-    /**
-     * Handler for confusion clarification metaprompt.
-     *
-     * @param metaPrompt - Metaprompt definition
-     * @private
-     */
-    async handleConfusionClarification(metaPrompt) {
-        const sentimentHistory = await this.workingMemory.get('gmi_sentiment_history');
-        // Get the last event for confusion keywords
-        const lastConfusionEvent = this.eventHistory
-            .slice()
-            .reverse()
-            .find((e) => e.eventType === GMIEventType.USER_CONFUSED);
-        const variables = {
-            current_sentiment: this.currentUserContext.currentSentiment || 'neutral',
-            consecutive_confusion: (sentimentHistory?.consecutiveConfusion || 1).toString(),
-            recent_conversation: JSON.stringify(this.conversationHistory.slice(-5)),
-            confusion_keywords: lastConfusionEvent?.metadata.triggerKeywords
-                ? JSON.stringify(lastConfusionEvent.metadata.triggerKeywords)
-                : '[]',
-            current_mood: this.currentGmiMood,
-            user_skill: this.currentUserContext.skillLevel || 'unknown',
-            task_complexity: this.currentTaskContext.complexity || 'unknown',
-        };
-        const response = await this.executeMetapromptWithVariables(metaPrompt, variables);
-        await this.applyMetapromptUpdates(response, metaPrompt.id);
-    }
-    /**
-     * Handler for satisfaction reinforcement metaprompt.
-     *
-     * @param metaPrompt - Metaprompt definition
-     * @private
-     */
-    async handleSatisfactionReinforcement(metaPrompt) {
-        const sentimentHistory = await this.workingMemory.get('gmi_sentiment_history');
-        const variables = {
-            current_sentiment: this.currentUserContext.currentSentiment || 'positive',
-            sentiment_score: (sentimentHistory?.trends[sentimentHistory.trends.length - 1]?.score || 0.5).toString(),
-            consecutive_satisfaction: (sentimentHistory?.consecutiveSatisfaction || 1).toString(),
-            recent_conversation: JSON.stringify(this.conversationHistory.slice(-5)),
-            current_mood: this.currentGmiMood,
-            user_skill: this.currentUserContext.skillLevel || 'unknown',
-            task_complexity: this.currentTaskContext.complexity || 'unknown',
-        };
-        const response = await this.executeMetapromptWithVariables(metaPrompt, variables);
-        await this.applyMetapromptUpdates(response, metaPrompt.id);
-    }
-    /**
-     * Handler for error recovery metaprompt.
-     *
-     * @param metaPrompt - Metaprompt definition
-     * @private
-     */
-    async handleErrorRecovery(metaPrompt) {
-        const recentErrors = this.reasoningTrace.entries
-            .slice(-10)
-            .filter((e) => e.type === ReasoningEntryType.ERROR);
-        const variables = {
-            recent_errors: JSON.stringify(recentErrors.map((e) => ({ message: e.message, details: e.details }))),
-            recent_conversation: JSON.stringify(this.conversationHistory.slice(-5)),
-            current_mood: this.currentGmiMood,
-            user_skill: this.currentUserContext.skillLevel || 'unknown',
-            task_complexity: this.currentTaskContext.complexity || 'unknown',
-        };
-        const response = await this.executeMetapromptWithVariables(metaPrompt, variables);
-        await this.applyMetapromptUpdates(response, metaPrompt.id);
-    }
-    /**
-     * Handler for engagement boost metaprompt.
-     *
-     * @param metaPrompt - Metaprompt definition
-     * @private
-     */
-    async handleEngagementBoost(metaPrompt) {
-        const sentimentHistory = await this.workingMemory.get('gmi_sentiment_history');
-        const variables = {
-            consecutive_neutral: (sentimentHistory?.consecutiveConfusion || 4).toString(),
-            recent_conversation: JSON.stringify(this.conversationHistory.slice(-5)),
-            current_mood: this.currentGmiMood,
-            user_skill: this.currentUserContext.skillLevel || 'unknown',
-            task_complexity: this.currentTaskContext.complexity || 'unknown',
-        };
-        const response = await this.executeMetapromptWithVariables(metaPrompt, variables);
-        await this.applyMetapromptUpdates(response, metaPrompt.id);
-    }
-    /**
-     * Generic handler for custom metaprompts not in the preset list.
-     *
-     * @param metaPrompt - Metaprompt definition
-     * @private
-     */
-    async handleGenericMetaprompt(metaPrompt) {
-        // Generic handler that provides all available context
-        const variables = {
-            recent_conversation: JSON.stringify(this.conversationHistory.slice(-5)),
-            recent_reasoning: JSON.stringify(this.reasoningTrace.entries.slice(-10)),
-            current_mood: this.currentGmiMood,
-            user_skill: this.currentUserContext.skillLevel || 'unknown',
-            task_complexity: this.currentTaskContext.complexity || 'unknown',
-            current_sentiment: this.currentUserContext.currentSentiment || 'neutral',
-        };
-        const response = await this.executeMetapromptWithVariables(metaPrompt, variables);
-        await this.applyMetapromptUpdates(response, metaPrompt.id);
-    }
-    /**
-     * Executes a metaprompt with variable substitution.
-     *
-     * @param metaPrompt - Metaprompt definition
-     * @param variables - Variables to substitute in the template
-     * @returns Parsed JSON response from LLM
-     * @private
-     */
-    async executeMetapromptWithVariables(metaPrompt, variables) {
-        // Extract template
-        let template;
-        if (typeof metaPrompt.promptTemplate === 'string') {
-            template = metaPrompt.promptTemplate;
-        }
-        else {
-            template = metaPrompt.promptTemplate.template;
-        }
-        // Substitute variables
-        let finalPrompt = template;
-        for (const [key, value] of Object.entries(variables)) {
-            finalPrompt = finalPrompt.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), value);
-        }
-        // Get model and provider info
-        const modelId = metaPrompt.modelId || this.activePersona.defaultModelId;
-        const providerId = metaPrompt.providerId || this.activePersona.defaultProviderId;
-        if (!modelId || !providerId) {
-            throw new GMIError('No model or provider specified for metaprompt', GMIErrorCode.CONFIGURATION_ERROR);
-        }
-        // Call LLM
-        this.addTraceEntry(ReasoningEntryType.DEBUG, `Executing metaprompt '${metaPrompt.id}'`, { modelId, providerId });
-        const completionOptions = {
-            temperature: metaPrompt.temperature ?? 0.3,
-            maxTokens: metaPrompt.maxOutputTokens ?? 512,
-            responseFormat: { type: 'json_object' },
-        };
-        const provider = this.llmProviderManager.getProvider(providerId);
-        if (!provider) {
-            throw new GMIError(`Provider '${providerId}' not found for metaprompt '${metaPrompt.id}'.`, GMIErrorCode.LLM_PROVIDER_UNAVAILABLE);
-        }
-        const result = await provider.generateCompletion(modelId, [{ role: 'user', content: finalPrompt }], completionOptions);
-        const responseContent = result.choices?.[0]?.message?.content;
-        if (!responseContent || typeof responseContent !== 'string') {
-            throw new GMIError(`Metaprompt '${metaPrompt.id}' returned no valid content.`, GMIErrorCode.LLM_PROVIDER_ERROR, { response: result });
-        }
-        // Parse JSON with LLM-based recovery
-        const parseOptions = {
-            attemptFixWithLLM: true,
-            llmModelIdForFix: modelId,
-            llmProviderIdForFix: providerId,
-        };
-        const parsedResponse = await this.utilityAI.parseJsonSafe(responseContent, parseOptions);
-        return parsedResponse;
-    }
-    /**
-     * Applies metaprompt updates to GMI state (mood, user skill, task complexity, memory).
-     *
-     * @param updates - Parsed updates from metaprompt response
-     * @param metapromptId - ID of the metaprompt that generated these updates
-     * @private
-     */
-    async applyMetapromptUpdates(updates, metapromptId) {
-        if (!updates)
-            return;
-        let stateChanged = false;
-        // Mood update
-        if (updates.updatedGmiMood && this.currentGmiMood !== updates.updatedGmiMood) {
-            // Validate that the mood is a valid GMIMood value
-            const validMoods = Object.values(GMIMood);
-            if (validMoods.includes(updates.updatedGmiMood.toUpperCase())) {
-                this.currentGmiMood = updates.updatedGmiMood.toUpperCase();
-                await this.workingMemory.set('currentGmiMood', this.currentGmiMood);
-                stateChanged = true;
-            }
-        }
-        // User skill level update
-        if (updates.updatedUserSkillLevel &&
-            this.currentUserContext.skillLevel !== updates.updatedUserSkillLevel) {
-            this.currentUserContext.skillLevel = updates.updatedUserSkillLevel;
-            await this.workingMemory.set('currentUserContext', this.currentUserContext);
-            stateChanged = true;
-        }
-        // Task complexity update
-        if (updates.updatedTaskComplexity &&
-            this.currentTaskContext.complexity !== updates.updatedTaskComplexity) {
-            this.currentTaskContext.complexity = updates.updatedTaskComplexity;
-            await this.workingMemory.set('currentTaskContext', this.currentTaskContext);
-            stateChanged = true;
-        }
-        // Memory imprints
-        if (updates.newMemoryImprints && Array.isArray(updates.newMemoryImprints)) {
-            for (const imprint of updates.newMemoryImprints) {
-                if (imprint.key) {
-                    await this.workingMemory.set(imprint.key, imprint.value);
-                }
-            }
-            if (updates.newMemoryImprints.length > 0) {
-                stateChanged = true;
-            }
-        }
-        // Log state change
-        if (stateChanged) {
-            this.addTraceEntry(ReasoningEntryType.STATE_CHANGE, `GMI state updated by metaprompt '${metapromptId}'`, {
-                newMood: this.currentGmiMood,
-                newUserSkill: this.currentUserContext.skillLevel,
-                newTaskComplexity: this.currentTaskContext.complexity,
-                rationale: updates.adjustmentRationale || updates.recoveryStrategy || updates.clarificationStrategy || updates.engagementStrategy || updates.mitigationStrategy,
-            });
-        }
-    }
     /** @inheritdoc */
     async _triggerAndProcessSelfReflection() {
-        // ... (GMI.ts code for _triggerAndProcessSelfReflection provided by user, with my error fixes)
-        // Key fixes to apply within this method based on error list:
-        // - Error 32: Use GMIErrorCode.PARSING_ERROR (ensure it's added to errors.ts)
-        // - Error 33, 34: GMIError.wrap -> createGMIErrorFromError or new GMIError; PROCESSING_ERROR -> GMI_PROCESSING_ERROR
-        // - Error 35: Review logic for `this.state = previousState === ...`
-        // - Error 27 (ModelCompletionOptions.modelId): Fix in getModelAndProviderForLLMCall or here if directly accessed.
-        // - Error 31 (PROVIDER_ERROR): Change to LLM_PROVIDER_ERROR.
-        const reflectionMetaPromptDef = this.activePersona.metaPrompts?.find(mp => mp.id === 'gmi_self_trait_adjustment');
-        if (!reflectionMetaPromptDef?.promptTemplate) {
-            this.addTraceEntry(ReasoningEntryType.SELF_REFLECTION_SKIPPED, "Self-reflection disabled or no 'gmi_self_trait_adjustment' meta-prompt.");
-            return;
-        }
-        if (this.state === GMIPrimeState.REFLECTING) {
-            this.addTraceEntry(ReasoningEntryType.SELF_REFLECTION_SKIPPED, "Self-reflection already in progress.");
-            return;
-        }
-        const previousState = this.state;
-        this.state = GMIPrimeState.REFLECTING;
-        this.addTraceEntry(ReasoningEntryType.SELF_REFLECTION_START, "Starting self-reflection cycle.");
-        try {
-            const evidence = {
-                recentConversation: this.conversationHistory.slice(-10),
-                recentTraceEntries: this.reasoningTrace.entries.slice(-20),
-                currentMood: this.currentGmiMood,
-                currentUserContext: this.currentUserContext,
-                currentTaskContext: this.currentTaskContext,
-            };
-            this.addTraceEntry(ReasoningEntryType.SELF_REFLECTION_DETAIL, "Gathered evidence for reflection.", {
-                conversationSampleCount: evidence.recentConversation.length,
-                traceSampleCount: evidence.recentTraceEntries.length
-            });
-            let metaPromptText = (typeof reflectionMetaPromptDef.promptTemplate === 'string')
-                ? reflectionMetaPromptDef.promptTemplate
-                : reflectionMetaPromptDef.promptTemplate.template;
-            metaPromptText = metaPromptText
-                .replace(/\{\{\s*evidence\s*\}\}/gi, JSON.stringify(evidence).substring(0, 4000) + "...")
-                .replace(/\{\{\s*current_mood\s*\}\}/gi, this.currentGmiMood)
-                .replace(/\{\{\s*user_skill\s*\}\}/gi, this.currentUserContext.skillLevel || "unknown")
-                .replace(/\{\{\s*task_complexity\s*\}\}/gi, this.currentTaskContext.complexity || "unknown");
-            this.addTraceEntry(ReasoningEntryType.SELF_REFLECTION_DETAIL, "Constructed meta-prompt.", { preview: metaPromptText.substring(0, 100) });
-            const { modelId, providerId } = this.getModelAndProviderForLLMCall(reflectionMetaPromptDef.modelId, reflectionMetaPromptDef.providerId, this.activePersona.defaultModelId || this.config.defaultLlmModelId, this.activePersona.defaultProviderId || this.config.defaultLlmProviderId);
-            const provider = this.llmProviderManager.getProvider(providerId);
-            if (!provider) {
-                throw new GMIError(`Provider '${providerId}' not found for self-reflection.`, GMIErrorCode.LLM_PROVIDER_UNAVAILABLE);
-            }
-            // Using generateCompletion as generate is often for older text completion models
-            const llmResponse = await provider.generateCompletion(modelId, [{ role: 'user', content: metaPromptText }], {
-                maxTokens: reflectionMetaPromptDef.maxOutputTokens || 512,
-                temperature: reflectionMetaPromptDef.temperature || 0.3,
-                responseFormat: { type: "json_object" } // Request JSON output
-            });
-            const responseContent = llmResponse.choices?.[0]?.message?.content;
-            if (!responseContent || typeof responseContent !== 'string') {
-                throw new GMIError("Self-reflection LLM call returned no valid content.", GMIErrorCode.LLM_PROVIDER_ERROR, { response: llmResponse });
-            }
-            this.addTraceEntry(ReasoningEntryType.SELF_REFLECTION_DETAIL, "LLM response for reflection received.", { preview: responseContent.substring(0, 100) });
-            const parseOptions = {
-                attemptFixWithLLM: true,
-                llmModelIdForFix: reflectionMetaPromptDef.modelId || modelId,
-                llmProviderIdForFix: reflectionMetaPromptDef.providerId || providerId,
-            };
-            const parsedUpdates = await this.utilityAI.parseJsonSafe(responseContent, parseOptions);
-            if (!parsedUpdates) {
-                throw new GMIError("Failed to parse/fix JSON from self-reflection LLM.", GMIErrorCode.PARSING_ERROR, { responseText: responseContent });
-            }
-            this.addTraceEntry(ReasoningEntryType.SELF_REFLECTION_DETAIL, "Parsed trait update suggestions.", { suggestions: parsedUpdates });
-            let stateChanged = false;
-            // ... (Apply updates as in the original GMI.ts code, ensuring null checks if needed)
-            if (parsedUpdates.updatedGmiMood && Object.values(GMIMood).includes(parsedUpdates.updatedGmiMood) && this.currentGmiMood !== parsedUpdates.updatedGmiMood) {
-                this.currentGmiMood = parsedUpdates.updatedGmiMood;
-                await this.workingMemory.set('currentGmiMood', this.currentGmiMood);
-                stateChanged = true;
-            }
-            if (parsedUpdates.updatedUserSkillLevel && this.currentUserContext.skillLevel !== parsedUpdates.updatedUserSkillLevel) {
-                this.currentUserContext.skillLevel = parsedUpdates.updatedUserSkillLevel;
-                await this.workingMemory.set('currentUserContext', this.currentUserContext);
-                stateChanged = true;
-            }
-            if (parsedUpdates.updatedTaskComplexity && this.currentTaskContext.complexity !== parsedUpdates.updatedTaskComplexity) {
-                this.currentTaskContext.complexity = parsedUpdates.updatedTaskComplexity;
-                await this.workingMemory.set('currentTaskContext', this.currentTaskContext);
-                stateChanged = true;
-            }
-            if (parsedUpdates.newMemoryImprints && parsedUpdates.newMemoryImprints.length > 0) {
-                for (const imprint of parsedUpdates.newMemoryImprints) {
-                    if (imprint.key)
-                        await this.workingMemory.set(imprint.key, imprint.value);
-                }
-                stateChanged = true;
-                this.addTraceEntry(ReasoningEntryType.STATE_CHANGE, "New memory imprints added from self-reflection.", { imprints: parsedUpdates.newMemoryImprints.map(i => i.key) });
-            }
-            if (stateChanged) {
-                this.addTraceEntry(ReasoningEntryType.STATE_CHANGE, "GMI state updated via self-reflection.", {
-                    newMood: this.currentGmiMood, newUserSkill: this.currentUserContext.skillLevel, newTaskComplexity: this.currentTaskContext.complexity,
-                    rationale: parsedUpdates.adjustmentRationale
-                });
-            }
-            else {
-                this.addTraceEntry(ReasoningEntryType.SELF_REFLECTION_DETAIL, "No state changes applied from self-reflection.", { rationale: parsedUpdates.adjustmentRationale });
-            }
-        }
-        catch (error) {
-            const gmiError = createGMIErrorFromError(error, GMIErrorCode.GMI_PROCESSING_ERROR, undefined, `Error during self-reflection.`);
-            this.addTraceEntry(ReasoningEntryType.ERROR, `Self-reflection failed: ${gmiError.message}`, gmiError.toPlainObject());
-            console.error(`GMI (ID: ${this.gmiId}) self-reflection error:`, gmiError);
-        }
-        finally {
-            // Or, if specific state is needed, previousState should be one of the valid non-reflecting states.
-            const disallowedStates = new Set([GMIPrimeState.IDLE, GMIPrimeState.INITIALIZING]);
-            this.state = disallowedStates.has(previousState) ? GMIPrimeState.READY : previousState;
-            this.addTraceEntry(ReasoningEntryType.SELF_REFLECTION_COMPLETE, "Self-reflection cycle finished.");
-        }
+        await this.metapromptExecutor.triggerAndProcessSelfReflection();
     }
     /**
      * Helper to determine model and provider for internal LLM calls.