@memberjunction/ng-conversations 2.104.0 → 2.105.0

package/dist/lib/components/message/message-input.component.js

@@ -1,18 +1,19 @@
 import { Component, Input, Output, EventEmitter, ViewChild } from '@angular/core';
 import { Metadata, RunView } from '@memberjunction/core';
-import { GraphQLAIClient } from '@memberjunction/graphql-dataprovider';
+import { GraphQLDataProvider, GraphQLAIClient } from '@memberjunction/graphql-dataprovider';
 import { AIEngineBase } from '@memberjunction/ai-engine-base';
 import * as i0 from "@angular/core";
 import * as i1 from "../../services/dialog.service";
 import * as i2 from "../../services/toast.service";
 import * as i3 from "../../services/conversation-agent.service";
 import * as i4 from "../../services/conversation-state.service";
-import * as i5 from "../../services/active-tasks.service";
-import * as i6 from "../../services/mention-autocomplete.service";
-import * as i7 from "../../services/mention-parser.service";
-import * as i8 from "@angular/common";
-import * as i9 from "@angular/forms";
-import * as i10 from "../mention/mention-dropdown.component";
+import * as i5 from "../../services/data-cache.service";
+import * as i6 from "../../services/active-tasks.service";
+import * as i7 from "../../services/mention-autocomplete.service";
+import * as i8 from "../../services/mention-parser.service";
+import * as i9 from "@angular/common";
+import * as i10 from "@angular/forms";
+import * as i11 from "../mention/mention-dropdown.component";
 const _c0 = ["messageTextarea"];
 function MessageInputComponent_div_6_Template(rf, ctx) { if (rf & 1) {
     i0.ɵɵelementStart(0, "div", 10);
@@ -26,9 +27,12 @@ export class MessageInputComponent {
     toastService;
     agentService;
     conversationState;
+    dataCache;
     activeTasks;
     mentionAutocomplete;
     mentionParser;
+    // Default artifact type ID for JSON (when agent doesn't specify DefaultArtifactTypeID)
+    JSON_ARTIFACT_TYPE_ID = 'ae674c7e-ea0d-49ea-89e4-0649f5eb20d4';
     conversationId;
     currentUser;
     disabled = false;
@@ -52,11 +56,16 @@ export class MessageInputComponent {
     mentionDropdownShowAbove = false; // Controls transform direction
     mentionStartIndex = -1;
     mentionQuery = '';
-    constructor(dialogService, toastService, agentService, conversationState, activeTasks, mentionAutocomplete, mentionParser) {
+    // PubSub subscription for task progress updates
+    pushStatusSubscription;
+    // Track active task execution message IDs for real-time updates
+    activeTaskExecutionMessageIds = new Set();
+    constructor(dialogService, toastService, agentService, conversationState, dataCache, activeTasks, mentionAutocomplete, mentionParser) {
         this.dialogService = dialogService;
         this.toastService = toastService;
         this.agentService = agentService;
         this.conversationState = conversationState;
+        this.dataCache = dataCache;
         this.activeTasks = activeTasks;
         this.mentionAutocomplete = mentionAutocomplete;
         this.mentionParser = mentionParser;
@@ -65,6 +74,96 @@ export class MessageInputComponent {
         this.converationManagerAgent = await this.agentService.getConversationManagerAgent();
         // Initialize mention autocomplete
         await this.mentionAutocomplete.initialize(this.currentUser);
+        // Subscribe to PubSub for task progress updates
+        this.subscribeToPushStatus();
+    }
+    ngOnDestroy() {
+        // Clean up PubSub subscription
+        if (this.pushStatusSubscription) {
+            this.pushStatusSubscription.unsubscribe();
+        }
+    }
+    /**
+     * Subscribe to PubSub for real-time task orchestration progress updates
+     */
+    subscribeToPushStatus() {
+        const dataProvider = GraphQLDataProvider.Instance;
+        this.pushStatusSubscription = dataProvider.PushStatusUpdates().subscribe((status) => {
+            if (!status || !status.message)
+                return;
+            try {
+                const statusObj = JSON.parse(status.message);
+                // Filter for TaskOrchestrator messages
+                if (statusObj.resolver === 'TaskOrchestrator') {
+                    this.handleTaskProgress(statusObj);
+                }
+            }
+            catch (error) {
+                console.error('Error parsing push status update:', error);
+            }
+        });
+    }
+    /**
+     * Handle task progress updates from PubSub
+     */
+    async handleTaskProgress(statusObj) {
+        if (statusObj.type === 'TaskProgress') {
+            // High-level task progress
+            const { taskName, message, percentComplete } = statusObj.data;
+            console.log(`[Task Progress] ${taskName}: ${message} (${percentComplete}%)`);
+            // Update any active task execution messages
+            await this.updateTaskExecutionMessages(taskName, message, percentComplete);
+        }
+        else if (statusObj.type === 'AgentProgress') {
+            // Detailed agent progress (shown as smaller sub-text)
+            const { taskName, agentStep, agentMessage } = statusObj.data;
+            console.log(`[Agent Progress] ${taskName} → ${agentStep}: ${agentMessage}`);
+            // Update with agent details
+            await this.updateTaskExecutionMessages(taskName, `${agentStep}: ${agentMessage}`, undefined, true);
+        }
+    }
+    /**
+     * Update task execution messages in real-time based on progress updates
+     */
+    async updateTaskExecutionMessages(taskName, progressMessage, percentComplete, isAgentDetail = false) {
+        // Update all active task execution messages using the cache
+        for (const messageId of this.activeTaskExecutionMessageIds) {
+            try {
+                // Get message from cache (single source of truth)
+                const message = await this.dataCache.getConversationDetail(messageId, this.currentUser);
+                if (!message) {
+                    console.warn(`Task execution message ${messageId} not found in cache`);
+                    continue;
+                }
+                // Skip if already complete
+                if (message.Status === 'Complete' || message.Status === 'Error') {
+                    continue;
+                }
+                // Build progress message
+                let updatedMessage = message.Message || '';
+                if (isAgentDetail) {
+                    // Agent details shown as sub-text
+                    updatedMessage = `⏳ **${taskName}**\n\n_${progressMessage}_`;
+                }
+                else if (percentComplete != null) {
+                    updatedMessage = `⏳ **${taskName}** (${percentComplete}%)\n\n${progressMessage}`;
+                }
+                else {
+                    updatedMessage = `⏳ **${taskName}**\n\n${progressMessage}`;
+                }
+                message.Message = updatedMessage;
+                // Use safe save to prevent race conditions with completion
+                const saved = await this.safeSaveConversationDetail(message, `TaskProgress:${taskName}`);
+                if (saved) {
+                    this.messageSent.emit(message);
+                    // Also update the ActiveTasksService to keep the tasks dropdown in sync
+                    this.activeTasks.updateStatusByConversationDetailId(message.ID, progressMessage);
+                }
+            }
+            catch (error) {
+                console.error('Error updating task execution message:', error);
+            }
+        }
     }
     get canSend() {
         return !this.disabled && !this.isSending && this.messageText.trim().length > 0;
@@ -199,8 +298,7 @@ export class MessageInputComponent {
             return;
         this.isSending = true;
         try {
-            const md = new Metadata();
-            const detail = await md.GetEntityObject('Conversation Details', this.currentUser);
+            const detail = await this.dataCache.createConversationDetail(this.currentUser);
             detail.ConversationID = this.conversationId;
             detail.Message = this.messageText.trim();
             detail.Role = 'User';
@@ -219,10 +317,10 @@ export class MessageInputComponent {
                 this.messageText = '';
                 // Check if this is the first message in the conversation
                 const isFirstMessage = this.conversationHistory.length === 0;
-                // Determine routing: @mention > last agent context > Conversation Manager
+                // Determine routing: @mention > last agent context > Sage
                 if (mentionResult.agentMention) {
-                    // Direct @mention - skip Conversation Manager, invoke agent directly
-                    console.log('🎯 Direct @mention detected, bypassing Conversation Manager');
+                    // Direct @mention - skip Sage, invoke agent directly
+                    console.log('🎯 Direct @mention detected, bypassing Sage');
                     if (isFirstMessage) {
                         Promise.all([
                             this.invokeAgentDirectly(detail, mentionResult.agentMention, this.conversationId),
@@ -242,7 +340,7 @@ export class MessageInputComponent {
                         msg.AgentID &&
                         msg.AgentID !== this.converationManagerAgent?.ID);
                     if (lastAIMessage && lastAIMessage.AgentID) {
-                        // Continue with same agent - skip Conversation Manager
+                        // Continue with same agent - skip Sage
                         console.log('🔄 Implicit continuation detected, continuing with last agent');
                         if (isFirstMessage) {
                             Promise.all([
@@ -255,8 +353,8 @@ export class MessageInputComponent {
                         }
                     }
                     else {
-                        // No context - use Conversation Manager
-                        console.log('🤖 No agent context, using Conversation Manager');
+                        // No context - use Sage
+                        console.log('🤖 No agent context, using Sage');
                         if (isFirstMessage) {
                             Promise.all([
                                 this.processMessageThroughAgent(detail, mentionResult),
@@ -288,56 +386,61 @@ export class MessageInputComponent {
             this.isSending = false;
         }
     }
+    /**
+     * Safe save for ConversationDetail - prevents overwrites of completed/errored messages
+     * Use this ONLY in progress update paths to prevent race conditions
+     * @param detail The conversation detail to save
+     * @param context Description of who is saving (for logging)
+     * @returns true if saved, false if blocked
+     */
+    async safeSaveConversationDetail(detail, context) {
+        // Never modify completed or errored messages
+        if (detail.Status === 'Complete' || detail.Status === 'Error') {
+            console.log(`[${context}] 🛡️ Blocked save - message is ${detail.Status}`);
+            return false;
+        }
+        await detail.Save();
+        return true;
+    }
     /**
      * Create a progress callback for agent execution
      * This callback updates both the active task and the ConversationDetail message
      * IMPORTANT: Filters by agentRunId to prevent cross-contamination when multiple agents run in parallel
      */
-    createProgressCallback(conversationDetailId, agentName) {
+    createProgressCallback(conversationDetail, agentName) {
         return async (progress) => {
             // Extract agentRunId from progress metadata
             const progressAgentRunId = progress.metadata?.agentRunId;
             // Format progress message with visual indicator
             const progressText = progress.message;
             // Update the active task with progress details (if it exists)
-            this.activeTasks.updateStatusByConversationDetailId(conversationDetailId, progressText);
+            this.activeTasks.updateStatusByConversationDetailId(conversationDetail.ID, progressText);
             // Update the ConversationDetail message in real-time
             try {
-                const md = new Metadata();
-                const conversationDetail = await md.GetEntityObject('Conversation Details', this.currentUser);
-                if (await conversationDetail.Load(conversationDetailId)) {
+                if (conversationDetail) {
+                    console.log(`[${agentName}] Got conversation detail from cache - Status: ${conversationDetail.Status}, ID: ${conversationDetail.ID}`);
                     // Skip progress updates if message is already complete
+                    // Since we're using the cached instance, this check sees the ACTUAL current state
                     if (conversationDetail.Status === 'Complete') {
-                        console.log(`[${agentName}] Skipping progress update - message already complete`);
+                        console.log(`[${agentName}] ⛔ Skipping progress update - message already complete`);
                         return;
                     }
-                    // CRITICAL: Only update if agentRunIds match (prevents cross-contamination)
-                    const storedAgentRunId = conversationDetail.AgentRunID;
-                    // If AgentRunID not yet set, set it from the first progress update
-                    if (!storedAgentRunId && progressAgentRunId) {
-                        conversationDetail.AgentRunID = progressAgentRunId;
-                        console.log(`[${agentName}] Setting AgentRunID from progress update:`, progressAgentRunId);
-                        // Emit event to parent so it can load the agent run into the map immediately
+                    // Emit agentRunId if we have it (for parent to track)
+                    if (progressAgentRunId) {
                         this.agentRunDetected.emit({
-                            conversationDetailId,
+                            conversationDetailId: conversationDetail.ID,
                             agentRunId: progressAgentRunId
                         });
                     }
-                    // If we have both IDs, verify they match before updating
-                    else if (progressAgentRunId && storedAgentRunId) {
-                        if (progressAgentRunId !== storedAgentRunId) {
-                            console.log(`[${agentName}] Skipping progress update - agentRunId mismatch:`, {
-                                progressAgentRunId,
-                                storedAgentRunId,
-                                conversationDetailId
-                            });
-                            return; // Skip this update - it's for a different agent run
+                    if (conversationDetail.Status === 'In-Progress') {
+                        conversationDetail.Message = progressText;
+                        // Use safe save to prevent race conditions with completion
+                        const saved = await this.safeSaveConversationDetail(conversationDetail, `Progress:${agentName}`);
+                        if (saved) {
+                            // Emit update to trigger UI refresh
+                            this.messageSent.emit(conversationDetail);
                         }
                     }
-                    conversationDetail.Message = progressText;
-                    await conversationDetail.Save();
-                    // Emit update to trigger UI refresh
-                    this.messageSent.emit(conversationDetail);
                 }
             }
             catch (error) {
@@ -345,12 +448,12 @@ export class MessageInputComponent {
             }
             console.log(`[${agentName}] Progress: ${progress.step} - ${progress.message} (${progress.percentage}%)`, {
                 agentRunId: progressAgentRunId,
-                conversationDetailId
+                conversationDetailId: conversationDetail.ID
             });
         };
     }
     /**
-     * Process the message through agents (multi-stage: Conversation Manager -> possible sub-agent)
+     * Process the message through agents (multi-stage: Sage -> possible sub-agent)
      * Only called when there's no @mention and no implicit agent context
      */
     async processMessageThroughAgent(userMessage, mentionResult) {
@@ -360,31 +463,30 @@ export class MessageInputComponent {
         // This prevents race condition when user switches conversations during async processing
         const conversationId = userMessage.ConversationID;
         try {
-            // Create AI message for Conversation Manager BEFORE invoking
-            const md = new Metadata();
-            conversationManagerMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+            // Create AI message for Sage BEFORE invoking
+            conversationManagerMessage = await this.dataCache.createConversationDetail(this.currentUser);
             conversationManagerMessage.ConversationID = conversationId;
             conversationManagerMessage.Role = 'AI';
             conversationManagerMessage.Message = '⏳ Starting...';
             conversationManagerMessage.ParentID = userMessage.ID;
             conversationManagerMessage.Status = 'In-Progress';
             conversationManagerMessage.HiddenToUser = false;
-            // Use the preloaded Conversation Manager agent instead of looking it up
+            // Use the preloaded Sage agent instead of looking it up
             if (this.converationManagerAgent?.ID) {
                 conversationManagerMessage.AgentID = this.converationManagerAgent.ID;
             }
             await conversationManagerMessage.Save();
             this.messageSent.emit(conversationManagerMessage);
-            // Use Conversation Manager to evaluate and route
-            // Stage 1: Conversation Manager evaluates the message
+            // Use Sage to evaluate and route
+            // Stage 1: Sage evaluates the message
             taskId = this.activeTasks.add({
-                agentName: 'Conversation Manager',
+                agentName: 'Sage',
                 status: 'Evaluating message...',
                 relatedMessageId: userMessage.ID,
                 conversationDetailId: conversationManagerMessage.ID
             });
-            const result = await this.agentService.processMessage(conversationId, userMessage, this.conversationHistory, conversationManagerMessage.ID, this.createProgressCallback(conversationManagerMessage.ID, 'Conversation Manager'));
-            // Remove Conversation Manager from active tasks
+            const result = await this.agentService.processMessage(conversationId, userMessage, this.conversationHistory, conversationManagerMessage.ID, this.createProgressCallback(conversationManagerMessage, 'Sage'));
+            // Remove Sage from active tasks
             if (taskId) {
                 this.activeTasks.remove(taskId);
                 taskId = null;
@@ -399,48 +501,79 @@ export class MessageInputComponent {
                 userMessage.Status = 'Complete';
                 await userMessage.Save();
                 this.messageSent.emit(userMessage);
-                console.warn('⚠️ Conversation Manager failed:', result?.agentRun?.ErrorMessage);
+                console.warn('⚠️ Sage failed:', result?.agentRun?.ErrorMessage);
                 return;
             }
-            console.log('🤖 Conversation Manager Response:', {
+            console.log('🤖 Sage Response:', {
                 finalStep: result.agentRun.FinalStep,
                 hasPayload: !!result.payload,
-                hasMessage: !!result.agentRun.Message
+                hasMessage: !!result.agentRun.Message,
+                payloadKeys: result.payload ? Object.keys(result.payload) : [],
+                payload: result.payload // Full payload for debugging
             });
-            // Stage 2: Check for sub-agent invocation
-            if (result.agentRun.FinalStep === 'Success' && result.payload?.invokeAgent) {
+            // Stage 2: Check for task graph (multi-step orchestration)
+            if (result.payload?.taskGraph) {
+                console.log('📋 Task graph detected, starting task orchestration');
+                await this.handleTaskGraphExecution(userMessage, result, this.conversationId, conversationManagerMessage);
+                // Remove CM from active tasks
+                if (taskId) {
+                    this.activeTasks.remove(taskId);
+                }
+            }
+            // Stage 3: Check for sub-agent invocation (single-step delegation)
+            else if (result.agentRun.FinalStep === 'Success' && result.payload?.invokeAgent) {
                 // Reuse the existing conversationManagerMessage instead of creating new ones
                 await this.handleSubAgentInvocation(userMessage, result, this.conversationId, conversationManagerMessage);
+                // Remove CM from active tasks
+                if (taskId) {
+                    this.activeTasks.remove(taskId);
+                }
             }
-            // Stage 3: Direct chat response from Conversation Manager
+            // Stage 4: Direct chat response from Sage
             else if (result.agentRun.FinalStep === 'Chat' && result.agentRun.Message) {
-                // Update the existing message with the response
+                // Normal chat response
                 conversationManagerMessage.Message = result.agentRun.Message;
                 conversationManagerMessage.Status = 'Complete';
-                if (result.agentRun.ID) {
-                    conversationManagerMessage.AgentRunID = result.agentRun.ID;
-                }
                 await conversationManagerMessage.Save();
                 this.messageSent.emit(conversationManagerMessage);
-                // Handle artifacts if any
+                // Handle artifacts if any (but NOT task graphs - those are intermediate work products)
                 if (result.payload && Object.keys(result.payload).length > 0) {
                     await this.createArtifactFromPayload(result.payload, conversationManagerMessage, result.agentRun.AgentID);
-                    console.log('🎨 Artifact created and linked to Conversation Manager message');
+                    console.log('🎨 Artifact created and linked to Sage message');
                     this.messageSent.emit(conversationManagerMessage);
                 }
                 userMessage.Status = 'Complete';
                 await userMessage.Save();
                 this.messageSent.emit(userMessage);
+                // Remove CM from active tasks
+                if (taskId) {
+                    this.activeTasks.remove(taskId);
+                }
             }
-            // Stage 4: Silent observation - check for agent continuity
+            // Stage 5: Silent observation - but check for message content first
             else {
-                console.log('🔇 Conversation Manager chose to observe silently');
-                // Hide the Conversation Manager message
-                conversationManagerMessage.HiddenToUser = true;
-                conversationManagerMessage.Status = 'Complete';
-                await conversationManagerMessage.Save();
-                this.messageSent.emit(conversationManagerMessage);
-                await this.handleSilentObservation(userMessage, this.conversationId);
+                // Check if there's a message to display even without payload/taskGraph
+                if (result.agentRun.Message) {
+                    console.log('💬 Sage provided a message without payload');
+                    conversationManagerMessage.Message = result.agentRun.Message;
+                    conversationManagerMessage.Status = 'Complete';
+                    conversationManagerMessage.HiddenToUser = false;
+                    await conversationManagerMessage.Save();
+                    this.messageSent.emit(conversationManagerMessage);
+                }
+                else {
+                    console.log('🔇 Sage chose to observe silently');
+                    // Hide the Sage message
+                    conversationManagerMessage.HiddenToUser = true;
+                    conversationManagerMessage.Status = 'Complete';
+                    await conversationManagerMessage.Save();
+                    this.messageSent.emit(conversationManagerMessage);
+                    await this.handleSilentObservation(userMessage, this.conversationId);
+                }
+                // Remove CM from active tasks
+                if (taskId) {
+                    this.activeTasks.remove(taskId);
+                }
             }
         }
         catch (error) {
@@ -464,30 +597,243 @@ export class MessageInputComponent {
         }
     }
     /**
-     * Handle sub-agent invocation based on Conversation Manager's payload
+     * Handle task graph execution based on Sage's payload
+     * Creates tasks and orchestrates their execution
+     */
+    async handleTaskGraphExecution(userMessage, managerResult, conversationId, conversationManagerMessage) {
+        const taskGraph = managerResult.payload.taskGraph;
+        const workflowName = taskGraph.workflowName || 'Workflow';
+        const reasoning = taskGraph.reasoning || 'Executing multi-step workflow';
+        const taskCount = taskGraph.tasks?.length || 0;
+        console.log(`📋 Task graph execution requested: ${workflowName}`, {
+            reasoning,
+            taskCount
+        });
+        const md = new Metadata();
+        // Deduplicate tasks by tempId (LLM sometimes returns duplicates)
+        const seenTempIds = new Set();
+        const uniqueTasks = taskGraph.tasks.filter((task) => {
+            if (seenTempIds.has(task.tempId)) {
+                console.warn(`⚠️ Duplicate tempId detected on client, filtering: ${task.tempId} (${task.name})`);
+                return false;
+            }
+            seenTempIds.add(task.tempId);
+            return true;
+        });
+        const uniqueTaskCount = uniqueTasks.length;
+        console.log(`Filtered to ${uniqueTaskCount} unique tasks (${taskCount - uniqueTaskCount} duplicates removed)`);
+        const isSingleTask = uniqueTaskCount === 1;
+        // If single task, use direct agent execution (existing pattern with great PubSub support)
+        if (isSingleTask) {
+            const task = uniqueTasks[0];
+            const agentName = task.agentName;
+            // Update CM message
+            const delegationMessage = `👉 Delegating to **${agentName}**`;
+            await this.updateConversationDetail(conversationManagerMessage, delegationMessage, 'Complete');
+            // Execute single agent directly using existing pattern
+            await this.handleSingleTaskExecution(userMessage, task, agentName, conversationId, conversationManagerMessage);
+            return;
+        }
+        // Multi-step workflow - use server-side task orchestration
+        console.log(`📋 Multi-step workflow detected (${uniqueTaskCount} tasks), using task orchestration`);
+        // Update CM message with task summary (use unique tasks only)
+        const taskSummary = uniqueTasks.map((t) => `• ${t.name}`).join('\n');
+        await this.updateConversationDetail(conversationManagerMessage, `📋 Setting up multi-step workflow...\n\n**${workflowName}**\n${taskSummary}`, 'Complete');
+        // Step 2: Create new ConversationDetail for task execution updates
+        const taskExecutionMessage = await this.dataCache.createConversationDetail(this.currentUser);
+        taskExecutionMessage.ConversationID = conversationId;
+        taskExecutionMessage.Role = 'AI';
+        taskExecutionMessage.Message = '⏳ Starting workflow execution...';
+        taskExecutionMessage.ParentID = conversationManagerMessage.ID; // Thread under delegation message
+        taskExecutionMessage.Status = 'In-Progress';
+        taskExecutionMessage.HiddenToUser = false;
+        // No AgentID for now - this represents the task orchestration system
+        await taskExecutionMessage.Save();
+        this.messageSent.emit(taskExecutionMessage);
+        // Register for real-time updates via PubSub
+        this.activeTaskExecutionMessageIds.add(taskExecutionMessage.ID);
+        try {
+            // Get environment ID from user
+            const environmentId = this.currentUser.EnvironmentID || 'F51358F3-9447-4176-B313-BF8025FD8D09';
+            // Get session ID for PubSub
+            const sessionId = GraphQLDataProvider.Instance.sessionId || '';
+            // Step 3: Call ExecuteTaskGraph mutation (links to taskExecutionMessage)
+            const mutation = `
+        mutation ExecuteTaskGraph($taskGraphJson: String!, $conversationDetailId: String!, $environmentId: String!, $sessionId: String!) {
+          ExecuteTaskGraph(
+            taskGraphJson: $taskGraphJson
+            conversationDetailId: $conversationDetailId
+            environmentId: $environmentId
+            sessionId: $sessionId
+          ) {
+            success
+            errorMessage
+            results {
+              taskId
+              success
+              output
+              error
+            }
+          }
+        }
+      `;
+            const variables = {
+                taskGraphJson: JSON.stringify(taskGraph),
+                conversationDetailId: taskExecutionMessage.ID, // Link tasks to execution message, not CM message
+                environmentId: environmentId,
+                sessionId: sessionId
+            };
+            const result = await GraphQLDataProvider.Instance.ExecuteGQL(mutation, variables);
+            console.log('📊 ExecuteTaskGraph result:', {
+                hasData: !!result?.data,
+                hasErrors: !!result?.errors,
+                data: result?.data,
+                errors: result?.errors
+            });
+            // Step 4: Update task execution message with results
+            // Check for GraphQL errors first
+            if (result?.errors && result.errors.length > 0) {
+                const errorMsg = result.errors.map((e) => e.message).join(', ');
+                console.error('❌ GraphQL errors:', result.errors);
+                taskExecutionMessage.Message = `❌ **${workflowName}** failed: ${errorMsg}`;
+                taskExecutionMessage.Status = 'Error';
+                taskExecutionMessage.Error = errorMsg;
+            }
+            else if (result?.data?.ExecuteTaskGraph?.success) {
+                console.log('✅ Task graph execution completed successfully');
+                taskExecutionMessage.Message = `✅ **${workflowName}** completed successfully`;
+                taskExecutionMessage.Status = 'Complete';
+            }
+            else {
+                const errorMsg = result?.data?.ExecuteTaskGraph?.errorMessage || 'Unknown error';
+                console.error('❌ Task graph execution failed:', errorMsg);
+                taskExecutionMessage.Message = `❌ **${workflowName}** failed: ${errorMsg}`;
+                taskExecutionMessage.Status = 'Error';
+                taskExecutionMessage.Error = errorMsg;
+            }
+            await taskExecutionMessage.Save();
+            this.messageSent.emit(taskExecutionMessage);
+            // Unregister from real-time updates (task complete)
+            this.activeTaskExecutionMessageIds.delete(taskExecutionMessage.ID);
+            // Mark user message as complete
+            userMessage.Status = 'Complete';
+            await userMessage.Save();
+            this.messageSent.emit(userMessage);
+        }
+        catch (error) {
+            console.error('❌ Error executing task graph:', error);
+            taskExecutionMessage.Message = `❌ **${workflowName}** - Error: ${String(error)}`;
+            taskExecutionMessage.Status = 'Error';
+            taskExecutionMessage.Error = String(error);
+            await taskExecutionMessage.Save();
+            this.messageSent.emit(taskExecutionMessage);
+            // Unregister from real-time updates (task failed)
+            this.activeTaskExecutionMessageIds.delete(taskExecutionMessage.ID);
+            userMessage.Status = 'Complete';
+            await userMessage.Save();
+            this.messageSent.emit(userMessage);
+        }
+    }
+    async updateConversationDetail(convoDetail, message, status) {
+        if (convoDetail.Status === 'Complete' || convoDetail.Status === 'Error') {
+            return; // Do not update completed or errored messages
+        }
+        const maxAttempts = 2;
+        let attempts = 0, done = false;
+        while (attempts < maxAttempts && !done) {
+            convoDetail.Message = message;
+            convoDetail.Status = status;
+            await convoDetail.Save();
+            if (convoDetail.Message === message && convoDetail.Status === status) {
+                done = true;
+                this.messageSent.emit(convoDetail);
+            }
+            else {
+                console.warn(`   ⚠️ ConversationDetail update attempt ${attempts + 1} did not persist. ${attempts + 1 < maxAttempts ? 'Retrying...' : 'Giving up.'}`);
+            }
+            attempts++;
+        }
+    }
+    /**
+     * Handle single task execution from task graph using direct agent execution
+     * Uses the existing agent execution pattern with PubSub support
+     */
+    async handleSingleTaskExecution(userMessage, task, // Task definition from taskGraph
+    agentName, conversationId, conversationManagerMessage) {
+        try {
+            // Look up the agent
+            const agent = AIEngineBase.Instance.Agents.find(a => a.Name === agentName);
+            if (!agent) {
+                throw new Error(`Agent not found: ${agentName}`);
+            }
+            // Create AI response message for the agent execution
+            const agentResponseMessage = await this.dataCache.createConversationDetail(this.currentUser);
+            agentResponseMessage.ConversationID = conversationId;
+            agentResponseMessage.Role = 'AI';
+            agentResponseMessage.Message = '⏳ Starting...';
+            agentResponseMessage.ParentID = conversationManagerMessage.ID; // Thread under delegation
+            agentResponseMessage.Status = 'In-Progress';
+            agentResponseMessage.HiddenToUser = false;
+            agentResponseMessage.AgentID = agent.ID;
+            await agentResponseMessage.Save();
+            this.messageSent.emit(agentResponseMessage);
+            // Add to active tasks
+            const newTaskId = this.activeTasks.add({
+                agentName: agentName,
+                status: 'Starting...',
+                relatedMessageId: userMessage.ID,
+                conversationDetailId: agentResponseMessage.ID
+            });
+            // Invoke agent with task's input payload
+            const agentResult = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, task.description || task.name, agentResponseMessage.ID, task.inputPayload, // Pass the task's input payload
+            this.createProgressCallback(agentResponseMessage, agentName));
+            // Remove from active tasks
+            this.activeTasks.remove(newTaskId);
+            if (agentResult && agentResult.success) {
+                // Update message with result
+                await this.updateConversationDetail(agentResponseMessage, agentResult.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete');
+                // Handle artifacts
+                if (agentResult.payload && Object.keys(agentResult.payload).length > 0) {
+                    await this.createArtifactFromPayload(agentResult.payload, agentResponseMessage, agentResult.agentRun.AgentID);
+                    console.log('🎨 Artifact created from single task execution');
+                    this.messageSent.emit(agentResponseMessage);
+                }
+            }
+            else {
+                // Handle failure
+                const errorMsg = agentResult?.agentRun?.ErrorMessage || 'Agent execution failed';
+                agentResponseMessage.Message = `❌ **${agentName}** failed: ${errorMsg}`;
+                agentResponseMessage.Status = 'Error';
+                agentResponseMessage.Error = errorMsg;
+                await agentResponseMessage.Save();
+                this.messageSent.emit(agentResponseMessage);
+            }
+            // Mark user message as complete
+            userMessage.Status = 'Complete';
+            await userMessage.Save();
+            this.messageSent.emit(userMessage);
+        }
+        catch (error) {
+            console.error('❌ Error in single task execution:', error);
+            userMessage.Status = 'Complete';
+            await userMessage.Save();
+            this.messageSent.emit(userMessage);
+        }
+    }
+    /**
+     * Handle sub-agent invocation based on Sage's payload
      * Reuses the existing conversationManagerMessage to avoid creating multiple records
      */
     async handleSubAgentInvocation(userMessage, managerResult, conversationId, conversationManagerMessage) {
         const payload = managerResult.payload;
         const agentName = payload.invokeAgent;
         const reasoning = payload.reasoning || 'Delegating to specialist agent';
-        console.log(`👉 Sub-agent invocation requested: ${agentName}`, { reasoning });
-        // Update the existing Conversation Manager message to show delegation
-        conversationManagerMessage.Message = `👉 **${agentName}** will handle this request...`;
-        conversationManagerMessage.Status = 'Complete';
-        // Keep AgentID as Conversation Manager (already set)
-        if (managerResult.agentRun.ID) {
-            conversationManagerMessage.AgentRunID = managerResult.agentRun.ID;
-        }
-        await conversationManagerMessage.Save();
-        this.messageSent.emit(conversationManagerMessage);
         // Now create a NEW message for the sub-agent execution
         try {
             // Look up the agent to get its ID
             const agent = AIEngineBase.Instance.Agents.find(a => a.Name === agentName);
             // Create AI response message BEFORE invoking agent (for duration tracking)
-            const md = new Metadata();
-            const agentResponseMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+            const agentResponseMessage = await this.dataCache.createConversationDetail(this.currentUser);
             agentResponseMessage.ConversationID = conversationId;
             agentResponseMessage.Role = 'AI';
             agentResponseMessage.Message = '⏳ Starting...'; // Initial message
@@ -510,23 +856,16 @@ export class MessageInputComponent {
             });
             // Invoke the sub-agent with progress callback
             const subResult = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, reasoning, agentResponseMessage.ID, undefined, // no payload for initial invocation
-            this.createProgressCallback(agentResponseMessage.ID, agentName));
+            this.createProgressCallback(agentResponseMessage, agentName));
             // Remove from active tasks
             this.activeTasks.remove(newTaskId);
             if (subResult && subResult.success) {
                 // Update the response message with agent result
-                agentResponseMessage.Message = subResult.agentRun?.Message || `✅ **${agentName}** completed`;
-                agentResponseMessage.Status = 'Complete';
-                // Store the agent ID and AgentRunID for display and tracking
+                // Store the agent ID for display
                 if (subResult.agentRun.AgentID) {
                     agentResponseMessage.AgentID = subResult.agentRun.AgentID;
                 }
-                if (subResult.agentRun.ID) {
-                    agentResponseMessage.AgentRunID = subResult.agentRun.ID;
-                }
-                // Save updates - this sets __mj_UpdatedAt for duration calculation
-                await agentResponseMessage.Save();
-                this.messageSent.emit(agentResponseMessage);
+                await this.updateConversationDetail(agentResponseMessage, subResult.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete');
                 // Handle artifacts from sub-agent if any
                 if (subResult.payload && Object.keys(subResult.payload).length > 0) {
                     await this.createArtifactFromPayload(subResult.payload, agentResponseMessage, subResult.agentRun.AgentID);
@@ -542,30 +881,18 @@ export class MessageInputComponent {
             else {
                 // Sub-agent failed - attempt auto-retry once
                 console.log(`⚠️ ${agentName} failed, attempting auto-retry...`);
-                // Update delegation message to show retry
-                conversationManagerMessage.Message = `👉 **${agentName}** will handle this request...\n\n⚠️ First attempt failed, retrying...`;
-                await conversationManagerMessage.Save();
-                this.messageSent.emit(conversationManagerMessage);
+                await this.updateConversationDetail(conversationManagerMessage, `👉 **${agentName}** will handle this request...\n\n⚠️ First attempt failed, retrying...`, conversationManagerMessage.Status);
                 // Update the existing agentResponseMessage to show retry status
-                agentResponseMessage.Message = 'Retrying...';
-                await agentResponseMessage.Save();
-                this.messageSent.emit(agentResponseMessage);
+                await this.updateConversationDetail(agentResponseMessage, "Retrying...", agentResponseMessage.Status);
                 // Retry the sub-agent
                 const retryResult = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, reasoning, agentResponseMessage.ID, undefined, // no payload for retry
-                this.createProgressCallback(agentResponseMessage.ID, `${agentName} (retry)`));
+                this.createProgressCallback(agentResponseMessage, `${agentName} (retry)`));
                 if (retryResult && retryResult.success) {
                     // Retry succeeded - update the same message
-                    agentResponseMessage.Message = retryResult.agentRun?.Message || `✅ **${agentName}** completed`;
-                    agentResponseMessage.Status = 'Complete';
                     if (retryResult.agentRun.AgentID) {
                         agentResponseMessage.AgentID = retryResult.agentRun.AgentID;
                     }
-                    if (retryResult.agentRun.ID) {
-                        agentResponseMessage.AgentRunID = retryResult.agentRun.ID;
-                    }
-                    // Save updates - maintains original CreatedAt for accurate duration
-                    await agentResponseMessage.Save();
-                    this.messageSent.emit(agentResponseMessage);
+                    await this.updateConversationDetail(agentResponseMessage, retryResult.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete');
                     // Handle artifacts
                     if (retryResult.payload && Object.keys(retryResult.payload).length > 0) {
                         await this.createArtifactFromPayload(retryResult.payload, agentResponseMessage, retryResult.agentRun.AgentID);
@@ -601,11 +928,11 @@ export class MessageInputComponent {
         }
     }
     /**
-     * Handle silent observation - when Conversation Manager stays silent,
+     * Handle silent observation - when Sage stays silent,
      * check if we should continue with the last agent for iterative refinement
      */
     async handleSilentObservation(userMessage, conversationId) {
-        // Find the last AI message (excluding Conversation Manager) in the conversation history
+        // Find the last AI message (excluding Sage) in the conversation history
         const lastAIMessage = this.conversationHistory
             .slice()
             .reverse()
@@ -621,7 +948,6 @@ export class MessageInputComponent {
             return;
         }
         // Load the agent entity to get its name
-        const md = new Metadata();
         const rv = new RunView();
         const agentResult = await rv.RunView({
             EntityName: 'AI Agents',
@@ -645,6 +971,7 @@ export class MessageInputComponent {
             ResultType: 'entity_object'
         }, this.currentUser);
         let previousPayload = null;
+        let previousArtifactInfo = null;
         if (artifactResult.Success && artifactResult.Results && artifactResult.Results.length > 0) {
             // Load the artifact version content
             const junctionRecord = artifactResult.Results[0];
@@ -658,7 +985,12 @@ export class MessageInputComponent {
                 if (version.Content) {
                     try {
                         previousPayload = JSON.parse(version.Content);
-                        console.log('📦 Loaded previous OUTPUT artifact as payload for continuity');
+                        previousArtifactInfo = {
+                            artifactId: version.ArtifactID,
+                            versionId: version.ID,
+                            versionNumber: version.VersionNumber || 1
+                        };
+                        console.log('📦 Loaded previous OUTPUT artifact as payload for continuity', previousArtifactInfo);
                     }
                     catch (error) {
                         console.warn('⚠️ Could not parse previous artifact content:', error);
@@ -667,7 +999,7 @@ export class MessageInputComponent {
             }
         }
         // Create status message showing agent continuity
-        const statusMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+        const statusMessage = await this.dataCache.createConversationDetail(this.currentUser);
         statusMessage.ConversationID = conversationId;
         statusMessage.Role = 'AI';
         statusMessage.Message = `Continuing with **${agentName}** for refinement...`;
@@ -686,12 +1018,12 @@ export class MessageInputComponent {
         });
         try {
             // Invoke the agent with the previous payload
-            const continuityResult = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, 'Continuing previous work based on user feedback', statusMessage.ID, previousPayload, this.createProgressCallback(statusMessage.ID, agentName));
+            const continuityResult = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, 'Continuing previous work based on user feedback', statusMessage.ID, previousPayload, this.createProgressCallback(statusMessage, agentName));
             // Remove from active tasks
             this.activeTasks.remove(taskId);
             if (continuityResult && continuityResult.success) {
                 // Create response message
-                const agentResponseMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+                const agentResponseMessage = await this.dataCache.createConversationDetail(this.currentUser);
                 agentResponseMessage.ConversationID = conversationId;
                 agentResponseMessage.Role = 'AI';
                 agentResponseMessage.Message = continuityResult.agentRun?.Message || `✅ **${agentName}** completed refinement`;
@@ -701,9 +1033,10 @@ export class MessageInputComponent {
                 agentResponseMessage.AgentID = lastAIMessage.AgentID;
                 await agentResponseMessage.Save();
                 this.messageSent.emit(agentResponseMessage);
-                // Handle artifacts from agent if any
+                // Handle artifacts from agent if any - create new version if continuing same agent
                 if (continuityResult.payload && Object.keys(continuityResult.payload).length > 0) {
-                    await this.createArtifactFromPayload(continuityResult.payload, agentResponseMessage, lastAIMessage.AgentID);
+                    await this.createArtifactFromPayload(continuityResult.payload, agentResponseMessage, lastAIMessage.AgentID, previousArtifactInfo // Pass artifact info to create new version
+                    );
                     console.log('🎨 Artifact created from agent continuity');
                     this.messageSent.emit(agentResponseMessage);
                 }
@@ -737,48 +1070,9 @@ export class MessageInputComponent {
             this.messageSent.emit(userMessage);
         }
     }
-    /**
-     * Handle agent response - create AI message from agent result
-     */
-    async handleAgentResponse(userMessage, result, conversationId) {
-        if (!result.agentRun.Message)
-            return;
-        const md = new Metadata();
-        const agentMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
-        agentMessage.ConversationID = conversationId;
-        agentMessage.Message = result.agentRun.Message;
-        agentMessage.Role = 'AI';
-        agentMessage.Status = 'Complete';
-        agentMessage.AgentID = this.converationManagerAgent?.ID || null; // Default to Conversation Manager
-        // Populate denormalized AgentID for fast lookup
-        if (result.agentRun.AgentID) {
-            agentMessage.AgentID = result.agentRun.AgentID;
-            console.log(`✅ Set AgentID=${result.agentRun.AgentID} for message from agent`);
-        }
-        else {
-            console.warn('⚠️ AgentID not found in agentRun result');
-        }
-        const saved = await agentMessage.Save();
-        if (saved) {
-            console.log('💾 Agent response saved');
-            // If agent returned a payload, create an artifact version linked to this message
-            if (result.payload && Object.keys(result.payload).length > 0) {
-                await this.createArtifactFromPayload(result.payload, agentMessage, result.agentRun.AgentID);
-                console.log('🎨 Artifact created and linked to conversation detail:', agentMessage.ID);
-            }
-            this.agentResponse.emit({
-                message: agentMessage,
-                agentResult: result
-            });
-            // Mark user message as complete
-            userMessage.Status = 'Complete';
-            await userMessage.Save();
-            this.messageSent.emit(userMessage);
-        }
-    }
     /**
      * Invoke an agent directly when mentioned with @ symbol
-     * Bypasses Conversation Manager completely - no status messages
+     * Bypasses Sage completely - no status messages
      */
     async invokeAgentDirectly(userMessage, agentMention, conversationId) {
         const agentName = agentMention.name;
@@ -797,8 +1091,7 @@ export class MessageInputComponent {
             // Look up the agent to get its ID
             const agent = AIEngineBase.Instance.Agents.find(a => a.Name === agentName);
             // Create AI response message BEFORE invoking agent (for duration tracking)
-            const md = new Metadata();
-            const agentResponseMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+            const agentResponseMessage = await this.dataCache.createConversationDetail(this.currentUser);
             agentResponseMessage.ConversationID = conversationId;
             agentResponseMessage.Role = 'AI';
             agentResponseMessage.Message = '⏳ Starting...'; // Initial message
@@ -814,22 +1107,14 @@ export class MessageInputComponent {
             this.messageSent.emit(agentResponseMessage);
             // Invoke the agent directly
             const result = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, `User mentioned agent directly with @${agentName}`, agentResponseMessage.ID, undefined, // no payload for direct mention
-            this.createProgressCallback(agentResponseMessage.ID, agentName));
+            this.createProgressCallback(agentResponseMessage, agentName));
             // Remove from active tasks
             this.activeTasks.remove(taskId);
             if (result && result.success) {
-                // Update the response message with agent result
-                agentResponseMessage.Message = result.agentRun?.Message || `✅ **${agentName}** completed`;
-                agentResponseMessage.Status = 'Complete';
                 if (result.agentRun.AgentID) {
                     agentResponseMessage.AgentID = result.agentRun.AgentID;
                 }
-                if (result.agentRun.ID) {
-                    agentResponseMessage.AgentRunID = result.agentRun.ID;
-                }
-                // Save updates - this sets __mj_UpdatedAt for duration calculation
-                await agentResponseMessage.Save();
-                this.messageSent.emit(agentResponseMessage);
+                await this.updateConversationDetail(agentResponseMessage, result.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete');
                 // Handle artifacts
                 if (result.payload && Object.keys(result.payload).length > 0) {
                     await this.createArtifactFromPayload(result.payload, agentResponseMessage, result.agentRun.AgentID);
@@ -842,8 +1127,7 @@ export class MessageInputComponent {
             }
             else {
                 // Agent failed - create error message
-                const md = new Metadata();
-                const errorMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+                const errorMessage = await this.dataCache.createConversationDetail(this.currentUser);
                 errorMessage.ConversationID = conversationId;
                 errorMessage.Role = 'AI';
                 errorMessage.Message = `❌ **@${agentName}** failed\n\n${result?.agentRun?.ErrorMessage || 'Unknown error'}`;
@@ -861,8 +1145,7 @@ export class MessageInputComponent {
         catch (error) {
             console.error(`❌ Error invoking mentioned agent ${agentName}:`, error);
             this.activeTasks.remove(taskId);
-            const md = new Metadata();
-            const errorMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+            const errorMessage = await this.dataCache.createConversationDetail(this.currentUser);
             errorMessage.ConversationID = conversationId;
             errorMessage.Role = 'AI';
             errorMessage.Message = `❌ **@${agentName}** encountered an error\n\n${String(error)}`;
@@ -879,11 +1162,10 @@ export class MessageInputComponent {
     }
     /**
      * Continue with the same agent from previous message (implicit continuation)
-     * Bypasses Conversation Manager - no status messages
+     * Bypasses Sage - no status messages
      */
     async continueWithAgent(userMessage, agentId, conversationId) {
         // Load the agent entity to get its name
-        const md = new Metadata();
         const rv = new RunView();
         const agentResult = await rv.RunView({
             EntityName: 'AI Agents',
@@ -891,12 +1173,53 @@ export class MessageInputComponent {
             ResultType: 'entity_object'
         }, this.currentUser);
         if (!agentResult.Success || !agentResult.Results || agentResult.Results.length === 0) {
-            console.warn('⚠️ Could not load agent for continuation - falling back to Conversation Manager');
+            console.warn('⚠️ Could not load agent for continuation - falling back to Sage');
             await this.processMessageThroughAgent(userMessage, { mentions: [], agentMention: null, userMentions: [] });
             return;
         }
         const agent = agentResult.Results[0];
         const agentName = agent.Name || 'Agent';
+        // Find the last AI message from this same agent to get the previous OUTPUT artifact
+        const lastAIMessage = this.conversationHistory
+            .slice()
+            .reverse()
+            .find(msg => msg.Role === 'AI' && msg.AgentID === agentId);
+        let previousPayload = null;
+        let previousArtifactInfo = null;
+        if (lastAIMessage) {
+            // Load the OUTPUT artifact from the last agent message
+            const artifactResult = await rv.RunView({
+                EntityName: 'MJ: Conversation Detail Artifacts',
+                ExtraFilter: `ConversationDetailID='${lastAIMessage.ID}' AND Direction='Output'`,
+                ResultType: 'entity_object'
+            }, this.currentUser);
+            if (artifactResult.Success && artifactResult.Results && artifactResult.Results.length > 0) {
+                // Load the artifact version content
+                const junctionRecord = artifactResult.Results[0];
+                const versionResult = await rv.RunView({
+                    EntityName: 'MJ: Artifact Versions',
+                    ExtraFilter: `ID='${junctionRecord.ArtifactVersionID}'`,
+                    ResultType: 'entity_object'
+                }, this.currentUser);
+                if (versionResult.Success && versionResult.Results && versionResult.Results.length > 0) {
+                    const version = versionResult.Results[0];
+                    if (version.Content) {
+                        try {
+                            previousPayload = JSON.parse(version.Content);
+                            previousArtifactInfo = {
+                                artifactId: version.ArtifactID,
+                                versionId: version.ID,
+                                versionNumber: version.VersionNumber || 1
+                            };
+                            console.log('📦 Loaded previous OUTPUT artifact as payload for continuation', previousArtifactInfo);
+                        }
+                        catch (error) {
+                            console.warn('⚠️ Could not parse previous artifact content:', error);
+                        }
+                    }
+                }
+            }
+        }
         // Add agent to active tasks
         const taskId = this.activeTasks.add({
             agentName: agentName,
@@ -910,7 +1233,7 @@ export class MessageInputComponent {
             await userMessage.Save();
             this.messageSent.emit(userMessage);
             // Create AI response message BEFORE invoking agent (for duration tracking)
-            const agentResponseMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+            const agentResponseMessage = await this.dataCache.createConversationDetail(this.currentUser);
             agentResponseMessage.ConversationID = conversationId;
             agentResponseMessage.Role = 'AI';
             agentResponseMessage.Message = '⏳ Starting...'; // Initial message
@@ -921,24 +1244,18 @@ export class MessageInputComponent {
             // Save the record to establish __mj_CreatedAt timestamp
             await agentResponseMessage.Save();
             this.messageSent.emit(agentResponseMessage);
-            // Invoke the agent directly (continuation)
-            const result = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, 'Continuing previous conversation with user', agentResponseMessage.ID, undefined, // no payload for continuation
-            this.createProgressCallback(agentResponseMessage.ID, agentName));
+            // Invoke the agent directly (continuation) with previous payload if available
+            const result = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, 'Continuing previous conversation with user', agentResponseMessage.ID, previousPayload, // Pass previous OUTPUT artifact payload for continuity
+            this.createProgressCallback(agentResponseMessage, agentName));
             // Remove from active tasks
             this.activeTasks.remove(taskId);
             if (result && result.success) {
                 // Update the response message with agent result
-                agentResponseMessage.Message = result.agentRun?.Message || `✅ **${agentName}** completed`;
-                agentResponseMessage.Status = 'Complete';
-                if (result.agentRun.ID) {
-                    agentResponseMessage.AgentRunID = result.agentRun.ID;
-                }
-                // Save updates - this sets __mj_UpdatedAt for duration calculation
-                await agentResponseMessage.Save();
-                this.messageSent.emit(agentResponseMessage);
-                // Handle artifacts
+                await this.updateConversationDetail(agentResponseMessage, result.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete');
+                // Handle artifacts - create new version if continuing with same agent and artifact
                 if (result.payload && Object.keys(result.payload).length > 0) {
-                    await this.createArtifactFromPayload(result.payload, agentResponseMessage, agentId);
+                    await this.createArtifactFromPayload(result.payload, agentResponseMessage, agentId, previousArtifactInfo // Pass artifact info to create new version instead of new artifact
+                    );
                     this.messageSent.emit(agentResponseMessage);
                 }
                 // Mark user message as complete
@@ -948,7 +1265,7 @@ export class MessageInputComponent {
             }
             else {
                 // Agent failed - create error message
-                const errorMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+                const errorMessage = await this.dataCache.createConversationDetail(this.currentUser);
                 errorMessage.ConversationID = conversationId;
                 errorMessage.Role = 'AI';
                 errorMessage.Message = `❌ **${agentName}** failed\n\n${result?.agentRun?.ErrorMessage || 'Unknown error'}`;
@@ -966,7 +1283,7 @@ export class MessageInputComponent {
         catch (error) {
             console.error(`❌ Error continuing with agent ${agentName}:`, error);
             this.activeTasks.remove(taskId);
-            const errorMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+            const errorMessage = await this.dataCache.createConversationDetail(this.currentUser);
             errorMessage.ConversationID = conversationId;
             errorMessage.Role = 'AI';
             errorMessage.Message = `❌ **${agentName}** encountered an error\n\n${String(error)}`;
@@ -983,34 +1300,52 @@ export class MessageInputComponent {
     }
     /**
      * Creates an artifact from an agent's payload and links it to the conversation detail
+     * If previousArtifactInfo is provided, creates a new version of the existing artifact
+     * Otherwise, creates a new artifact with version 1
      * @param payload The agent's payload object
      * @param message The conversation detail message to link to
      * @param agentId The ID of the agent that produced the payload
+     * @param previousArtifactInfo Optional info about previous artifact to create new version
      */
-    async createArtifactFromPayload(payload, message, agentId) {
+    async createArtifactFromPayload(payload, message, agentId, previousArtifactInfo) {
         try {
             const md = new Metadata();
-            // Create Artifact header
-            const artifact = await md.GetEntityObject('MJ: Artifacts', this.currentUser);
-            // Generate artifact name based on agent name and timestamp
-            const agentName = agentId
-                ? AIEngineBase.Instance?.Agents?.find(a => a.ID === agentId)?.Name || 'Agent'
-                : 'Agent';
-            artifact.Name = `${agentName} Payload - ${new Date().toLocaleString()}`;
-            artifact.Description = `Payload returned by ${agentName}`;
-            // Use JSON artifact type (hardcoded ID from migration)
-            artifact.TypeID = 'ae674c7e-ea0d-49ea-89e4-0649f5eb20d4'; // JSON type
-            artifact.UserID = this.currentUser.ID;
-            artifact.EnvironmentID = this.currentUser.EnvironmentID || 'F51358F3-9447-4176-B313-BF8025FD8D09';
-            const artifactSaved = await artifact.Save();
-            if (!artifactSaved) {
-                console.error('Failed to save artifact');
-                return;
+            let artifactId;
+            let newVersionNumber;
+            // If we have previous artifact info, we're creating a new version of existing artifact
+            if (previousArtifactInfo) {
+                artifactId = previousArtifactInfo.artifactId;
+                newVersionNumber = previousArtifactInfo.versionNumber + 1;
+                console.log(`📦 Creating version ${newVersionNumber} of existing artifact ${artifactId}`);
+            }
+            else {
+                // Create new Artifact header
+                const artifact = await md.GetEntityObject('MJ: Artifacts', this.currentUser);
+                // Look up agent to get name and default artifact type
+                const agent = agentId
+                    ? AIEngineBase.Instance?.Agents?.find(a => a.ID === agentId)
+                    : null;
+                const agentName = agent?.Name || 'Agent';
+                artifact.Name = `${agentName} Payload - ${new Date().toLocaleString()}`;
+                artifact.Description = `Payload returned by ${agentName}`;
+                // Use agent's DefaultArtifactTypeID if available, otherwise fall back to JSON
+                const defaultArtifactTypeId = agent?.DefaultArtifactTypeID;
+                artifact.TypeID = defaultArtifactTypeId || this.JSON_ARTIFACT_TYPE_ID;
+                artifact.UserID = this.currentUser.ID;
+                artifact.EnvironmentID = this.currentUser.EnvironmentID || 'F51358F3-9447-4176-B313-BF8025FD8D09';
+                const artifactSaved = await artifact.Save();
+                if (!artifactSaved) {
+                    console.error('Failed to save artifact');
+                    return;
+                }
+                artifactId = artifact.ID;
+                newVersionNumber = 1;
+                console.log(`📦 Creating new artifact ${artifactId} with version 1`);
             }
             // Create Artifact Version with content
             const version = await md.GetEntityObject('MJ: Artifact Versions', this.currentUser);
-            version.ArtifactID = artifact.ID;
-            version.VersionNumber = 1;
+            version.ArtifactID = artifactId;
+            version.VersionNumber = newVersionNumber;
             version.Content = JSON.stringify(payload, null, 2);
             version.UserID = this.currentUser.ID;
             const versionSaved = await version.Save();
@@ -1027,7 +1362,30 @@ export class MessageInputComponent {
             if (!junctionSaved) {
                 console.error('Failed to create artifact-message association');
             }
-            this.artifactCreated.emit({ artifactId: artifact.ID, versionId: version.ID, conversationDetailId: message.ID, name: artifact.Name });
+            // Emit with artifact name (load from DB if versioning existing artifact)
+            let artifactName;
+            if (previousArtifactInfo) {
+                const artifactEntity = await md.GetEntityObject('MJ: Artifacts', this.currentUser);
+                if (await artifactEntity.Load(artifactId)) {
+                    artifactName = artifactEntity.Name || 'Artifact';
+                }
+                else {
+                    artifactName = 'Artifact';
+                }
+            }
+            else {
+                const agentName = agentId
+                    ? AIEngineBase.Instance?.Agents?.find(a => a.ID === agentId)?.Name || 'Agent'
+                    : 'Agent';
+                artifactName = `${agentName} Payload - ${new Date().toLocaleString()}`;
+            }
+            this.artifactCreated.emit({
+                artifactId,
+                versionId: version.ID,
+                versionNumber: newVersionNumber,
+                conversationDetailId: message.ID,
+                name: artifactName
+            });
         }
         catch (error) {
             console.error('Error creating artifact from payload:', error);
@@ -1087,7 +1445,7 @@ export class MessageInputComponent {
             // Don't show error to user - naming failures should be silent
         }
     }
-    static ɵfac = function MessageInputComponent_Factory(t) { return new (t || MessageInputComponent)(i0.ɵɵdirectiveInject(i1.DialogService), i0.ɵɵdirectiveInject(i2.ToastService), i0.ɵɵdirectiveInject(i3.ConversationAgentService), i0.ɵɵdirectiveInject(i4.ConversationStateService), i0.ɵɵdirectiveInject(i5.ActiveTasksService), i0.ɵɵdirectiveInject(i6.MentionAutocompleteService), i0.ɵɵdirectiveInject(i7.MentionParserService)); };
+    static ɵfac = function MessageInputComponent_Factory(t) { return new (t || MessageInputComponent)(i0.ɵɵdirectiveInject(i1.DialogService), i0.ɵɵdirectiveInject(i2.ToastService), i0.ɵɵdirectiveInject(i3.ConversationAgentService), i0.ɵɵdirectiveInject(i4.ConversationStateService), i0.ɵɵdirectiveInject(i5.DataCacheService), i0.ɵɵdirectiveInject(i6.ActiveTasksService), i0.ɵɵdirectiveInject(i7.MentionAutocompleteService), i0.ɵɵdirectiveInject(i8.MentionParserService)); };
     static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: MessageInputComponent, selectors: [["mj-message-input"]], viewQuery: function MessageInputComponent_Query(rf, ctx) { if (rf & 1) {
             i0.ɵɵviewQuery(_c0, 5);
         } if (rf & 2) {
@@ -1124,12 +1482,12 @@ export class MessageInputComponent {
             i0.ɵɵproperty("disabled", ctx.disabled);
             i0.ɵɵadvance(2);
             i0.ɵɵproperty("disabled", !ctx.canSend)("title", ctx.isSending ? "Sending..." : "Send message");
-        } }, dependencies: [i8.NgIf, i9.DefaultValueAccessor, i9.NgControlStatus, i9.NgModel, i10.MentionDropdownComponent], styles: [".message-input-container[_ngcontent-%COMP%] {\n  position: relative;\n  padding: 16px 24px;\n  border-top: 1px solid #D9D9D9;\n  background: #FFF;\n}\n\n.message-input-wrapper[_ngcontent-%COMP%] {\n  border: 2px solid #D9D9D9;\n  border-radius: 8px;\n  padding: 12px;\n  transition: border-color 0.2s, box-shadow 0.2s;\n  background: #FFF;\n}\n\n.message-input-wrapper[_ngcontent-%COMP%]:focus-within {\n  border-color: #0076B6;\n  box-shadow: 0 0 0 3px rgba(0, 118, 182, 0.1);\n}\n\n.message-input[_ngcontent-%COMP%] {\n  width: 100%;\n  padding: 0;\n  border: none;\n  resize: none;\n  font-family: inherit;\n  font-size: 14px;\n  min-height: 40px;\n  max-height: 200px;\n  line-height: 1.5;\n}\n\n.message-input[_ngcontent-%COMP%]:focus {\n  outline: none;\n}\n\n.message-input[_ngcontent-%COMP%]:disabled {\n  background: #F4F4F4;\n  cursor: not-allowed;\n}\n.input-actions[_ngcontent-%COMP%] {\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  margin-top: 12px;\n}\n.btn-attach[_ngcontent-%COMP%] {\n  padding: 8px 16px;\n  background: transparent;\n  border: 1px solid #D9D9D9;\n  border-radius: 6px;\n  cursor: pointer;\n  color: #333;\n  display: flex;\n  align-items: center;\n  gap: 6px;\n}\n.btn-attach[_ngcontent-%COMP%]:hover:not(:disabled) {\n  background: #F4F4F4;\n  border-color: #AAA;\n}\n.btn-attach[_ngcontent-%COMP%]:disabled {\n  opacity: 0.5;\n  cursor: not-allowed;\n}\n.btn-send[_ngcontent-%COMP%] {\n  width: 40px;\n  height: 40px;\n  background: #3B82F6;\n  color: white;\n  border: none;\n  border-radius: 8px;\n  cursor: pointer;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  transition: background 0.2s;\n  flex-shrink: 0;\n}\n.btn-send[_ngcontent-%COMP%]:hover:not(:disabled) {\n  background: #2563EB;\n}\n.btn-send[_ngcontent-%COMP%]:disabled {\n  background: #D9D9D9;\n  color: #AAA;\n  cursor: not-allowed;\n}\n.btn-send[_ngcontent-%COMP%]   i[_ngcontent-%COMP%] {\n  font-size: 16px;\n}\n.processing-indicator[_ngcontent-%COMP%] {\n  display: flex;\n  align-items: center;\n  gap: 8px;\n  font-size: 13px;\n  color: #6B7280;\n  margin-right: auto;\n}\n.processing-indicator[_ngcontent-%COMP%]   i[_ngcontent-%COMP%] {\n  color: #0076B6;\n}"] });
+        } }, dependencies: [i9.NgIf, i10.DefaultValueAccessor, i10.NgControlStatus, i10.NgModel, i11.MentionDropdownComponent], styles: [".message-input-container[_ngcontent-%COMP%] {\n  position: relative;\n  padding: 16px 24px;\n  border-top: 1px solid #D9D9D9;\n  background: #FFF;\n}\n\n.message-input-wrapper[_ngcontent-%COMP%] {\n  border: 2px solid #D9D9D9;\n  border-radius: 8px;\n  padding: 12px;\n  transition: border-color 0.2s, box-shadow 0.2s;\n  background: #FFF;\n}\n\n.message-input-wrapper[_ngcontent-%COMP%]:focus-within {\n  border-color: #0076B6;\n  box-shadow: 0 0 0 3px rgba(0, 118, 182, 0.1);\n}\n\n.message-input[_ngcontent-%COMP%] {\n  width: 100%;\n  padding: 0;\n  border: none;\n  resize: none;\n  font-family: inherit;\n  font-size: 14px;\n  min-height: 40px;\n  max-height: 200px;\n  line-height: 1.5;\n}\n\n.message-input[_ngcontent-%COMP%]:focus {\n  outline: none;\n}\n\n.message-input[_ngcontent-%COMP%]:disabled {\n  background: #F4F4F4;\n  cursor: not-allowed;\n}\n.input-actions[_ngcontent-%COMP%] {\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  margin-top: 12px;\n}\n.btn-attach[_ngcontent-%COMP%] {\n  padding: 8px 16px;\n  background: transparent;\n  border: 1px solid #D9D9D9;\n  border-radius: 6px;\n  cursor: pointer;\n  color: #333;\n  display: flex;\n  align-items: center;\n  gap: 6px;\n}\n.btn-attach[_ngcontent-%COMP%]:hover:not(:disabled) {\n  background: #F4F4F4;\n  border-color: #AAA;\n}\n.btn-attach[_ngcontent-%COMP%]:disabled {\n  opacity: 0.5;\n  cursor: not-allowed;\n}\n.btn-send[_ngcontent-%COMP%] {\n  width: 40px;\n  height: 40px;\n  background: #3B82F6;\n  color: white;\n  border: none;\n  border-radius: 8px;\n  cursor: pointer;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  transition: background 0.2s;\n  flex-shrink: 0;\n}\n.btn-send[_ngcontent-%COMP%]:hover:not(:disabled) {\n  background: #2563EB;\n}\n.btn-send[_ngcontent-%COMP%]:disabled {\n  background: #D9D9D9;\n  color: #AAA;\n  cursor: not-allowed;\n}\n.btn-send[_ngcontent-%COMP%]   i[_ngcontent-%COMP%] {\n  font-size: 16px;\n}\n.processing-indicator[_ngcontent-%COMP%] {\n  display: flex;\n  align-items: center;\n  gap: 8px;\n  font-size: 13px;\n  color: #6B7280;\n  margin-right: auto;\n}\n.processing-indicator[_ngcontent-%COMP%]   i[_ngcontent-%COMP%] {\n  color: #0076B6;\n}"] });
 }
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MessageInputComponent, [{
         type: Component,
         args: [{ selector: 'mj-message-input', template: "<div class=\"message-input-container\">\n  <textarea\n    #messageTextarea\n    class=\"message-input\"\n    [(ngModel)]=\"messageText\"\n    [placeholder]=\"placeholder\"\n    [disabled]=\"disabled || isSending\"\n    (keydown)=\"onKeyDown($event)\"\n    (input)=\"onInput($event)\"\n    rows=\"3\">\n  </textarea>\n\n  <!-- Mention Autocomplete Dropdown -->\n  <mj-mention-dropdown\n    [suggestions]=\"mentionSuggestions\"\n    [position]=\"mentionDropdownPosition\"\n    [visible]=\"showMentionDropdown\"\n    [showAbove]=\"mentionDropdownShowAbove\"\n    (suggestionSelected)=\"onMentionSelected($event)\"\n    (closed)=\"closeMentionDropdown()\">\n  </mj-mention-dropdown>\n\n  <div class=\"input-actions\">\n    <div class=\"processing-indicator\" *ngIf=\"isProcessing\">\n      <i class=\"fas fa-circle-notch fa-spin\"></i>\n      <span>AI is responding...</span>\n    </div>\n    <button\n      class=\"btn-attach\"\n      [disabled]=\"disabled\"\n      title=\"Attach file (coming soon)\">\n      <i class=\"fas fa-paperclip\"></i>\n    </button>\n    <button\n      class=\"btn-send\"\n      [disabled]=\"!canSend\"\n      (click)=\"onSend()\"\n      [title]=\"isSending ? 'Sending...' : 'Send message'\">\n      <i class=\"fas fa-paper-plane\"></i>\n    </button>\n  </div>\n</div>", styles: [".message-input-container {\n  position: relative;\n  padding: 16px 24px;\n  border-top: 1px solid #D9D9D9;\n  background: #FFF;\n}\n\n.message-input-wrapper {\n  border: 2px solid #D9D9D9;\n  border-radius: 8px;\n  padding: 12px;\n  transition: border-color 0.2s, box-shadow 0.2s;\n  background: #FFF;\n}\n\n.message-input-wrapper:focus-within {\n  border-color: #0076B6;\n  box-shadow: 0 0 0 3px rgba(0, 118, 182, 0.1);\n}\n\n.message-input {\n  width: 100%;\n  padding: 0;\n  border: none;\n  resize: none;\n  font-family: inherit;\n  font-size: 14px;\n  min-height: 40px;\n  max-height: 200px;\n  line-height: 1.5;\n}\n\n.message-input:focus {\n  outline: none;\n}\n\n.message-input:disabled {\n  background: #F4F4F4;\n  cursor: not-allowed;\n}\n.input-actions {\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  margin-top: 12px;\n}\n.btn-attach {\n  padding: 8px 16px;\n  background: transparent;\n  border: 1px solid #D9D9D9;\n  border-radius: 6px;\n  cursor: pointer;\n  color: #333;\n  display: flex;\n  align-items: center;\n  gap: 6px;\n}\n.btn-attach:hover:not(:disabled) {\n  background: #F4F4F4;\n  border-color: #AAA;\n}\n.btn-attach:disabled {\n  opacity: 0.5;\n  cursor: not-allowed;\n}\n.btn-send {\n  width: 40px;\n  height: 40px;\n  background: #3B82F6;\n  color: white;\n  border: none;\n  border-radius: 8px;\n  cursor: pointer;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  transition: background 0.2s;\n  flex-shrink: 0;\n}\n.btn-send:hover:not(:disabled) {\n  background: #2563EB;\n}\n.btn-send:disabled {\n  background: #D9D9D9;\n  color: #AAA;\n  cursor: not-allowed;\n}\n.btn-send i {\n  font-size: 16px;\n}\n.processing-indicator {\n  display: flex;\n  align-items: center;\n  gap: 8px;\n  font-size: 13px;\n  color: #6B7280;\n  margin-right: auto;\n}\n.processing-indicator i {\n  color: #0076B6;\n}"] }]
-    }], () => [{ type: i1.DialogService }, { type: i2.ToastService }, { type: i3.ConversationAgentService }, { type: i4.ConversationStateService }, { type: i5.ActiveTasksService }, { type: i6.MentionAutocompleteService }, { type: i7.MentionParserService }], { conversationId: [{
+    }], () => [{ type: i1.DialogService }, { type: i2.ToastService }, { type: i3.ConversationAgentService }, { type: i4.ConversationStateService }, { type: i5.DataCacheService }, { type: i6.ActiveTasksService }, { type: i7.MentionAutocompleteService }, { type: i8.MentionParserService }], { conversationId: [{
             type: Input
         }], currentUser: [{
             type: Input
@@ -1155,5 +1513,5 @@ export class MessageInputComponent {
             type: ViewChild,
             args: ['messageTextarea']
         }] }); })();
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(MessageInputComponent, { className: "MessageInputComponent", filePath: "src/lib/components/message/message-input.component.ts", lineNumber: 21 }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(MessageInputComponent, { className: "MessageInputComponent", filePath: "src/lib/components/message/message-input.component.ts", lineNumber: 23 }); })();
 //# sourceMappingURL=message-input.component.js.map