@memberjunction/ng-conversations 6.2.0-edge.5 → 6.2.0-edge.6

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

@@ -8,7 +8,7 @@ import { ApplyRoutingDecision, ArtifactVersionForTurn, RunRoutingDecision, Shoul
 import { BuildRecentTurns, BuildRoutingArtifactVersions, CanAskRoutingDecision, CollectRoutingParticipants, IsAgentAllowed } from '@memberjunction/ai-core-plus';
 import { GenerateAndApplyConversationName } from '../../services/conversation-naming';
 import { AIEngineBase } from '@memberjunction/ai-engine-base';
-import { ConversationUtility, agentFailureDisposition, agentFailureMessage } from '@memberjunction/ai-core-plus';
+import { ConversationUtility, agentFailureDisposition, agentFailureMessage, ContinuationAnnouncementText } from '@memberjunction/ai-core-plus';
 import { MentionAutocompleteService } from '../../services/mention-autocomplete.service';
 import { PlanModePreference } from '../../utils/plan-mode-preference';
 import { MJNotificationService } from '@memberjunction/ng-notifications';
@@ -824,7 +824,7 @@ export class MessageInputComponent extends BaseAngularComponent {
      */
     async InsertAgentMention(agentName, focus = true, clearExisting = true) {
         if (!this.InputBox) {
-            console.log(`[Omnibar→Chat] InsertAgentMention('${agentName}'): input box not mounted yet — caller will retry`);
+            LogStatusEx({ message: `[Omnibar→Chat] InsertAgentMention('${agentName}'): input box not mounted yet — caller will retry`, verboseOnly: true });
             return false;
         }
         if (clearExisting) {
@@ -835,7 +835,7 @@ export class MessageInputComponent extends BaseAngularComponent {
         }
         try {
             if (!this.mentionAutocomplete.IsInitialized && this.CurrentUser) {
-                console.log(`[Omnibar→Chat] InsertAgentMention('${agentName}'): initializing mention autocomplete…`);
+                LogStatusEx({ message: `[Omnibar→Chat] InsertAgentMention('${agentName}'): initializing mention autocomplete…`, verboseOnly: true });
                 await this.mentionAutocomplete.initialize(this.CurrentUser);
             }
             const wanted = agentName.trim().toLowerCase();
@@ -844,7 +844,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                 .find(s => s.type === 'agent' && s.name.trim().toLowerCase() === wanted);
             if (suggestion) {
                 const inserted = this.InputBox.InsertMention(suggestion, focus);
-                console.log(`[Omnibar→Chat] InsertAgentMention('${agentName}'): resolved to pill (id=${suggestion.id}) — insert ${inserted ? 'OK' : 'FAILED (editor view not ready)'}`);
+                LogStatusEx({ message: `[Omnibar→Chat] InsertAgentMention('${agentName}'): resolved to pill (id=${suggestion.id}) — insert ${inserted ? 'OK' : 'FAILED (editor view not ready)'}`, verboseOnly: true });
                 if (inserted) {
                     if (focus) {
                         this.scheduleFocusReassert(agentName);
@@ -873,7 +873,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                 const editor = this.InputBox?.mentionEditor;
                 if (editor && !editor.HasFocus) {
                     const ok = editor.FocusCaretAtEnd();
-                    console.log(`[Omnibar→Chat] focus re-assert (+${delay}ms) for '${context}': ${ok ? 'refocused' : 'editor gone'}`);
+                    LogStatusEx({ message: `[Omnibar→Chat] focus re-assert (+${delay}ms) for '${context}': ${ok ? 'refocused' : 'editor gone'}`, verboseOnly: true });
                 }
             }, delay);
         }
@@ -1515,13 +1515,13 @@ export class MessageInputComponent extends BaseAngularComponent {
                 }
                 // Skip if already complete or errored
                 if (message.Status === 'Complete' || message.Status === 'Error') {
-                    console.log(`[StreamingCallback] Message ${messageId} is ${message.Status}, ignoring progress update`);
+                    LogStatusEx({ message: `[StreamingCallback] Message ${messageId} is ${message.Status}, ignoring progress update`, verboseOnly: true });
                     return;
                 }
                 // Check if message was marked as completed (prevents race condition)
                 const completionTime = this.completionTimestamps.get(messageId);
                 if (completionTime) {
-                    console.log(`[StreamingCallback] Message ${messageId} marked complete at ${new Date(completionTime).toISOString()}, ignoring late progress update`);
+                    LogStatusEx({ message: `[StreamingCallback] Message ${messageId} marked complete at ${new Date(completionTime).toISOString()}, ignoring late progress update`, verboseOnly: true });
                     return;
                 }
                 // Streamed final-response content: the service accumulates deltas, so
@@ -1557,7 +1557,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                 this.MessageSent.emit(message);
                 // CRITICAL: Update ActiveTasksService to keep the tasks dropdown in sync
                 this.activeTasks.updateStatusByConversationDetailId(message.ID, progress.message);
-                console.log(`[StreamingCallback] Updated message ${messageId}: ${progress.taskName || 'Agent'}`);
+                LogStatusEx({ message: `[StreamingCallback] Updated message ${messageId}: ${progress.taskName || 'Agent'}`, verboseOnly: true });
             }
             catch (error) {
                 console.error(`[StreamingCallback] Error updating message ${messageId}:`, error);
@@ -1572,7 +1572,7 @@ export class MessageInputComponent extends BaseAngularComponent {
         if (this.registeredCallbacks.size === 0) {
             return;
         }
-        console.log(`🧹 Unregistering ${this.registeredCallbacks.size} message callbacks`);
+        LogStatusEx({ message: `🧹 Unregistering ${this.registeredCallbacks.size} message callbacks`, verboseOnly: true });
         for (const [messageId, callback] of this.registeredCallbacks) {
             this.streamingService.unregisterMessageCallback(messageId, callback);
         }
@@ -1910,18 +1910,6 @@ export class MessageInputComponent extends BaseAngularComponent {
             return undefined;
         }
     }
-    /**
-     * A new AI row of an agent turn: in `conversationId`, on the turn's branch `branchId` (null is
-     * Main), visible. The caller sets Message, ParentID, Status and AgentID, then saves it.
-     */
-    async createTurnRow(conversationId, branchId) {
-        const row = await this.dataCache.createConversationDetail(this.CurrentUser);
-        row.ConversationID = conversationId;
-        row.BranchID = branchId;
-        row.Role = 'AI';
-        row.HiddenToUser = false;
-        return row;
-    }
     /**
      * Creates and configures a new conversation detail message on `branchId` (null is Main)
      */
@@ -2398,7 +2386,7 @@ export class MessageInputComponent extends BaseAngularComponent {
         // Form responses always continue with the agent that requested the form
         // Don't show "Analyzing intent..." message for this obvious case
         if (ConversationUtility.ContainsFormResponse(message)) {
-            console.log('✅ Form response detected, skipping intent check UI (fast path)');
+            LogStatusEx({ message: '✅ Form response detected, skipping intent check UI (fast path)', verboseOnly: true });
             return {
                 decision: 'YES',
                 reasoning: 'User submitted a form response to the previous agent'
@@ -2530,143 +2518,76 @@ export class MessageInputComponent extends BaseAngularComponent {
      * @param branchId The turn's branch (null is Main).
      */
     async processMessageThroughAgent(userMessage, mentionResult, branchId) {
-        let taskId = null;
         let conversationManagerMessage = null;
         // CRITICAL: Capture conversationId from user message at start
         // This prevents race condition when user switches conversations during async processing
         const conversationId = userMessage.ConversationID;
         try {
-            // Create AI message for Sage BEFORE invoking
-            conversationManagerMessage = await this.createTurnRow(conversationId, branchId);
-            conversationManagerMessage.Message = '⏳ Starting...';
-            conversationManagerMessage.ParentID = userMessage.ID;
-            conversationManagerMessage.Status = 'In-Progress';
-            // 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);
+            // Sage's reply shows as a local placeholder until the server creates the row and names it.
+            conversationManagerMessage = await this.createReplyPlaceholder(conversationId, branchId, userMessage.ID, this.ConverationManagerAgent?.ID ?? null);
             // Use Sage to evaluate and route
             // Stage 1: Sage evaluates the message
-            taskId = this.activeTasks.add({
+            const result = await this.agentService.ProcessMessage(conversationId, userMessage, this.ConversationHistory, this.adoptReplyRow(conversationManagerMessage, {
                 agentName: 'Sage',
                 status: 'Evaluating message...',
                 relatedMessageId: userMessage.ID,
-                conversationDetailId: conversationManagerMessage.ID,
                 conversationId,
                 conversationName: this.ConversationName
-            });
-            const result = await this.agentService.ProcessMessage(conversationId, userMessage, this.ConversationHistory, conversationManagerMessage.ID, this.createProgressCallback(conversationManagerMessage, 'Sage'), this.AppContext, this.PlanModeEnabled, // per-request Plan Mode toggle
+            }), this.createProgressCallback(conversationManagerMessage, 'Sage'), this.AppContext, this.PlanModeEnabled, // per-request Plan Mode toggle
             this._pendingRequestedSkillIDs, // user-requested skills (/skill mentions)
             this.AllowedAgentIDs, // the agents the manager may delegate to
-            this.AgentHistoryFrom);
+            this.AgentHistoryFrom, // the first moment of the conversation the run may read
+            branchId);
             // Emit afterAgentTurn on the happy path only — the error/failure branch
             // immediately below handles its own cleanup and skips this emit.
             if (result && result.success) {
                 this.emitAfterAgentTurn(conversationId, result);
             }
-            // Task will be removed automatically in markMessageComplete()
-            // DO NOT remove here - agent may still be streaming/processing
-            taskId = null; // Clear reference but don't remove from service
             if (!result || !result.success) {
                 await this.applyAgentFailureToDetail(conversationManagerMessage, userMessage, this.ConverationManagerAgent?.Name || 'Sage', result, 'failed');
                 console.warn('⚠️ Sage failed:', agentFailureMessage(result, 'Agent evaluation failed'));
-                this.cleanupCompletionTimestamp(conversationManagerMessage.ID);
                 return;
             }
-            // Stage 2: Check for task graph (multi-step orchestration)
-            if (result.payload?.taskGraph) {
-                await this.handleTaskGraphExecution(userMessage, result, conversationId, branchId, conversationManagerMessage);
-                // Remove CM from active tasks
-                if (taskId) {
-                    // Task removed in markMessageComplete() - 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, conversationId, branchId, conversationManagerMessage);
-                // Remove CM from active tasks
-                if (taskId) {
-                    // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
-                }
-            }
-            // Stage 4: Direct chat response from Agent
-            else if (result.agentRun.FinalStep === 'Chat' && result.agentRun.Message) {
-                // Normal chat response
-                // use update helper to ensure that if there is a race condition with more streaming updates we don't allow that to override this final message
-                // Note: updateConversationDetail will call markMessageComplete() for us
-                await this.updateConversationDetail(conversationManagerMessage, result.agentRun.Message, 'Complete', result);
-                // Handle artifacts if any (but NOT task graphs - those are intermediate work products)
-                // Server already created artifacts - just emit event to trigger UI reload
-                if (result.payload && Object.keys(result.payload).length > 0) {
-                    this.emitArtifactReload(conversationManagerMessage);
-                    this.MessageSent.emit(conversationManagerMessage);
-                }
-                await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
-                // Remove CM from active tasks
-                if (taskId) {
-                    // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
-                }
-                // Clean up completion timestamp after delay
-                this.cleanupCompletionTimestamp(conversationManagerMessage.ID);
-            }
-            // Stage 5: Silent observation - but check for message content first
-            else {
-                // Check if there's a message to display even without payload/taskGraph
-                if (result.agentRun.Message) {
-                    // Mark message as completing BEFORE setting final content
-                    this.markMessageComplete(conversationManagerMessage);
-                    conversationManagerMessage.HiddenToUser = false;
-                    // use update helper to ensure that if there is a race condition with more streaming updates we don't allow that to override this final message
-                    await this.updateConversationDetail(conversationManagerMessage, result.agentRun.Message, 'Complete', result);
-                    this.MessageSent.emit(conversationManagerMessage);
-                    // Clean up completion timestamp after delay
-                    this.cleanupCompletionTimestamp(conversationManagerMessage.ID);
-                }
-                else {
-                    // Mark message as completing
-                    this.markMessageComplete(conversationManagerMessage);
-                    // Hide the Sage message
-                    conversationManagerMessage.HiddenToUser = true;
-                    // use update helper to ensure that if there is a race condition with more streaming updates we don't allow that to override this final message
-                    await this.updateConversationDetail(conversationManagerMessage, conversationManagerMessage.Message, 'Complete', result);
-                    this.MessageSent.emit(conversationManagerMessage);
-                    await this.handleSilentObservation(userMessage, conversationId, branchId);
-                    // Clean up completion timestamp after delay
-                    this.cleanupCompletionTimestamp(conversationManagerMessage.ID);
-                }
-                // Remove CM from active tasks
-                if (taskId) {
-                    // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
-                }
-            }
+            // The server wrote Sage's reply; show it as the server left it before routing on.
+            await this.settleReply(conversationManagerMessage, '❌ Sage could not start.');
+            await this.routeConversationManagerResult(userMessage, result, conversationId, branchId, conversationManagerMessage);
         }
         catch (error) {
             console.error('❌ Error processing message through agents:', error);
-            // Update conversationManagerMessage status to Error
-            if (conversationManagerMessage && conversationManagerMessage.ID) {
-                // Use updateConversationDetail to ensure task cleanup
-                conversationManagerMessage.Error = String(error);
-                await this.updateConversationDetail(conversationManagerMessage, `❌ Error: ${String(error)}`, 'Error');
-                // Clean up completion timestamp
-                this.cleanupCompletionTimestamp(conversationManagerMessage.ID);
+            if (conversationManagerMessage) {
+                await this.settleReply(conversationManagerMessage, `❌ Error: ${String(error)}`);
             }
             // Mark user message as complete
             await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
-            // Clean up active task
-            if (taskId) {
-                // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
-            }
         }
     }
-    /** Detaches the progress callback for one message — used when submission never starts. */
-    releaseProgressCallback(messageId) {
-        const callback = this.registeredCallbacks.get(messageId);
-        if (callback) {
-            this.streamingService.unregisterMessageCallback(messageId, callback);
-            this.registeredCallbacks.delete(messageId);
+    /**
+     * Acts on the conversation manager's settled reply: a workflow, a delegation, a chat answer, or
+     * silence (its reply is hidden and the last agent may continue).
+     */
+    async routeConversationManagerResult(userMessage, result, conversationId, branchId, managerReply) {
+        // Stage 2: Check for task graph (multi-step orchestration)
+        if (result.payload?.taskGraph) {
+            await this.handleTaskGraphExecution(userMessage, result, conversationId, branchId, managerReply);
+        }
+        // Stage 3: Check for sub-agent invocation (single-step delegation)
+        else if (result.agentRun.FinalStep === 'Success' && result.payload?.invokeAgent) {
+            await this.handleSubAgentInvocation(userMessage, result, conversationId, branchId, managerReply);
+        }
+        // Stage 4: Direct chat response from Agent
+        else if (result.agentRun.FinalStep === 'Chat' && result.agentRun.Message) {
+            // Handle artifacts if any (but NOT task graphs - those are intermediate work products)
+            // Server already created artifacts - just emit event to trigger UI reload
+            if (result.payload && Object.keys(result.payload).length > 0) {
+                this.emitArtifactReload(managerReply);
+                this.MessageSent.emit(managerReply);
+            }
+            await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
+        }
+        // Stage 5: Silent observation — Sage said nothing, so its reply is hidden and the last agent may continue
+        else if (!result.agentRun.Message) {
+            await this.hideReply(managerReply);
+            await this.handleSilentObservation(userMessage, conversationId, branchId);
         }
     }
     /**
@@ -2702,49 +2623,59 @@ export class MessageInputComponent extends BaseAngularComponent {
             return;
         }
         const workflowName = taskGraph.workflowName || 'Workflow';
-        const reasoning = taskGraph.reasoning || 'Executing multi-step workflow';
-        const taskCount = Array.isArray(taskGraph.tasks) ? taskGraph.tasks.length : 0;
-        // A message the user can watch. Progress frames from the dispatcher land against this ID.
-        const taskExecutionMessage = await this.createTurnRow(conversationId, branchId);
-        taskExecutionMessage.Message = `⏳ **${workflowName}**\n\n${reasoning}\n\nSubmitting ${taskCount} task(s)…`;
-        taskExecutionMessage.ParentID = conversationManagerMessage.ID;
-        taskExecutionMessage.Status = 'In-Progress';
-        await taskExecutionMessage.Save();
-        this.MessageSent.emit(taskExecutionMessage);
-        const callback = this.createMessageProgressCallback(taskExecutionMessage.ID);
-        this.registeredCallbacks.set(taskExecutionMessage.ID, callback);
-        this.streamingService.registerMessageCallback(taskExecutionMessage.ID, callback);
         try {
             // `TaskGraph.Submit` is a Remote Operation, not a bespoke mutation: the same call site is
             // reachable from MCP, an Action wrapper, and this UI. `Execute` marshals over the generic
             // `ExecuteRemoteOperation` transport, so there is no hand-written GraphQL document here.
-            const result = await new TaskGraphSubmitOperation().Execute({
+            //
+            // The server writes the workflow's status bubble under the reply that planned it (only the
+            // server writes agent replies) and binds the graph to it, so progress frames land on it.
+            const input = {
                 spec: taskGraph,
                 environmentID: MJEnvironmentEntityExtended.DefaultEnvironmentID,
-                conversationDetailID: taskExecutionMessage.ID,
-            });
-            if (result.Success && result.Output?.success) {
-                // Deliberately NOT "completed" — submission means the work is durable and running, and
-                // claiming completion here is exactly the lie the old await-everything path told when it
-                // returned early. The dispatcher's progress frames update this message as tasks finish.
-                await this.updateConversationDetail(taskExecutionMessage, `▶️ **${workflowName}** started — ${taskCount} task(s) running.`, 'In-Progress');
-            }
-            else {
-                const errorMsg = result.Output?.errorMessage || result.ErrorMessage || 'Unknown error';
+                conversationDetailID: conversationManagerMessage.ID,
+                postStatusMessage: true,
+            };
+            const result = await new TaskGraphSubmitOperation().Execute(input);
+            const output = result.Output;
+            if (output?.statusConversationDetailID) {
+                await this.showWorkflowStatus(output.statusConversationDetailID);
+            }
+            if (!result.Success || !output?.success) {
+                // The bubble says it was rejected; the reason (it may quote the plan) is shown only to this person.
+                const errorMsg = output?.errorMessage || result.ErrorMessage || 'Unknown error';
                 console.error('Task graph submission rejected:', errorMsg);
-                taskExecutionMessage.Error = errorMsg;
-                await this.updateConversationDetail(taskExecutionMessage, `❌ **${workflowName}** rejected: ${errorMsg}`, 'Error');
-                this.releaseProgressCallback(taskExecutionMessage.ID);
+                this.notifyAgentTurnProblem(`${workflowName} was rejected: ${errorMsg}`, 'error');
             }
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
             console.error('Task graph submission failed:', error);
-            taskExecutionMessage.Error = msg;
-            await this.updateConversationDetail(taskExecutionMessage, `❌ **${workflowName}** failed to submit: ${msg}`, 'Error');
-            this.releaseProgressCallback(taskExecutionMessage.ID);
+            this.notifyAgentTurnProblem(`${workflowName} failed to submit: ${msg}`, 'error');
+        }
+    }
+    /**
+     * Shows the workflow status bubble the server wrote, and follows the dispatcher's progress frames on
+     * it while it runs, as the chat followed its own status row.
+     */
+    async showWorkflowStatus(statusId) {
+        const status = await this.dataCache.getConversationDetail(statusId, this.CurrentUser);
+        if (!status) {
+            console.warn(`Workflow status ${statusId} could not be loaded`);
+            return;
+        }
+        this.MessageSent.emit(status);
+        if (status.Status === 'In-Progress') {
+            const callback = this.createMessageProgressCallback(status.ID);
+            this.registeredCallbacks.set(status.ID, callback);
+            this.streamingService.registerMessageCallback(status.ID, callback);
         }
     }
+    /**
+     * Saves the person's own message with its text and status (in MJ's chat, marking it Complete once its turn is
+     * over). Never used for an agent's reply: only the server writes those, and the chat shows them with
+     * {@link settleReply}.
+     */
     async updateConversationDetail(convoDetail, message, status, result) {
         // Mark as completing FIRST if status is Complete or Error
         // This ensures task cleanup happens even if we return early due to guard clause
@@ -2815,10 +2746,10 @@ export class MessageInputComponent extends BaseAngularComponent {
         }
         const source = await this.agentService.FindLatestAgentOutputVersion(this.ConversationId, agentId, this.AgentHistoryFrom, branchId);
         if (!source || source.payload == null) {
-            console.log(`📦 No previous payload found for agent ${agentId}`);
+            LogStatusEx({ message: `📦 No previous payload found for agent ${agentId}`, verboseOnly: true });
             return { payload: null, artifactInfo: null };
         }
-        console.log(`📦 Loaded previous payload for agent ${agentId} from artifact version ${source.versionId}`);
+        LogStatusEx({ message: `📦 Loaded previous payload for agent ${agentId} from artifact version ${source.versionId}`, verboseOnly: true });
         return {
             payload: source.payload,
             artifactInfo: {
@@ -2829,47 +2760,25 @@ export class MessageInputComponent extends BaseAngularComponent {
         };
     }
     /**
-     * Handle sub-agent invocation based on Sage's payload
-     * Reuses the existing conversationManagerMessage to avoid creating multiple records
+     * Handle sub-agent invocation based on Sage's payload: the delegate answers the user's message
+     * with its own reply, which the server creates. A failed first attempt is retried once; its
+     * reply is hidden when the retry takes over.
      *
      * @param branchId The turn's branch (null is Main).
      */
-    async handleSubAgentInvocation(userMessage, managerResult, conversationId, branchId, conversationManagerMessage) {
+    async handleSubAgentInvocation(userMessage, managerResult, conversationId, branchId, delegatingReply) {
         const payload = managerResult.payload;
         const agentName = payload.invokeAgent;
         const reasoning = payload.reasoning || 'Delegating to specialist agent';
-        // Now create a NEW message for the sub-agent execution
+        const agent = AIEngineBase.Instance.ReadableAgents.find(a => a.Name === agentName);
+        // The manager routes only among the allowed agents, but its answer is model output: hold
+        // the host's list here too, before any run starts for the delegate.
+        if (this.AllowedAgentIDs != null && !IsAgentAllowed(agent?.ID, this.AllowedAgentIDs)) {
+            await this.refuseDisallowedAgents(userMessage, [agentName]);
+            return;
+        }
         let agentResponseMessage = null;
         try {
-            // Look up the agent to get its ID
-            const agent = AIEngineBase.Instance.ReadableAgents.find(a => a.Name === agentName);
-            // The manager routes only among the allowed agents, but its answer is model output: hold
-            // the host's list here too, before any row is written for the delegate.
-            if (this.AllowedAgentIDs != null && !IsAgentAllowed(agent?.ID, this.AllowedAgentIDs)) {
-                await this.refuseDisallowedAgents(userMessage, [agentName]);
-                return;
-            }
-            // Create AI response message BEFORE invoking agent (for duration tracking)
-            agentResponseMessage = await this.createTurnRow(conversationId, branchId);
-            agentResponseMessage.Message = '⏳ Starting...'; // Initial message
-            agentResponseMessage.ParentID = conversationManagerMessage.ID; // Thread under delegation message
-            agentResponseMessage.Status = 'In-Progress';
-            // Set AgentID immediately for proper attribution
-            if (agent?.ID) {
-                agentResponseMessage.AgentID = agent.ID;
-            }
-            // Save the record to establish __mj_CreatedAt timestamp
-            await agentResponseMessage.Save();
-            this.MessageSent.emit(agentResponseMessage);
-            // Add sub-agent to active tasks
-            const newTaskId = this.activeTasks.add({
-                agentName: agentName,
-                status: 'Starting...',
-                relatedMessageId: userMessage.ID,
-                conversationDetailId: agentResponseMessage.ID,
-                conversationId,
-                conversationName: this.ConversationName
-            });
             // Load previous payload if agent has been invoked before
             const { payload: previousPayload, artifactInfo } = agent?.ID
                 ? await this.loadPreviousPayloadForAgent(agent.ID, branchId)
@@ -2878,70 +2787,44 @@ export class MessageInputComponent extends BaseAngularComponent {
             const configurationPresetId = agent?.ID
                 ? await this.agentService.FindConfigurationPresetForAgent(conversationId, agent.ID, branchId)
                 : undefined;
-            // Invoke the sub-agent with progress callback
-            const subResult = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.ConversationHistory, reasoning, agentResponseMessage.ID, previousPayload, // Pass previous payload for continuity
-            this.createProgressCallback(agentResponseMessage, agentName), artifactInfo?.artifactId, artifactInfo?.versionId, configurationPresetId, // Pass configuration from previous @mention for continuity
-            this.AppContext, // Embedder-supplied app/form context
-            this.PlanModeEnabled, // per-request Plan Mode toggle
-            this._pendingRequestedSkillIDs, // user-requested skills (/skill mentions)
-            this.AgentHistoryFrom);
-            // Task will be removed automatically in markMessageComplete() when status changes to Complete/Error
-            // DO NOT remove here - allows UI to show task during entire execution
-            if (subResult && subResult.success) {
-                // Update the response message with agent result
-                // Store the agent ID for display
-                if (subResult.agentRun.AgentID) {
-                    agentResponseMessage.AgentID = subResult.agentRun.AgentID;
-                }
-                await this.updateConversationDetail(agentResponseMessage, subResult.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete', subResult);
-                // Always emit artifactCreated to trigger UI reload — the server may have created
-                // artifacts even when the result payload is empty (e.g., remote stage server).
-                // onArtifactCreated will reload from DB and discover any artifacts that exist.
-                this.emitArtifactReload(agentResponseMessage);
-                this.MessageSent.emit(agentResponseMessage);
-                // Mark user message as complete
-                await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
-            }
-            else {
-                // A post-ACK disconnect means the first run may still be executing on this
-                // detail — do not start a second run on the same conversationDetailId.
-                if (agentFailureDisposition(subResult).status === 'In-Progress') {
-                    await this.applyAgentFailureToDetail(agentResponseMessage, userMessage, agentName, subResult);
-                    return;
-                }
-                // Sub-agent failed - attempt auto-retry once
-                console.log(`⚠️ ${agentName} failed, attempting auto-retry...`);
-                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
-                await this.updateConversationDetail(agentResponseMessage, "Retrying...", agentResponseMessage.Status);
-                // Retry the sub-agent (reuse previously loaded payload and config from first attempt)
-                const retryResult = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.ConversationHistory, reasoning, agentResponseMessage.ID, previousPayload, // Pass same payload as first attempt
-                this.createProgressCallback(agentResponseMessage, `${agentName} (retry)`), artifactInfo?.artifactId, artifactInfo?.versionId, configurationPresetId, // Pass same config as first attempt
+            // The delegate's reply threads under the delegating reply, as it always has; the server checks and sets it.
+            const threading = {
+                ReplyParentId: delegatingReply.ID,
+                ...(branchId ? { ReplyBranchId: branchId } : {}),
+            };
+            const invoke = async (label) => {
+                const reply = await this.createReplyPlaceholder(conversationId, branchId, delegatingReply.ID, agent?.ID ?? null);
+                agentResponseMessage = reply;
+                const result = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.ConversationHistory, reasoning, this.adoptReplyRow(reply, { agentName, status: 'Starting...', relatedMessageId: userMessage.ID, conversationId, conversationName: this.ConversationName }), previousPayload, // Pass previous payload for continuity
+                this.createProgressCallback(reply, label), artifactInfo?.artifactId, artifactInfo?.versionId, configurationPresetId, // Pass configuration from previous @mention for continuity
                 this.AppContext, // Embedder-supplied app/form context
                 this.PlanModeEnabled, // per-request Plan Mode toggle
                 this._pendingRequestedSkillIDs, // user-requested skills (/skill mentions)
-                this.AgentHistoryFrom);
-                if (retryResult && retryResult.success) {
-                    // Retry succeeded - update the same message
-                    if (retryResult.agentRun.AgentID) {
-                        agentResponseMessage.AgentID = retryResult.agentRun.AgentID;
-                    }
-                    await this.updateConversationDetail(agentResponseMessage, retryResult.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete', retryResult);
-                    // Always emit artifactCreated to trigger UI reload (same as initial attempt)
-                    this.emitArtifactReload(agentResponseMessage);
-                    this.MessageSent.emit(agentResponseMessage);
-                    await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
-                }
-                else {
-                    // Retry also failed — terminate the agent bubble (the red-pill timer lives here),
-                    // not only the Sage delegation message.
-                    await this.applyAgentFailureToDetail(agentResponseMessage, userMessage, agentName, retryResult, 'failed after retry');
-                    const retryDisposition = agentFailureDisposition(retryResult);
-                    if (retryDisposition.status === 'Error') {
-                        conversationManagerMessage.Error = retryDisposition.message;
-                        await this.updateConversationDetail(conversationManagerMessage, `❌ **${agentName}** failed after retry\n\n${retryDisposition.message}`, 'Error');
-                    }
-                }
+                this.AgentHistoryFrom, // the first moment of the conversation the run may read
+                threading);
+                return { reply, result };
+            };
+            const first = await invoke(agentName);
+            if (first.result && first.result.success) {
+                await this.showDelegateReply(first.reply, userMessage);
+                return;
+            }
+            // A post-ACK disconnect means the first run may still be executing — do not start a second run.
+            if (agentFailureDisposition(first.result).status === 'In-Progress') {
+                await this.applyAgentFailureToDetail(first.reply, userMessage, agentName, first.result);
+                return;
+            }
+            // Sub-agent failed - attempt auto-retry once. The failed reply stays the server's record of
+            // the attempt; it is hidden so the retry's reply takes its place on screen.
+            LogStatusEx({ message: `⚠️ ${agentName} failed, attempting auto-retry...`, verboseOnly: true });
+            await this.settleReply(first.reply, `❌ **${agentName}** failed`);
+            await this.hideReply(first.reply);
+            const retry = await invoke(`${agentName} (retry)`);
+            if (retry.result && retry.result.success) {
+                await this.showDelegateReply(retry.reply, userMessage);
+            }
+            else {
+                await this.applyAgentFailureToDetail(retry.reply, userMessage, agentName, retry.result, 'failed after retry');
             }
         }
         catch (error) {
@@ -2956,13 +2839,19 @@ export class MessageInputComponent extends BaseAngularComponent {
             else {
                 await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
             }
-            const catchDisposition = agentFailureDisposition(catchResult);
-            if (catchDisposition.status === 'Error') {
-                conversationManagerMessage.Error = catchDisposition.message;
-                await this.updateConversationDetail(conversationManagerMessage, `❌ **${agentName}** encountered an error\n\n${catchDisposition.message}`, 'Error');
-            }
         }
     }
+    /**
+     * Shows a delegate's successful reply as the server wrote it, reloads its artifacts (the server
+     * may have created some even when the result payload is empty, e.g. a remote stage server), and
+     * completes the user's message.
+     */
+    async showDelegateReply(reply, userMessage) {
+        await this.settleReply(reply, '❌ The agent could not start.');
+        this.emitArtifactReload(reply);
+        this.MessageSent.emit(reply);
+        await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
+    }
     /**
      * Handle silent observation - when Sage stays silent,
      * check if we should continue with the last agent for iterative refinement
@@ -2974,12 +2863,12 @@ export class MessageInputComponent extends BaseAngularComponent {
         const lastAIMessage = this.findLastNonSageReply();
         if (!lastAIMessage || !lastAIMessage.AgentID) {
             // No previous specialist agent - just mark user message as complete
-            console.log('🔇 No previous specialist agent found - marking complete');
+            LogStatusEx({ message: '🔇 No previous specialist agent found - marking complete', verboseOnly: true });
             await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
             return;
         }
         if (!IsAgentAllowed(lastAIMessage.AgentID, this.AllowedAgentIDs)) {
-            console.log('🔇 Previous specialist agent is not allowed in this chat - marking complete');
+            LogStatusEx({ message: '🔇 Previous specialist agent is not allowed in this chat - marking complete', verboseOnly: true });
             await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
             return;
         }
@@ -3004,60 +2893,39 @@ export class MessageInputComponent extends BaseAngularComponent {
                 versionId: source.versionId,
                 versionNumber: source.versionNumber
             };
-            console.log('📦 Loaded previous OUTPUT artifact as payload for continuity', previousArtifactInfo);
-        }
-        // Create status message showing agent continuity
-        const statusMessage = await this.createTurnRow(conversationId, branchId);
-        statusMessage.Message = `Continuing with **${agentName}** for refinement...`;
-        statusMessage.ParentID = userMessage.ID;
-        statusMessage.Status = 'Complete';
-        statusMessage.AgentID = this.ConverationManagerAgent?.ID || null;
-        await statusMessage.Save();
-        this.MessageSent.emit(statusMessage);
-        // Add agent to active tasks
-        const taskId = this.activeTasks.add({
-            agentName: agentName,
-            status: 'Processing refinement...',
-            relatedMessageId: userMessage.ID,
-            conversationDetailId: statusMessage.ID,
-            conversationId,
-            conversationName: this.ConversationName
-        });
+            LogStatusEx({ message: '📦 Loaded previous OUTPUT artifact as payload for continuity', verboseOnly: true, additionalArgs: [previousArtifactInfo] });
+        }
+        // The manager's line "Continuing with X for refinement..." and the continuing agent's reply, threaded under it,
+        // both written by the server. Until it acknowledges the run they show as local placeholders.
+        const managerId = this.ConverationManagerAgent?.ID ?? null;
+        const announcement = managerId
+            ? await this.createReplyPlaceholder(conversationId, branchId, userMessage.ID, managerId, { Message: ContinuationAnnouncementText(agentName), Status: 'Complete' })
+            : undefined;
+        const reply = await this.createReplyPlaceholder(conversationId, branchId, announcement?.ID ?? userMessage.ID, lastAIMessage.AgentID);
+        const threading = managerId || branchId
+            ? {
+                ...(managerId ? { AnnouncedByAgentId: managerId } : {}),
+                ...(branchId ? { ReplyBranchId: branchId } : {}),
+            }
+            : null;
         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, agentName), previousArtifactInfo?.artifactId, previousArtifactInfo?.versionId, undefined, // configurationPresetId not used in this path
+            const continuityResult = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.ConversationHistory, 'Continuing previous work based on user feedback', this.adoptReplyRow(reply, { agentName, status: 'Processing refinement...', relatedMessageId: userMessage.ID, conversationId, conversationName: this.ConversationName }, announcement), previousPayload, this.createProgressCallback(reply, agentName), previousArtifactInfo?.artifactId, previousArtifactInfo?.versionId, undefined, // configurationPresetId not used in this path
             this.AppContext, // Embedder-supplied app/form context
             this.PlanModeEnabled, // per-request Plan Mode toggle
             this._pendingRequestedSkillIDs, // user-requested skills (/skill mentions)
-            this.AgentHistoryFrom);
-            // Remove from active tasks
-            // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
+            this.AgentHistoryFrom, // the first moment of the conversation the run may read
+            threading);
             if (continuityResult && continuityResult.success) {
-                // Create response message
-                const agentResponseMessage = await this.createTurnRow(conversationId, branchId);
-                agentResponseMessage.Message = continuityResult.agentRun?.Message || `✅ **${agentName}** completed refinement`;
-                agentResponseMessage.ParentID = statusMessage.ID;
-                agentResponseMessage.Status = 'Complete';
-                agentResponseMessage.AgentID = lastAIMessage.AgentID;
-                await agentResponseMessage.Save();
-                this.MessageSent.emit(agentResponseMessage);
-                // Server created artifacts (handles versioning automatically) - emit event to trigger UI reload
-                if (continuityResult.payload && Object.keys(continuityResult.payload).length > 0) {
-                    this.emitArtifactReload(agentResponseMessage);
-                    console.log('🎨 Server created artifact (versioned) from agent continuity');
-                    this.MessageSent.emit(agentResponseMessage);
-                }
-                // Mark user message as complete
-                await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
+                await this.showDelegateReply(reply, userMessage);
             }
             else {
-                await this.applyAgentFailureToDetail(statusMessage, userMessage, agentName, continuityResult, 'failed during refinement');
+                await this.applyAgentFailureToDetail(reply, userMessage, agentName, continuityResult, 'failed during refinement');
             }
         }
         catch (error) {
             console.error(`❌ Error in agent continuity with ${agentName}:`, error);
-            // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
-            await this.applyAgentFailureToDetail(statusMessage, userMessage, agentName, { success: false, errorMessage: error instanceof Error ? error.message : String(error) }, 'encountered an error');
+            await this.applyAgentFailureToDetail(reply, userMessage, agentName, { success: false, errorMessage: error instanceof Error ? error.message : String(error) }, 'encountered an error');
         }
     }
     /**
@@ -3068,15 +2936,6 @@ export class MessageInputComponent extends BaseAngularComponent {
      */
     async invokeAgentDirectly(userMessage, agentMention, conversationId, branchId) {
         const agentName = agentMention.name;
-        // Add agent to active tasks
-        const taskId = this.activeTasks.add({
-            agentName: agentName,
-            status: 'Processing...',
-            relatedMessageId: userMessage.ID,
-            conversationDetailId: userMessage.ID,
-            conversationId,
-            conversationName: this.ConversationName
-        });
         // Declare agentResponseMessage outside try block so it's accessible in catch
         let agentResponseMessage = undefined;
         try {
@@ -3087,50 +2946,36 @@ export class MessageInputComponent extends BaseAngularComponent {
             this.MessageSent.emit(userMessage);
             // Look up the agent to get its ID
             const agent = AIEngineBase.Instance.ReadableAgents.find(a => a.Name === agentName);
-            // Create AI response message BEFORE invoking agent (for duration tracking)
-            agentResponseMessage = await this.createTurnRow(conversationId, branchId);
-            agentResponseMessage.Message = '⏳ Starting...'; // Initial message
-            agentResponseMessage.ParentID = userMessage.ID;
-            agentResponseMessage.Status = 'In-Progress';
-            // Set AgentID immediately for proper attribution
-            if (agent?.ID) {
-                agentResponseMessage.AgentID = agent.ID;
-            }
-            // Save the record to establish __mj_CreatedAt timestamp
-            await agentResponseMessage.Save();
-            this.MessageSent.emit(agentResponseMessage);
+            // The reply shows as a local placeholder until the server creates the row and names it.
+            agentResponseMessage = await this.createReplyPlaceholder(conversationId, branchId, userMessage.ID, agent?.ID ?? null);
             // Load previous payload if agent has been invoked before
             const { payload: previousPayload, artifactInfo } = agent?.ID
                 ? await this.loadPreviousPayloadForAgent(agent.ID, branchId)
                 : { payload: null, artifactInfo: null };
             // Invoke the agent directly
-            const result = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.ConversationHistory, `User mentioned agent directly with @${agentName}`, agentResponseMessage.ID, previousPayload, // Pass previous payload for continuity
+            const result = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.ConversationHistory, `User mentioned agent directly with @${agentName}`, this.adoptReplyRow(agentResponseMessage, { agentName, status: 'Processing...', relatedMessageId: userMessage.ID, conversationId, conversationName: this.ConversationName }), previousPayload, // Pass previous payload for continuity
             this.createProgressCallback(agentResponseMessage, agentName), artifactInfo?.artifactId, artifactInfo?.versionId, agentMention.configurationId, // Pass configuration preset ID
             this.AppContext, // Embedder-supplied app/form context
             this.PlanModeEnabled, // per-request Plan Mode toggle
             this._pendingRequestedSkillIDs, // user-requested skills (/skill mentions)
-            this.AgentHistoryFrom);
-            // Remove from active tasks
-            // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
+            this.AgentHistoryFrom, // the first moment of the conversation the run may read
+            branchId ? { ReplyBranchId: branchId } : null);
             if (result && result.success) {
-                if (result.agentRun.AgentID) {
-                    agentResponseMessage.AgentID = result.agentRun.AgentID;
-                }
                 this.emitAfterAgentTurn(conversationId, result);
+                await this.settleReply(agentResponseMessage, `❌ **${agentName}** could not start.`);
                 // Multi-stage response handling (same logic as ambient Sage)
                 // Stage 1: Check for task graph (multi-step orchestration)
                 if (result.payload?.taskGraph) {
-                    console.log('📋 Task graph detected from @mention, starting task orchestration');
+                    LogStatusEx({ message: '📋 Task graph detected from @mention, starting task orchestration', verboseOnly: true });
                     await this.handleTaskGraphExecution(userMessage, result, conversationId, branchId, agentResponseMessage);
                 }
                 // Stage 2: Check for sub-agent invocation (single-step delegation)
                 else if (result.agentRun.FinalStep === 'Success' && result.payload?.invokeAgent) {
-                    console.log('🎯 Sub-agent invocation detected from @mention');
+                    LogStatusEx({ message: '🎯 Sub-agent invocation detected from @mention', verboseOnly: true });
                     await this.handleSubAgentInvocation(userMessage, result, conversationId, branchId, agentResponseMessage);
                 }
                 // Stage 3: Normal chat response
                 else {
-                    await this.updateConversationDetail(agentResponseMessage, result.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete', result);
                     // Server created artifacts - emit event to trigger UI reload
                     if (result.payload && Object.keys(result.payload).length > 0) {
                         this.emitArtifactReload(agentResponseMessage);
@@ -3191,7 +3036,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                     versionId: target.versionId,
                     versionNumber: target.versionNumber
                 };
-                console.log('📦 Loaded target artifact version as payload', previousArtifactInfo);
+                LogStatusEx({ message: '📦 Loaded target artifact version as payload', verboseOnly: true, additionalArgs: [previousArtifactInfo] });
             }
             else {
                 console.warn('⚠️ Could not load target artifact version:', targetArtifactVersionId);
@@ -3224,10 +3069,10 @@ export class MessageInputComponent extends BaseAngularComponent {
                     versionId: source.versionId,
                     versionNumber: source.versionNumber
                 };
-                console.log('📦 Loaded artifact as payload for continuation', previousArtifactInfo);
+                LogStatusEx({ message: '📦 Loaded artifact as payload for continuation', verboseOnly: true, additionalArgs: [previousArtifactInfo] });
             }
             else {
-                console.log(`📦 No artifact found for agent ${agentId} in this conversation`);
+                LogStatusEx({ message: `📦 No artifact found for agent ${agentId} in this conversation`, verboseOnly: true });
             }
         }
         // Execute the agent with the gathered context
@@ -3247,15 +3092,6 @@ export class MessageInputComponent extends BaseAngularComponent {
      * @param configurationId Optional configuration preset ID to use
      */
     async executeAgentContinuation(userMessage, agentId, agentName, conversationId, branchId, previousPayload, previousArtifactInfo, configurationId) {
-        // Add agent to active tasks
-        const taskId = this.activeTasks.add({
-            agentName: agentName,
-            status: 'Processing...',
-            relatedMessageId: userMessage.ID,
-            conversationDetailId: userMessage.ID,
-            conversationId,
-            conversationName: this.ConversationName
-        });
         // Declare agentResponseMessage outside try block so it's accessible in catch
         let agentResponseMessage = undefined;
         try {
@@ -3264,32 +3100,23 @@ export class MessageInputComponent extends BaseAngularComponent {
             userMessage.Status = 'Complete';
             await userMessage.Save();
             this.MessageSent.emit(userMessage);
-            // Create AI response message BEFORE invoking agent (for duration tracking)
-            agentResponseMessage = await this.createTurnRow(conversationId, branchId);
-            agentResponseMessage.Message = '⏳ Starting...'; // Initial message
-            agentResponseMessage.ParentID = userMessage.ID;
-            agentResponseMessage.Status = 'In-Progress';
-            agentResponseMessage.AgentID = agentId;
-            // Save the record to establish __mj_CreatedAt timestamp
-            await agentResponseMessage.Save();
-            this.MessageSent.emit(agentResponseMessage);
+            // The reply shows as a local placeholder until the server creates the row and names it.
+            agentResponseMessage = await this.createReplyPlaceholder(conversationId, branchId, userMessage.ID, agentId);
             // Invoke the agent directly (continuation) with previous payload if available.
             // `this.appContext` is forwarded so direct-routed sub-agents (e.g. Form
             // Builder via [defaultAgentId]) see the embedder's ActiveForm/Schema/
             // OverrideID block in their prompt — same flow Sage gets via
             // `processMessage`.
-            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
+            const result = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.ConversationHistory, 'Continuing previous conversation with user', this.adoptReplyRow(agentResponseMessage, { agentName, status: 'Processing...', relatedMessageId: userMessage.ID, conversationId, conversationName: this.ConversationName }), previousPayload, // Pass previous OUTPUT artifact payload for continuity
             this.createProgressCallback(agentResponseMessage, agentName), previousArtifactInfo?.artifactId, previousArtifactInfo?.versionId, configurationId, // Pass configuration for continuity
             this.AppContext, // Embedder-supplied app/form context
             this.PlanModeEnabled, // per-request Plan Mode toggle
             this._pendingRequestedSkillIDs, // user-requested skills (/skill mentions)
-            this.AgentHistoryFrom);
-            // Remove from active tasks
-            // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
+            this.AgentHistoryFrom, // the first moment of the conversation the run may read
+            branchId ? { ReplyBranchId: branchId } : null);
             if (result && result.success) {
                 this.emitAfterAgentTurn(conversationId, result);
-                // Update the response message with agent result
-                await this.updateConversationDetail(agentResponseMessage, result.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete', result);
+                await this.settleReply(agentResponseMessage, `❌ **${agentName}** could not start.`);
                 // Server created artifacts (handles versioning) - emit event to trigger UI reload
                 if (result.payload && Object.keys(result.payload).length > 0) {
                     this.emitArtifactReload(agentResponseMessage);
@@ -3336,39 +3163,113 @@ export class MessageInputComponent extends BaseAngularComponent {
                 name: result.Name,
                 description: result.Description
             });
-            console.log(`✅ Conversation renamed to: "${result.Name}"`);
+            LogStatusEx({ message: `✅ Conversation renamed to: "${result.Name}"`, verboseOnly: true });
         }
     }
     /**
-     * Persist an agent failure onto the response bubble.
+     * An unsaved, local "Starting…" reply, shown from the moment the turn starts until the server
+     * acknowledges the run and names the reply row it created. The chat never writes an agent's
+     * reply: only the server does (A19). The placeholder is never saved; {@link adoptReplyRow}
+     * turns it into the server's row.
+     */
+    async createReplyPlaceholder(conversationId, branchId, parentId, agentId, line = { Message: '⏳ Starting...', Status: 'In-Progress' }) {
+        const placeholder = await this.dataCache.createConversationDetail(this.CurrentUser);
+        placeholder.ConversationID = conversationId;
+        placeholder.BranchID = branchId; // the server writes the reply on its message's branch; the placeholder shows there too
+        placeholder.Role = 'AI';
+        placeholder.Message = line.Message;
+        placeholder.ParentID = parentId;
+        placeholder.Status = line.Status;
+        placeholder.HiddenToUser = false;
+        placeholder.AgentID = agentId;
+        this.MessageSent.emit(placeholder);
+        return placeholder;
+    }
+    /**
+     * The acknowledgement callback for a placeholder's run. When the server accepts the run it names
+     * the reply row it created: the placeholder takes that row's ID and creation time (so the bubble's
+     * timer starts when the server's row did), and the turn's active task is keyed by that ID, which
+     * is what its progress and completion carry. Runs synchronously, before any progress is routed.
+     */
+    adoptReplyRow(placeholder, task, announcement) {
+        return (reply) => {
+            if (announcement && reply.AnnouncementDetailId) {
+                this.adoptRow(announcement, reply.AnnouncementDetailId, reply.CreatedAt);
+            }
+            this.adoptRow(placeholder, reply.ConversationDetailId, reply.CreatedAt);
+            this.activeTasks.add({ ...task, conversationDetailId: reply.ConversationDetailId });
+        };
+    }
+    /** Makes a local placeholder the server's row: its ID and creation time. Synchronous, so nothing routes in between. */
+    adoptRow(placeholder, id, createdAt) {
+        void placeholder.LoadFromData({ ...placeholder.GetAll(), ID: id, __mj_CreatedAt: createdAt }, true);
+        this.MessageSent.emit(placeholder);
+    }
+    /**
+     * Shows a reply as the server left it once its run has returned. The server wrote the reply's
+     * text and status (the chat no longer saves it), so the row is reloaded. A row still In-Progress
+     * is watched until the server settles it. A placeholder the server never acknowledged has no row:
+     * it is marked failed on screen only, with `failureText`, and never saved.
+     */
+    async settleReply(reply, failureText) {
+        if (!reply.IsSaved) {
+            this.markMessageComplete(reply);
+            reply.Status = 'Error';
+            reply.Message = failureText;
+            this.MessageSent.emit(reply);
+            this.cleanupCompletionTimestamp(reply.ID);
+            return;
+        }
+        await reply.Load(reply.ID);
+        if (reply.Status === 'In-Progress') {
+            this.MessageSent.emit(reply);
+            this.startInFlightDetailWatch(reply);
+            return;
+        }
+        this.markMessageComplete(reply);
+        this.MessageSent.emit(reply);
+        this.cleanupCompletionTimestamp(reply.ID);
+    }
+    /**
+     * Hides a reply from the transcript (bookkeeping a person may still write; what the reply says
+     * stays the server's). Used for a manager's silent turn and for a delegate's failed first attempt
+     * once its retry takes over.
+     */
+    async hideReply(reply) {
+        reply.HiddenToUser = true;
+        if (reply.IsSaved && !(await reply.Save())) {
+            console.warn(`Could not hide reply ${reply.ID}:`, reply.LatestResult?.CompleteMessage);
+        }
+        this.MessageSent.emit(reply);
+    }
+    /**
+     * Shows an agent failure on the reply bubble.
      *
-     * A dropped HTTP/WebSocket path used to return `null` from invokeSubAgent, so
-     * the bubble said "Unknown error" while the AIAgentRun stayed Running and the
-     * timer kept ticking. If the transport ACKed the mutation and then died, keep
-     * In-Progress so a later completion event (or {@link startInFlightDetailWatch})
-     * can land. ConversationDetail.Status is the server's claim; the client only
-     * renders it. The GraphQLAIClient stall reconciler covers the wait inside
-     * invokeSubAgent; once that returns, the watch observes the detail until the
-     * server writes a terminal status (MaxTimePerRun).
+     * The server writes the reply, failures included (the chat never saves it), so this reloads the
+     * row the server wrote. A dropped HTTP/WebSocket path after the server ACKed the run may leave the
+     * run still executing: the bubble then says so, on screen only, and {@link startInFlightDetailWatch}
+     * follows the row until the server writes a terminal status. A placeholder the server never
+     * acknowledged shows the failure on screen only.
      *
-     * Always completes the user message — the user turn finished regardless of
-     * what the agent is doing.
+     * Always completes the user message — the user turn finished regardless of what the agent is doing.
      */
     async applyAgentFailureToDetail(agentResponseMessage, userMessage, agentName, result, failedVerb = 'failed') {
         const disposition = agentFailureDisposition(result);
-        if (disposition.status === 'In-Progress') {
-            await this.updateConversationDetail(agentResponseMessage, `⏳ **${agentName}** is still running on the server.\n\n${disposition.message}`, 'In-Progress');
-            // Skip the watch if the reload-before-write guard already found a
-            // terminal server status (Complete/Error) — starting it would race the
-            // just-completed bubble.
+        if (disposition.status === 'In-Progress' && agentResponseMessage.IsSaved) {
+            await agentResponseMessage.Load(agentResponseMessage.ID);
             if (agentResponseMessage.Status === 'In-Progress') {
+                agentResponseMessage.Message = `⏳ **${agentName}** is still running on the server.\n\n${disposition.message}`;
+                this.MessageSent.emit(agentResponseMessage);
                 this.startInFlightDetailWatch(agentResponseMessage);
             }
-            await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
-            return;
+            else {
+                this.markMessageComplete(agentResponseMessage);
+                this.MessageSent.emit(agentResponseMessage);
+            }
+        }
+        else {
+            await this.settleReply(agentResponseMessage, `❌ **${agentName}** ${failedVerb}\n\n${disposition.message}`);
         }
-        agentResponseMessage.Error = disposition.message;
-        await this.updateConversationDetail(agentResponseMessage, `❌ **${agentName}** ${failedVerb}\n\n${disposition.message}`, 'Error');
         await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
     }
     startInFlightDetailWatch(detail) {
@@ -3773,5 +3674,5 @@ export class MessageInputComponent extends BaseAngularComponent {
         }], ComposerBlurred: [{
             type: Output
         }] }); })();
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(MessageInputComponent, { className: "MessageInputComponent", filePath: "src/lib/components/message/message-input.component.ts", lineNumber: 71 }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(MessageInputComponent, { className: "MessageInputComponent", filePath: "src/lib/components/message/message-input.component.ts", lineNumber: 78 }); })();
 //# sourceMappingURL=message-input.component.js.map