@memberjunction/ng-conversations 6.2.0-edge.0 → 6.2.0-edge.2

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

@@ -3,6 +3,9 @@ import { BaseAngularComponent } from '@memberjunction/ng-base-types';
 import { LogStatusEx } from '@memberjunction/core';
 import { MJEnvironmentEntityExtended, ConversationEngine, UserInfoEngine, TaskGraphSubmitOperation } from '@memberjunction/core-entities';
 import { BeforeAgentTurnEventArgs, AfterAgentTurnEventArgs } from '../../events/chat-events';
+import { ResolveAgentTurn, FindDisallowedTaskGraphAgents } from '../../utils/agent-turn-routing';
+import { ApplyRoutingDecision, ArtifactVersionForTurn, RunRoutingDecision, ShouldRunRoutingDecision } from '../../utils/decision-routing';
+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';
@@ -59,30 +62,202 @@ export class MessageInputComponent extends BaseAngularComponent {
     realtimeSession;
     // Default artifact type ID for JSON (when agent doesn't specify DefaultArtifactTypeID)
     JSON_ARTIFACT_TYPE_ID = 'ae674c7e-ea0d-49ea-89e4-0649f5eb20d4';
-    conversationId;
-    conversationName; // For task tracking display
-    currentUser;
-    disabled = false;
-    placeholder = 'Type a message... (Ctrl+Enter to send)';
-    parentMessageId; // Optional: for replying in threads
-    enableAttachments = true; // Whether to show attachment button (based on agent modality support)
-    enableMentions = true; // Whether to enable @-mention autocomplete (agents/users). Hosts addressing a single fixed agent (e.g. Form Builder cockpit) typically set false.
+    ConversationId;
+    /** @deprecated Use {@link ConversationId}. */
+    set conversationId(value) {
+        this.ConversationId = value;
+    }
+    /** @deprecated Use {@link ConversationId}. */
+    get conversationId() {
+        return this.ConversationId;
+    }
+    ConversationName;
+    /** @deprecated Use {@link ConversationName}. */
+    set conversationName(value) {
+        this.ConversationName = value;
+    }
+    /** @deprecated Use {@link ConversationName}. */
+    get conversationName() {
+        return this.ConversationName;
+    } // For task tracking display
+    CurrentUser;
+    /** @deprecated Use {@link CurrentUser}. */
+    set currentUser(value) {
+        this.CurrentUser = value;
+    }
+    /** @deprecated Use {@link CurrentUser}. */
+    get currentUser() {
+        return this.CurrentUser;
+    }
+    Disabled = false;
+    /** @deprecated Use {@link Disabled}. */
+    set disabled(value) {
+        this.Disabled = value;
+    }
+    /** @deprecated Use {@link Disabled}. */
+    get disabled() {
+        return this.Disabled;
+    }
+    /**
+     * Blocks sending. Distinct from {@link Disabled}, which means the composer is busy.
+     */
+    ReadOnly = false;
+    Placeholder = 'Type a message... (Ctrl+Enter to send)';
+    /** @deprecated Use {@link Placeholder}. */
+    set placeholder(value) {
+        this.Placeholder = value;
+    }
+    /** @deprecated Use {@link Placeholder}. */
+    get placeholder() {
+        return this.Placeholder;
+    }
+    ParentMessageId;
+    /** @deprecated Use {@link ParentMessageId}. */
+    set parentMessageId(value) {
+        this.ParentMessageId = value;
+    }
+    /** @deprecated Use {@link ParentMessageId}. */
+    get parentMessageId() {
+        return this.ParentMessageId;
+    } // Optional: for replying in threads
+    EnableAttachments = true;
+    /** @deprecated Use {@link EnableAttachments}. */
+    set enableAttachments(value) {
+        this.EnableAttachments = value;
+    }
+    /** @deprecated Use {@link EnableAttachments}. */
+    get enableAttachments() {
+        return this.EnableAttachments;
+    } // Whether to show attachment button (based on agent modality support)
+    EnableMentions = true;
+    /** @deprecated Use {@link EnableMentions}. */
+    set enableMentions(value) {
+        this.EnableMentions = value;
+    }
+    /** @deprecated Use {@link EnableMentions}. */
+    get enableMentions() {
+        return this.EnableMentions;
+    } // Whether to enable @-mention autocomplete (agents/users). Hosts addressing a single fixed agent (e.g. Form Builder cockpit) typically set false.
     // Per-type caps under enableMentions (all default true) — forwarded to the AI composer's
     // EnableAgentMentions/EnableEntityMentions/EnableSkillCommands. Let a host keep '/' skill
     // commands while dropping '@' agent mentions (which would override a pinned default agent).
-    enableAgentMentions = true;
-    enableEntityMentions = true;
-    enableSkillCommands = true;
-    enablePlanMode = true; // Whether the composer shows the Plan Mode toggle. Hosts that don't expose plan-mode workflows set false.
-    enableRealtime = true; // Whether the composer shows the realtime voice-call launcher/options. Hosts without a voice experience set false.
-    maxAttachments = 10; // Maximum number of attachments per message
-    maxAttachmentSizeBytes = 20 * 1024 * 1024; // Maximum size per attachment (20MB default)
-    acceptedFileTypes = 'image/*'; // Accepted MIME types pattern
-    artifactsByDetailId; // Pre-loaded artifact data for performance
-    systemArtifactsByDetailId; // Pre-loaded system artifact data (Visibility='System Only')
-    agentRunsByDetailId; // Pre-loaded agent run data for performance
-    emptyStateMode = false; // When true, emits emptyStateSubmit instead of creating messages directly
-    appContext = null; // Application context for AI agent awareness
+    EnableAgentMentions = true;
+    /** @deprecated Use {@link EnableAgentMentions}. */
+    set enableAgentMentions(value) {
+        this.EnableAgentMentions = value;
+    }
+    /** @deprecated Use {@link EnableAgentMentions}. */
+    get enableAgentMentions() {
+        return this.EnableAgentMentions;
+    }
+    EnableEntityMentions = true;
+    /** @deprecated Use {@link EnableEntityMentions}. */
+    set enableEntityMentions(value) {
+        this.EnableEntityMentions = value;
+    }
+    /** @deprecated Use {@link EnableEntityMentions}. */
+    get enableEntityMentions() {
+        return this.EnableEntityMentions;
+    }
+    EnableSkillCommands = true;
+    /** @deprecated Use {@link EnableSkillCommands}. */
+    set enableSkillCommands(value) {
+        this.EnableSkillCommands = value;
+    }
+    /** @deprecated Use {@link EnableSkillCommands}. */
+    get enableSkillCommands() {
+        return this.EnableSkillCommands;
+    }
+    EnablePlanMode = true;
+    /** @deprecated Use {@link EnablePlanMode}. */
+    set enablePlanMode(value) {
+        this.EnablePlanMode = value;
+    }
+    /** @deprecated Use {@link EnablePlanMode}. */
+    get enablePlanMode() {
+        return this.EnablePlanMode;
+    } // Whether the composer shows the Plan Mode toggle. Hosts that don't expose plan-mode workflows set false.
+    EnableRealtime = true;
+    /** @deprecated Use {@link EnableRealtime}. */
+    set enableRealtime(value) {
+        this.EnableRealtime = value;
+    }
+    /** @deprecated Use {@link EnableRealtime}. */
+    get enableRealtime() {
+        return this.EnableRealtime;
+    } // Whether the composer shows the realtime voice-call launcher/options. Hosts without a voice experience set false.
+    MaxAttachments = 10;
+    /** @deprecated Use {@link MaxAttachments}. */
+    set maxAttachments(value) {
+        this.MaxAttachments = value;
+    }
+    /** @deprecated Use {@link MaxAttachments}. */
+    get maxAttachments() {
+        return this.MaxAttachments;
+    } // Maximum number of attachments per message
+    MaxAttachmentSizeBytes = 20 * 1024 * 1024;
+    /** @deprecated Use {@link MaxAttachmentSizeBytes}. */
+    set maxAttachmentSizeBytes(value) {
+        this.MaxAttachmentSizeBytes = value;
+    }
+    /** @deprecated Use {@link MaxAttachmentSizeBytes}. */
+    get maxAttachmentSizeBytes() {
+        return this.MaxAttachmentSizeBytes;
+    } // Maximum size per attachment (20MB default)
+    AcceptedFileTypes = 'image/*';
+    /** @deprecated Use {@link AcceptedFileTypes}. */
+    set acceptedFileTypes(value) {
+        this.AcceptedFileTypes = value;
+    }
+    /** @deprecated Use {@link AcceptedFileTypes}. */
+    get acceptedFileTypes() {
+        return this.AcceptedFileTypes;
+    } // Accepted MIME types pattern
+    ArtifactsByDetailId;
+    /** @deprecated Use {@link ArtifactsByDetailId}. */
+    set artifactsByDetailId(value) {
+        this.ArtifactsByDetailId = value;
+    }
+    /** @deprecated Use {@link ArtifactsByDetailId}. */
+    get artifactsByDetailId() {
+        return this.ArtifactsByDetailId;
+    } // Pre-loaded artifact data for performance
+    SystemArtifactsByDetailId;
+    /** @deprecated Use {@link SystemArtifactsByDetailId}. */
+    set systemArtifactsByDetailId(value) {
+        this.SystemArtifactsByDetailId = value;
+    }
+    /** @deprecated Use {@link SystemArtifactsByDetailId}. */
+    get systemArtifactsByDetailId() {
+        return this.SystemArtifactsByDetailId;
+    } // Pre-loaded system artifact data (Visibility='System Only')
+    AgentRunsByDetailId;
+    /** @deprecated Use {@link AgentRunsByDetailId}. */
+    set agentRunsByDetailId(value) {
+        this.AgentRunsByDetailId = value;
+    }
+    /** @deprecated Use {@link AgentRunsByDetailId}. */
+    get agentRunsByDetailId() {
+        return this.AgentRunsByDetailId;
+    } // Pre-loaded agent run data for performance
+    EmptyStateMode = false;
+    /** @deprecated Use {@link EmptyStateMode}. */
+    set emptyStateMode(value) {
+        this.EmptyStateMode = value;
+    }
+    /** @deprecated Use {@link EmptyStateMode}. */
+    get emptyStateMode() {
+        return this.EmptyStateMode;
+    } // When true, emits emptyStateSubmit instead of creating messages directly
+    AppContext = null;
+    /** @deprecated Use {@link AppContext}. */
+    set appContext(value) {
+        this.AppContext = value;
+    }
+    /** @deprecated Use {@link AppContext}. */
+    get appContext() {
+        return this.AppContext;
+    } // Application context for AI agent awareness
     /**
      * Plan Mode toggle state — sticky PER CONVERSATION, OFF by default (no behavior change unless
      * the user turns it on). When on, the user's next message(s) in THIS conversation request Plan
@@ -99,7 +274,7 @@ export class MessageInputComponent extends BaseAngularComponent {
      * conversation's flag OFF automatically (see message-item's plan-decision handling).
      */
     get PlanModeEnabled() {
-        return PlanModePreference.IsEnabled(this.conversationId);
+        return PlanModePreference.IsEnabled(this.ConversationId);
     }
     /**
      * Skill IDs the user requested via `/skill-name` mentions in the message being routed. Collected
@@ -114,7 +289,7 @@ export class MessageInputComponent extends BaseAngularComponent {
      * start of routing so the value is stable for the whole message dispatch.
      */
     collectRequestedSkillIDs() {
-        const chipData = this.inputBox?.getMentionChipsData() || [];
+        const chipData = this.InputBox?.getMentionChipsData() || [];
         return chipData.filter(chip => chip.type === 'skill').map(chip => chip.id);
     }
     /**
@@ -130,7 +305,15 @@ export class MessageInputComponent extends BaseAngularComponent {
      * context and don't need Sage to route. Leave unset to preserve the
      * standard Sage-fronted UX of the main Chat app.
      */
-    defaultAgentId = null;
+    DefaultAgentId = null;
+    /** @deprecated Use {@link DefaultAgentId}. */
+    set defaultAgentId(value) {
+        this.DefaultAgentId = value;
+    }
+    /** @deprecated Use {@link DefaultAgentId}. */
+    get defaultAgentId() {
+        return this.DefaultAgentId;
+    }
     /**
      * Per-conversation pinned default agent — sourced from the loaded
      * `MJConversationEntity.DefaultAgentID`. When set, this agent is used in
@@ -144,7 +327,15 @@ export class MessageInputComponent extends BaseAngularComponent {
      *   4. defaultAgentId (embedder-supplied)
      *   5. Sage fallback
      */
-    conversationDefaultAgentId = null;
+    ConversationDefaultAgentId = null;
+    /** @deprecated Use {@link ConversationDefaultAgentId}. */
+    set conversationDefaultAgentId(value) {
+        this.ConversationDefaultAgentId = value;
+    }
+    /** @deprecated Use {@link ConversationDefaultAgentId}. */
+    get conversationDefaultAgentId() {
+        return this.ConversationDefaultAgentId;
+    }
     /**
      * The `MJ: AI Agent Configurations.ID` selected via the chat header's
      * mode picker (Draft / Standard / High). Applied to **non-mention**
@@ -162,14 +353,22 @@ export class MessageInputComponent extends BaseAngularComponent {
      * messages already in flight or already in history. Affects "what
      * happens next."
      */
-    agentConfigurationPresetId = null;
+    AgentConfigurationPresetId = null;
+    /** @deprecated Use {@link AgentConfigurationPresetId}. */
+    set agentConfigurationPresetId(value) {
+        this.AgentConfigurationPresetId = value;
+    }
+    /** @deprecated Use {@link AgentConfigurationPresetId}. */
+    get agentConfigurationPresetId() {
+        return this.AgentConfigurationPresetId;
+    }
     // Initial message to send automatically - using getter/setter for precise control
     _initialMessage = null;
     _initialAttachments = null;
     _isComponentReady = false; // Track if component is ready to send
     /** Conversation this input has already auto-sent its pending first message for. */
     _autoSentForConversationId = null;
-    set initialMessage(value) {
+    set InitialMessage(value) {
         // Handle case where an object with {text, attachments} is passed instead of just a string
         // This can happen if there's a type mismatch in the binding chain
         let actualValue = value;
@@ -183,31 +382,55 @@ export class MessageInputComponent extends BaseAngularComponent {
             this.triggerInitialSend();
         }
     }
-    get initialMessage() {
+    get InitialMessage() {
         return this._initialMessage;
     }
-    set initialAttachments(value) {
+    /** @deprecated Use {@link InitialMessage}. */
+    get initialMessage() {
+        return this.InitialMessage;
+    }
+    /** @deprecated Use {@link InitialMessage}. */
+    set initialMessage(value) {
+        this.InitialMessage = value;
+    }
+    set InitialAttachments(value) {
         this._initialAttachments = value;
     }
-    get initialAttachments() {
+    get InitialAttachments() {
         return this._initialAttachments;
     }
+    /** @deprecated Use {@link InitialAttachments}. */
+    get initialAttachments() {
+        return this.InitialAttachments;
+    }
+    /** @deprecated Use {@link InitialAttachments}. */
+    set initialAttachments(value) {
+        this.InitialAttachments = value;
+    }
     _conversationHistory = [];
-    get conversationHistory() {
+    get ConversationHistory() {
         return this._conversationHistory;
     }
-    set conversationHistory(value) {
+    set ConversationHistory(value) {
         this._conversationHistory = value;
     }
+    /** @deprecated Use {@link ConversationHistory}. */
+    get conversationHistory() {
+        return this.ConversationHistory;
+    }
+    /** @deprecated Use {@link ConversationHistory}. */
+    set conversationHistory(value) {
+        this.ConversationHistory = value;
+    }
     // Message IDs that are in-progress and need streaming reconnection
     // Using getter/setter to react immediately when value changes (avoids timing issues with ngOnChanges)
     _inProgressMessageIds;
-    set inProgressMessageIds(value) {
+    set InProgressMessageIds(value) {
         this._inProgressMessageIds = value;
         // React immediately when input changes (after component initialized)
         // This ensures callbacks are registered without relying on ngOnChanges timing
         if (this.streamingService && value && value.length > 0) {
-            this.reconnectInProgressMessages();
+            this.ReconnectInProgressMessages();
         }
         else if (this.streamingService) {
             // Empty/undefined — e.g. this input was backgrounded by a conversation swap
@@ -217,48 +440,251 @@ export class MessageInputComponent extends BaseAngularComponent {
             this.unregisterAllCallbacks();
         }
     }
-    get inProgressMessageIds() {
+    get InProgressMessageIds() {
         return this._inProgressMessageIds;
     }
+    /** @deprecated Use {@link InProgressMessageIds}. */
+    get inProgressMessageIds() {
+        return this.InProgressMessageIds;
+    }
+    /** @deprecated Use {@link InProgressMessageIds}. */
+    set inProgressMessageIds(value) {
+        this.InProgressMessageIds = value;
+    }
     /**
      * Application context for the current conversation. Threaded through from the
      * chat-area component for inclusion in the {@link beforeAgentTurn} event payload —
      * lets listeners reason about which app's chat surface is invoking the agent.
      * Optional; defaults to null for surfaces with no app context.
      */
-    applicationId = null;
-    messageSent = new EventEmitter();
-    agentResponse = new EventEmitter();
+    ApplicationId = null;
+    /** @deprecated Use {@link ApplicationId}. */
+    set applicationId(value) {
+        this.ApplicationId = value;
+    }
+    /** @deprecated Use {@link ApplicationId}. */
+    get applicationId() {
+        return this.ApplicationId;
+    }
+    // ── Host rules for agent turns ──────────────────────────────────────────
+    // All opt-in. Left at their defaults, every message is answered exactly as before.
+    /**
+     * When a message starts an agent turn. `'Always'` (the default) answers every message, as
+     * before. `'MentionOnly'` answers only a message that tags an agent; any other message is
+     * posted with no turn at all — no reply row, no placeholder, no turn events — which is what a
+     * chat between several people needs.
+     */
+    AgentReplyMode = 'Always';
+    /**
+     * The agents that may answer here. Narrows the composer's '@' list, every route (a tagged
+     * agent, continuity, the pinned and host default agents, the conversation manager) and the
+     * conversation manager's delegation, including each agent step of a workflow it plans. A tagged
+     * agent outside the list is ignored. Null (the default) allows every agent the user can run;
+     * an empty list allows none.
+     */
+    AllowedAgentIDs = null;
+    /**
+     * The people the composer's '@' list offers, such as the chat's members. Null (the default)
+     * offers only the current user, as before.
+     */
+    MentionPeople = null;
+    /**
+     * The first moment of the conversation an agent turn may read. The server loads the agent's
+     * history from there and uses no summary of earlier messages; the run's own reads of the
+     * conversation (history tools, attached artifacts, the previous output it continues from)
+     * start there too, and so does the continuity route, which considers only replies written at
+     * or after it. Sent to the server only when set, so leaving it null keeps working against an
+     * MJAPI that predates it (one that predates it rejects a turn that sets it, rather than
+     * reading past the floor). Null (the default) reads the whole conversation.
+     */
+    AgentHistoryFrom = null;
+    /**
+     * Runs agent turns on the host's server instead of MJ's own path. The chat area still picks
+     * the agent and fires {@link BeforeAgentTurn}; it then calls the handler once per turn, before
+     * any reply row exists, and shows the rows the handler reports. Null (the default) runs turns
+     * on MJ's path.
+     */
+    AgentTurnHandler = null;
+    /**
+     * Whether MJ names a new conversation from its first message. True (the default) keeps
+     * today's behavior; a host that names its own chats turns it off.
+     */
+    AutoNameConversation = true;
+    /**
+     * Whether an unmentioned message asks one typed decision which agent in the conversation should
+     * answer it, instead of always going back to the last agent that answered. The same call can
+     * name the artifact version the message modifies. The answer replaces continuity only when it
+     * is confident and arrives in time; an error, a slow or unsure answer keeps today's routing, and
+     * a tagged message or a form response makes no call (see `decision-routing.ts`). False (the
+     * default) changes nothing: no call, and today's routing.
+     *
+     * What goes to the model: each qualifying message sends these to the model behind the
+     * `Default Decision` prompt, which can be a different vendor from the agents' own: the first
+     * 1,000 characters of the new message, the last 6 turns (150 characters each), each participant's
+     * name, description and last reply, and the names of their artifact versions. Each call writes an
+     * `MJ: AI Prompt Runs` row, even when the answer comes too late to be used.
+     */
+    EnableDecisionRouting = false;
+    MessageSent = new EventEmitter();
+    /**
+     * @deprecated Use {@link MessageSent}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (messageSent) keeps working. Must stay AFTER MessageSent: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    messageSent = this.MessageSent;
+    AgentResponse = new EventEmitter();
+    /**
+     * @deprecated Use {@link AgentResponse}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (agentResponse) keeps working. Must stay AFTER AgentResponse: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    agentResponse = this.AgentResponse;
+    /**
+     * Cancelable — fired once per agent turn, on every route, after routing has picked the agent
+     * and BEFORE any reply row exists. Listeners may set `event.Cancel = true` to stop the turn
+     * (nothing more is written, and {@link AfterAgentTurn} does not fire) or set
+     * `event.RedirectAgentId` to send it to another allowed agent. A message that starts no turn
+     * fires nothing. Follows MJ's established Before/After cancelable event pattern.
+     */
+    BeforeAgentTurn = new EventEmitter();
+    /**
+     * @deprecated Use {@link BeforeAgentTurn}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (beforeAgentTurn) keeps working. Must stay AFTER BeforeAgentTurn: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    beforeAgentTurn = this.BeforeAgentTurn;
     /**
-     * Cancelable — fired BEFORE `agentService.processMessage()` is called for a user turn.
-     * Listeners may set `event.Cancel = true` to halt the agent invocation (e.g., a
-     * client-side guardrail blocking the turn). When canceled, the corresponding
-     * {@link afterAgentTurn} event is NOT fired and the running task is cleared.
-     * Follows MJ's established Before/After cancelable event pattern.
+     * Fired AFTER a successful agent turn, on every route. Carries the agent run id and the
+     * full agent result. Not fired when {@link BeforeAgentTurn} was canceled, when the turn
+     * failed, or when a host {@link AgentTurnHandler} reported no result.
      */
-    beforeAgentTurn = new EventEmitter();
+    AfterAgentTurn = new EventEmitter();
     /**
-     * Fired AFTER a successful agent turn completes. Carries the agent run id and the
-     * full agent result. Not fired when {@link beforeAgentTurn} was canceled or when
-     * the underlying `processMessage` errored.
+     * @deprecated Use {@link AfterAgentTurn}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (afterAgentTurn) keeps working. Must stay AFTER AfterAgentTurn: class fields
+     * initialise in order, and the other way round this captures undefined.
      */
-    afterAgentTurn = new EventEmitter();
+    afterAgentTurn = this.AfterAgentTurn;
     // conversationId is carried on every agent-lifecycle event so the parent chat-area can drop
     // events emitted by a BACKGROUND conversation's (hidden, still-streaming) input after the user
     // has swapped conversations — preventing cross-conversation state/cache bleed. Sourced from the
     // ConversationDetail entity's ConversationID (the captured, immutable value), never this.conversationId.
-    agentRunDetected = new EventEmitter();
-    agentRunUpdate = new EventEmitter(); // Emits when agent run data updates during progress
-    messageComplete = new EventEmitter(); // Emits when message completes (success or error)
-    artifactCreated = new EventEmitter();
-    conversationRenamed = new EventEmitter();
-    intentCheckStarted = new EventEmitter(); // Emits when intent checking starts
-    intentCheckCompleted = new EventEmitter(); // Emits when intent checking completes (carries conversationId so the parent can drop a background conversation's completion after a swap — symmetric with intentCheckStarted)
-    initialMessageAutoSendStarted = new EventEmitter(); // Emitted when this input latches the pending first message for auto-send
-    initialMessageAutoSendFailed = new EventEmitter(); // Emitted when a latched pending first message fails before messageSent
-    emptyStateSubmit = new EventEmitter(); // Emitted when in emptyStateMode
-    uploadStateChanged = new EventEmitter(); // Emits when attachment upload state changes
-    inputBox;
+    AgentRunDetected = new EventEmitter();
+    /**
+     * @deprecated Use {@link AgentRunDetected}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (agentRunDetected) keeps working. Must stay AFTER AgentRunDetected: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    agentRunDetected = this.AgentRunDetected;
+    AgentRunUpdate = new EventEmitter();
+    /**
+     * @deprecated Use {@link AgentRunUpdate}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (agentRunUpdate) keeps working. Must stay AFTER AgentRunUpdate: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    agentRunUpdate = this.AgentRunUpdate; // Emits when agent run data updates during progress
+    MessageComplete = new EventEmitter();
+    /**
+     * @deprecated Use {@link MessageComplete}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (messageComplete) keeps working. Must stay AFTER MessageComplete: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    messageComplete = this.MessageComplete; // Emits when message completes (success or error)
+    ArtifactCreated = new EventEmitter();
+    /**
+     * @deprecated Use {@link ArtifactCreated}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (artifactCreated) keeps working. Must stay AFTER ArtifactCreated: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    artifactCreated = this.ArtifactCreated;
+    ConversationRenamed = new EventEmitter();
+    /**
+     * @deprecated Use {@link ConversationRenamed}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (conversationRenamed) keeps working. Must stay AFTER ConversationRenamed: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    conversationRenamed = this.ConversationRenamed;
+    IntentCheckStarted = new EventEmitter();
+    /**
+     * @deprecated Use {@link IntentCheckStarted}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (intentCheckStarted) keeps working. Must stay AFTER IntentCheckStarted: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    intentCheckStarted = this.IntentCheckStarted; // Emits when intent checking starts
+    IntentCheckCompleted = new EventEmitter();
+    /**
+     * @deprecated Use {@link IntentCheckCompleted}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (intentCheckCompleted) keeps working. Must stay AFTER IntentCheckCompleted: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    intentCheckCompleted = this.IntentCheckCompleted; // Emits when intent checking completes (carries conversationId so the parent can drop a background conversation's completion after a swap — symmetric with intentCheckStarted)
+    InitialMessageAutoSendStarted = new EventEmitter();
+    /**
+     * @deprecated Use {@link InitialMessageAutoSendStarted}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (initialMessageAutoSendStarted) keeps working. Must stay AFTER InitialMessageAutoSendStarted: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    initialMessageAutoSendStarted = this.InitialMessageAutoSendStarted; // Emitted when this input latches the pending first message for auto-send
+    InitialMessageAutoSendFailed = new EventEmitter();
+    /**
+     * @deprecated Use {@link InitialMessageAutoSendFailed}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (initialMessageAutoSendFailed) keeps working. Must stay AFTER InitialMessageAutoSendFailed: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    initialMessageAutoSendFailed = this.InitialMessageAutoSendFailed; // Emitted when a latched pending first message fails before messageSent
+    EmptyStateSubmit = new EventEmitter();
+    /**
+     * @deprecated Use {@link EmptyStateSubmit}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (emptyStateSubmit) keeps working. Must stay AFTER EmptyStateSubmit: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    emptyStateSubmit = this.EmptyStateSubmit; // Emitted when in emptyStateMode
+    UploadStateChanged = new EventEmitter();
+    /**
+     * @deprecated Use {@link UploadStateChanged}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (uploadStateChanged) keeps working. Must stay AFTER UploadStateChanged: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    uploadStateChanged = this.UploadStateChanged; // Emits when attachment upload state changes
+    InputBox;
+    /** @deprecated Use {@link InputBox}. */
+    get inputBox() {
+        return this.InputBox;
+    }
+    /** @deprecated Use {@link InputBox}. */
+    set inputBox(value) {
+        this.InputBox = value;
+    }
     _messageText = '';
     /**
      * The composer's text. An accessor pair rather than a plain field because every write reaches the
@@ -274,13 +700,21 @@ export class MessageInputComponent extends BaseAngularComponent {
      * Read is a plain field read; there is no two-way `ngModel` on this property (the template binds
      * `[value]="messageText"` one-way), so the pair is transparent to callers.
      */
-    get messageText() {
+    get MessageText() {
         return this._messageText;
     }
-    set messageText(value) {
+    set MessageText(value) {
         this._messageText = value;
         this.mentionedAgentId = undefined;
     }
+    /** @deprecated Use {@link MessageText}. */
+    get messageText() {
+        return this.MessageText;
+    }
+    /** @deprecated Use {@link MessageText}. */
+    set messageText(value) {
+        this.MessageText = value;
+    }
     /**
      * Prefills the composer with draft text WITHOUT sending (unlike pendingMessage,
      * which auto-sends) and focuses the input — e.g. the omnibar's '@agent' flow
@@ -292,24 +726,40 @@ export class MessageInputComponent extends BaseAngularComponent {
      * view isn't up yet, ngAfterViewInit applies it. Emits initialDraftApplied so the
      * host can clear its pending state.
      */
-    set initialDraft(value) {
+    set InitialDraft(value) {
         if (value && value !== this.appliedInitialDraft) {
             this.appliedInitialDraft = value;
-            if (this.inputBox) {
+            if (this.InputBox) {
                 this.SetDraft(value, true);
-                this.initialDraftApplied.emit();
+                this.InitialDraftApplied.emit();
             }
             else {
                 this.pendingInitialDraft = value;
             }
         }
     }
-    get initialDraft() {
+    get InitialDraft() {
         return this.appliedInitialDraft;
     }
+    /** @deprecated Use {@link InitialDraft}. */
+    get initialDraft() {
+        return this.InitialDraft;
+    }
+    /** @deprecated Use {@link InitialDraft}. */
+    set initialDraft(value) {
+        this.InitialDraft = value;
+    }
     appliedInitialDraft = null;
     pendingInitialDraft = null;
-    initialDraftApplied = new EventEmitter();
+    InitialDraftApplied = new EventEmitter();
+    /**
+     * @deprecated Use {@link InitialDraftApplied}.
+     *
+     * The same emitter under the old binding name, so a template still binding
+     * (initialDraftApplied) keeps working. Must stay AFTER InitialDraftApplied: class fields
+     * initialise in order, and the other way round this captures undefined.
+     */
+    initialDraftApplied = this.InitialDraftApplied;
     /**
      * Live draft-state signal: fires on every composer value change with the
      * SERIALIZED content (mention pills encoded via getPlainTextWithJsonMentions,
@@ -320,12 +770,12 @@ export class MessageInputComponent extends BaseAngularComponent {
     ComposerBlurred = new EventEmitter();
     /** Handles the composer's value stream: keeps messageText in sync + emits draft state. */
     OnComposerValueChanged(value) {
-        this.messageText = value;
+        this.MessageText = value;
         this.DraftStateChanged.emit(this.GetSerializedDraft());
     }
     /** Current composer content in the lossless serialized form ('' when empty). */
     GetSerializedDraft() {
-        const serialized = this.inputBox?.getPlainTextWithJsonMentions() ?? this.messageText ?? '';
+        const serialized = this.InputBox?.getPlainTextWithJsonMentions() ?? this.MessageText ?? '';
         return serialized.trim().length === 0 ? '' : serialized;
     }
     /**
@@ -338,27 +788,27 @@ export class MessageInputComponent extends BaseAngularComponent {
      * @returns false while the composer view isn't mounted yet — callers may retry.
      */
     async InsertAgentMention(agentName, focus = true, clearExisting = true) {
-        if (!this.inputBox) {
+        if (!this.InputBox) {
             console.log(`[Omnibar→Chat] InsertAgentMention('${agentName}'): input box not mounted yet — caller will retry`);
             return false;
         }
         if (clearExisting) {
             // Pre-addressing REPLACES any un-sent draft (tagging agent B after agent A
             // must not stack pills).
-            this.inputBox.mentionEditor?.clear();
-            this.messageText = '';
+            this.InputBox.mentionEditor?.clear();
+            this.MessageText = '';
         }
         try {
-            if (!this.mentionAutocomplete.IsInitialized && this.currentUser) {
+            if (!this.mentionAutocomplete.IsInitialized && this.CurrentUser) {
                 console.log(`[Omnibar→Chat] InsertAgentMention('${agentName}'): initializing mention autocomplete…`);
-                await this.mentionAutocomplete.initialize(this.currentUser);
+                await this.mentionAutocomplete.initialize(this.CurrentUser);
             }
             const wanted = agentName.trim().toLowerCase();
             const suggestion = this.mentionAutocomplete
                 .getSuggestions(agentName, false, '@')
                 .find(s => s.type === 'agent' && s.name.trim().toLowerCase() === wanted);
             if (suggestion) {
-                const inserted = this.inputBox.InsertMention(suggestion, focus);
+                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)'}`);
                 if (inserted) {
                     if (focus) {
@@ -385,7 +835,7 @@ export class MessageInputComponent extends BaseAngularComponent {
     scheduleFocusReassert(context) {
         for (const delay of [300, 900, 1800]) {
             setTimeout(() => {
-                const editor = this.inputBox?.mentionEditor;
+                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'}`);
@@ -394,18 +844,66 @@ export class MessageInputComponent extends BaseAngularComponent {
         }
     }
     SetDraft(text, focus = true) {
-        this.messageText = text;
+        this.MessageText = text;
         if (focus) {
             // The composer mounts/binds on the next tick after messageText flows down.
-            setTimeout(() => this.inputBox?.focus(), 50);
-        }
+            setTimeout(() => this.InputBox?.focus(), 50);
+        }
+    }
+    IsSending = false;
+    /** @deprecated Use {@link IsSending}. */
+    get isSending() {
+        return this.IsSending;
+    }
+    /** @deprecated Use {@link IsSending}. */
+    set isSending(value) {
+        this.IsSending = value;
+    }
+    IsProcessing = false;
+    /** @deprecated Use {@link IsProcessing}. */
+    get isProcessing() {
+        return this.IsProcessing;
+    }
+    /** @deprecated Use {@link IsProcessing}. */
+    set isProcessing(value) {
+        this.IsProcessing = value;
+    } // True when waiting for agent/naming response
+    ProcessingMessage = 'AI is responding...';
+    /** @deprecated Use {@link ProcessingMessage}. */
+    get processingMessage() {
+        return this.ProcessingMessage;
+    }
+    /** @deprecated Use {@link ProcessingMessage}. */
+    set processingMessage(value) {
+        this.ProcessingMessage = value;
+    } // Message shown during processing
+    IsUploadingAttachments = false;
+    /** @deprecated Use {@link IsUploadingAttachments}. */
+    get isUploadingAttachments() {
+        return this.IsUploadingAttachments;
+    }
+    /** @deprecated Use {@link IsUploadingAttachments}. */
+    set isUploadingAttachments(value) {
+        this.IsUploadingAttachments = value;
+    } // True when uploading attachments to server
+    UploadingMessage = 'Uploading attachments...';
+    /** @deprecated Use {@link UploadingMessage}. */
+    get uploadingMessage() {
+        return this.UploadingMessage;
+    }
+    /** @deprecated Use {@link UploadingMessage}. */
+    set uploadingMessage(value) {
+        this.UploadingMessage = value;
+    } // Message shown during upload
+    ConverationManagerAgent = null;
+    /** @deprecated Use {@link ConverationManagerAgent}. */
+    get converationManagerAgent() {
+        return this.ConverationManagerAgent;
+    }
+    /** @deprecated Use {@link ConverationManagerAgent}. */
+    set converationManagerAgent(value) {
+        this.ConverationManagerAgent = value;
     }
-    isSending = false;
-    isProcessing = false; // True when waiting for agent/naming response
-    processingMessage = 'AI is responding...'; // Message shown during processing
-    isUploadingAttachments = false; // True when uploading attachments to server
-    uploadingMessage = 'Uploading attachments...'; // Message shown during upload
-    converationManagerAgent = null;
     // Track completion timestamps to prevent race conditions with late progress updates
     completionTimestamps = new Map();
     // Track registered streaming callbacks for cleanup
@@ -437,7 +935,15 @@ export class MessageInputComponent extends BaseAngularComponent {
     }
     // ── Voice session (Realtime Co-Agent) ───────────────────────────────
     /** True while a live voice session is active — drives the overlay + mic state. */
-    voiceActive = false;
+    VoiceActive = false;
+    /** @deprecated Use {@link VoiceActive}. */
+    get voiceActive() {
+        return this.VoiceActive;
+    }
+    /** @deprecated Use {@link VoiceActive}. */
+    set voiceActive(value) {
+        this.VoiceActive = value;
+    }
     realtimeActiveSub;
     async ngOnInit() {
         // Bind provider-aware services to this component's provider.
@@ -449,16 +955,16 @@ export class MessageInputComponent extends BaseAngularComponent {
         this.realtimeSession.Provider = p;
         // Reflect the live voice-session Active flag into a local field for the template.
         this.realtimeActiveSub = this.realtimeSession.Active$.subscribe(active => {
-            this.voiceActive = active;
+            this.VoiceActive = active;
         });
-        this.converationManagerAgent = await this.agentService.getConversationManagerAgent();
+        this.ConverationManagerAgent = await this.agentService.getConversationManagerAgent();
         // Warm UserInfoEngine so the PlanModeEnabled getter has the cached settings available
         // (no-op when already loaded; failure just leaves the toggle at its default OFF).
         PlanModePreference.Warm();
         // Initialize mention autocomplete (needed for parsing mentions in messages)
-        await this.mentionAutocomplete.initialize(this.currentUser);
+        await this.mentionAutocomplete.initialize(this.CurrentUser);
         // Reconnect to any in-progress messages for streaming updates (via global streaming service)
-        this.reconnectInProgressMessages();
+        this.ReconnectInProgressMessages();
     }
     ngOnChanges(changes) {
         // When conversation changes, focus the input
@@ -474,7 +980,7 @@ export class MessageInputComponent extends BaseAngularComponent {
             // next tick — the composer's own view finishes mounting first
             setTimeout(() => {
                 this.SetDraft(draft, true);
-                this.initialDraftApplied.emit();
+                this.InitialDraftApplied.emit();
             }, 50);
         }
         // Focus input on initial load
@@ -491,26 +997,29 @@ export class MessageInputComponent extends BaseAngularComponent {
      * Called from setter or ngAfterViewInit when conditions are met.
      */
     triggerInitialSend() {
+        if (this.ReadOnly) {
+            return;
+        }
         const message = this._initialMessage;
         const attachments = this._initialAttachments;
         const hasContent = !!message || !!(attachments && attachments.length > 0);
-        if (!hasContent || !this.conversationId || UUIDsEqual(this._autoSentForConversationId, this.conversationId)) {
+        if (!hasContent || !this.ConversationId || UUIDsEqual(this._autoSentForConversationId, this.ConversationId)) {
             return;
         }
-        this._autoSentForConversationId = this.conversationId;
+        this._autoSentForConversationId = this.ConversationId;
         // Set pending attachments before sending
         if (attachments && attachments.length > 0) {
             this.pendingAttachments = [...attachments];
         }
         Promise.resolve().then(() => {
-            this.initialMessageAutoSendStarted.emit({ conversationId: this.conversationId });
+            this.InitialMessageAutoSendStarted.emit({ conversationId: this.ConversationId });
         });
         // Use setTimeout to ensure we're outside of change detection cycle
         setTimeout(async () => {
-            const sent = await this.sendMessageWithText(message || '');
+            const sent = await this.SendMessageWithText(message || '');
             if (!sent) {
                 this._autoSentForConversationId = null;
-                this.initialMessageAutoSendFailed.emit({ conversationId: this.conversationId });
+                this.InitialMessageAutoSendFailed.emit({ conversationId: this.ConversationId });
             }
         }, 100);
     }
@@ -531,14 +1040,17 @@ export class MessageInputComponent extends BaseAngularComponent {
      *   2. per-conversation pinned default
      *   3. embedder-supplied default
      *   4. Sage fallback
-     * Returns null only if Sage itself failed to load.
+     * skipping any agent outside {@link AllowedAgentIDs}. {@link AgentReplyMode} does not apply:
+     * starting a call is itself a choice to talk to an agent. Returns null when Sage failed to
+     * load, or when the host allows none of these agents.
      */
+    ResolveCurrentAgentId() {
+        const target = ResolveAgentTurn(this.agentTurnCandidates([]), { ReplyMode: 'Always', AllowedAgentIDs: this.AllowedAgentIDs }, () => true);
+        return target?.AgentId ?? null;
+    }
+    /** @deprecated Use {@link ResolveCurrentAgentId}. */
     resolveCurrentAgentId() {
-        return this.findLastNonSageAgentId()
-            ?? this.conversationDefaultAgentId
-            ?? this.defaultAgentId
-            ?? this.converationManagerAgent?.ID
-            ?? null;
+        return this.ResolveCurrentAgentId();
     }
     /**
      * The agent the '/' skill picker should narrow to. Mirrors routing's priority: an explicit
@@ -546,12 +1058,16 @@ export class MessageInputComponent extends BaseAngularComponent {
      * would otherwise go to ({@link resolveCurrentAgentId}). Bound to `mj-ai-composer`'s
      * `TargetAgentId`; null = unknown, no narrowing.
      */
-    get pickerTargetAgentId() {
+    get PickerTargetAgentId() {
         if (this.mentionedAgentId === undefined) {
-            const chips = this.inputBox?.getMentionChipsData() || [];
+            const chips = this.InputBox?.getMentionChipsData() || [];
             this.mentionedAgentId = chips.find(chip => chip.type === 'agent')?.id ?? null;
         }
-        return this.mentionedAgentId ?? this.resolveCurrentAgentId();
+        return this.mentionedAgentId ?? this.ResolveCurrentAgentId();
+    }
+    /** @deprecated Use {@link PickerTargetAgentId}. */
+    get pickerTargetAgentId() {
+        return this.PickerTargetAgentId;
     }
     /**
      * Memo for the first `@agent` chip in the draft, so the template-bound
@@ -582,8 +1098,12 @@ export class MessageInputComponent extends BaseAngularComponent {
      */
     mentionedAgentId = undefined;
     /** True when the mic button should be enabled (have an agent + not disabled). */
+    get CanStartRealtime() {
+        return !this.ReadOnly && !this.Disabled && !this.VoiceActive && !!this.ResolveCurrentAgentId();
+    }
+    /** @deprecated Use {@link CanStartRealtime}. */
     get canStartRealtime() {
-        return !this.disabled && !this.voiceActive && !!this.resolveCurrentAgentId();
+        return this.CanStartRealtime;
     }
     /**
      * Display name of the agent the voice session fronts. Resolved here (this component
@@ -591,7 +1111,7 @@ export class MessageInputComponent extends BaseAngularComponent {
      * session start so the chat-area-hosted overlay can read it from the service.
      */
     resolveRealtimeAgentName() {
-        const agentId = this.resolveCurrentAgentId();
+        const agentId = this.ResolveCurrentAgentId();
         if (agentId) {
             const match = this.mentionAutocomplete
                 .getAvailableAgents()
@@ -600,10 +1120,18 @@ export class MessageInputComponent extends BaseAngularComponent {
                 return match.Name;
             }
         }
-        return this.converationManagerAgent?.Name ?? 'Sage';
+        return this.ConverationManagerAgent?.Name ?? 'Sage';
     }
     /** True while the "Start a voice call with…" agent picker popover is open. */
-    showRealtimeAgentPicker = false;
+    ShowRealtimeAgentPicker = false;
+    /** @deprecated Use {@link ShowRealtimeAgentPicker}. */
+    get showRealtimeAgentPicker() {
+        return this.ShowRealtimeAgentPicker;
+    }
+    /** @deprecated Use {@link ShowRealtimeAgentPicker}. */
+    set showRealtimeAgentPicker(value) {
+        this.ShowRealtimeAgentPicker = value;
+    }
     /**
      * CDK connected-overlay positions for the voice agent picker. Preferred: open UPWARD,
      * right edge aligned to the composer's right edge (matching the old absolute placement).
@@ -611,40 +1139,79 @@ export class MessageInputComponent extends BaseAngularComponent {
      * body-level CDK overlay container (with `cdkConnectedOverlayPush`), it escapes the chat
      * overlay's `overflow: hidden` border and can never clip at the top of a narrow overlay.
      */
-    pickerOverlayPositions = [
+    PickerOverlayPositions = [
         { originX: 'end', originY: 'top', overlayX: 'end', overlayY: 'bottom', offsetY: -8 },
         { originX: 'end', originY: 'bottom', overlayX: 'end', overlayY: 'top', offsetY: 8 },
     ];
+    /** @deprecated Use {@link PickerOverlayPositions}. */
+    get pickerOverlayPositions() {
+        return this.PickerOverlayPositions;
+    }
     /**
      * `MJ: User Settings` key persisting the user's co-agent choice for realtime calls
      * (server-side, cross-device — never localStorage). Stored shape: `{"coAgentId":
      * string | null}` — `null` is an explicit "Auto" choice that overwrites an older pick.
      */
-    static CoAgentPrefKey = 'mj.realtimeVoice.coAgent.v1';
+    static coAgentPrefKey = 'mj.realtimeVoice.coAgent.v1';
     /**
      * The persisted co-agent preference, loaded just before the picker opens (and read by
      * the instant-start path). `null` = no preference / explicit "Auto".
      */
-    voicePickerDefaultCoAgentId = null;
+    VoicePickerDefaultCoAgentId = null;
+    /** @deprecated Use {@link VoicePickerDefaultCoAgentId}. */
+    get voicePickerDefaultCoAgentId() {
+        return this.VoicePickerDefaultCoAgentId;
+    }
+    /** @deprecated Use {@link VoicePickerDefaultCoAgentId}. */
+    set voicePickerDefaultCoAgentId(value) {
+        this.VoicePickerDefaultCoAgentId = value;
+    }
     /**
      * Agents the voice picker offers — the same cached set the @mention
-     * autocomplete and {@link resolveRealtimeAgentName} use, so the picker can
-     * never offer an agent the conversation couldn't otherwise route to.
-     */
+     * autocomplete and {@link resolveRealtimeAgentName} use, narrowed to
+     * {@link AllowedAgentIDs}, so the picker can never offer an agent the
+     * conversation couldn't otherwise route to.
+     */
+    get VoicePickerAgents() {
+        const agents = this.mentionAutocomplete.getAvailableAgents();
+        const allowed = this.AllowedAgentIDs;
+        if (allowed == null) {
+            return agents;
+        }
+        // Memoized on both inputs: the picker binds this getter, and a fresh array on every
+        // change-detection pass would look like a new input each time.
+        const memo = this.voicePickerAgentsMemo;
+        if (memo && memo.Source === agents && memo.Allowed === allowed) {
+            return memo.Result;
+        }
+        const result = agents.filter(agent => IsAgentAllowed(agent.ID, allowed));
+        this.voicePickerAgentsMemo = { Source: agents, Allowed: allowed, Result: result };
+        return result;
+    }
+    voicePickerAgentsMemo = null;
+    /** @deprecated Use {@link VoicePickerAgents}. */
     get voicePickerAgents() {
-        return this.mentionAutocomplete.getAvailableAgents();
+        return this.VoicePickerAgents;
     }
     /**
      * The ACTIVE Realtime-type co-agent candidates — the same run-permission-filtered
      * cached set as {@link voicePickerAgents}, narrowed to the Realtime agent type. The
      * picker shows its co-agent selector only when more than one exists.
      */
-    get voicePickerCoAgents() {
+    get VoicePickerCoAgents() {
         return FilterRealtimeCoAgents(this.mentionAutocomplete.getAvailableAgents());
     }
+    /** @deprecated Use {@link VoicePickerCoAgents}. */
+    get voicePickerCoAgents() {
+        return this.VoicePickerCoAgents;
+    }
     /** The agent the default resolution would call — preselected in the picker. */
+    get VoicePickerDefaultAgentId() {
+        return this.ResolveCurrentAgentId();
+    }
+    /** @deprecated Use {@link VoicePickerDefaultAgentId}. */
     get voicePickerDefaultAgentId() {
-        return this.resolveCurrentAgentId();
+        return this.VoicePickerDefaultAgentId;
     }
     /**
      * Start a real-time voice session fronting the conversation's current agent.
@@ -660,18 +1227,18 @@ export class MessageInputComponent extends BaseAngularComponent {
      *   the user never chose — so show a compact agent picker instead and start
      *   with whichever agent they pick.
      */
-    async onStartRealtime() {
-        if (!this.canStartRealtime) {
+    async OnStartRealtime() {
+        if (!this.CanStartRealtime) {
             return;
         }
         // New/empty conversation (no prior agent turn): let the user choose who
         // to call. Falls through to the immediate path if the agent cache is
         // empty (nothing to pick from — the resolved default is the only option).
-        if (!this.findLastNonSageAgentId() && this.voicePickerAgents.length > 0) {
+        if (!this.findLastNonSageAgentId() && this.VoicePickerAgents.length > 0) {
             await this.openRealtimeAgentPicker();
             return;
         }
-        const targetAgentId = this.resolveCurrentAgentId();
+        const targetAgentId = this.ResolveCurrentAgentId();
         if (!targetAgentId) {
             this.toastService.error('No agent available for a voice session.');
             return;
@@ -679,6 +1246,10 @@ export class MessageInputComponent extends BaseAngularComponent {
         const coAgentId = await this.resolveInstantCoAgentId(targetAgentId);
         await this.startRealtimeWithAgent(targetAgentId, this.resolveRealtimeAgentName(), null, coAgentId);
     }
+    /** @deprecated Use {@link OnStartRealtime}. */
+    async onStartRealtime() {
+        return this.OnStartRealtime();
+    }
     /**
      * Caret-next-to-the-phone click: open the agent/co-agent/model picker ON DEMAND, even
      * when the conversation already has agent history (where the plain phone click
@@ -687,27 +1258,35 @@ export class MessageInputComponent extends BaseAngularComponent {
      * choice one click away. Falls through to the instant path when there is nothing to
      * pick from.
      */
-    async onRealtimeOptions() {
-        if (!this.canStartRealtime) {
+    async OnRealtimeOptions() {
+        if (!this.CanStartRealtime) {
             return;
         }
-        if (this.voicePickerAgents.length > 0) {
+        if (this.VoicePickerAgents.length > 0) {
             await this.openRealtimeAgentPicker();
             return;
         }
-        void this.onStartRealtime();
+        void this.OnStartRealtime();
+    }
+    /** @deprecated Use {@link OnRealtimeOptions}. */
+    async onRealtimeOptions() {
+        return this.OnRealtimeOptions();
     }
     /** Loads the persisted co-agent preference, then shows the picker (pref preselected). */
     async openRealtimeAgentPicker() {
-        this.voicePickerDefaultCoAgentId = await this.loadPersistedCoAgentId();
-        this.showRealtimeAgentPicker = true;
+        this.VoicePickerDefaultCoAgentId = await this.loadPersistedCoAgentId();
+        this.ShowRealtimeAgentPicker = true;
     }
     /** User confirmed an agent (+ optional co-agent / voice model) in the voice picker — start the call. */
-    async onRealtimeAgentPicked(pick) {
-        this.showRealtimeAgentPicker = false;
+    async OnRealtimeAgentPicked(pick) {
+        this.ShowRealtimeAgentPicker = false;
         this.persistCoAgentChoice(pick.CoAgentId);
         await this.startRealtimeWithAgent(pick.Agent.ID, pick.Agent.Name || this.resolveRealtimeAgentName(), pick.PreferredModelId, pick.CoAgentId, BuildRealtimeConfigOverridesJson(pick.PreferredModelId, pick.PreferredVoice), pick.RecordingConsent);
     }
+    /** @deprecated Use {@link OnRealtimeAgentPicked}. */
+    async onRealtimeAgentPicked(pick) {
+        return this.OnRealtimeAgentPicked(pick);
+    }
     /**
      * Reads the persisted co-agent preference from `MJ: User Settings` (via
      * `UserInfoEngine`'s cached settings). Defensive: any failure or malformed payload
@@ -716,7 +1295,7 @@ export class MessageInputComponent extends BaseAngularComponent {
     async loadPersistedCoAgentId() {
         try {
             await UserInfoEngine.Instance.Config();
-            const raw = UserInfoEngine.Instance.GetSetting(MessageInputComponent.CoAgentPrefKey);
+            const raw = UserInfoEngine.Instance.GetSetting(MessageInputComponent.coAgentPrefKey);
             if (!raw) {
                 return null;
             }
@@ -730,7 +1309,7 @@ export class MessageInputComponent extends BaseAngularComponent {
     /** Persists the user's co-agent choice (including explicit "Auto" = null) cross-device. */
     persistCoAgentChoice(coAgentId) {
         try {
-            UserInfoEngine.Instance.SetSettingDebounced(MessageInputComponent.CoAgentPrefKey, JSON.stringify({ coAgentId: coAgentId ?? null }));
+            UserInfoEngine.Instance.SetSettingDebounced(MessageInputComponent.coAgentPrefKey, JSON.stringify({ coAgentId: coAgentId ?? null }));
         }
         catch (error) {
             console.warn('[MessageInput] Failed to persist co-agent preference:', error);
@@ -749,7 +1328,7 @@ export class MessageInputComponent extends BaseAngularComponent {
         if (!preferred) {
             return null;
         }
-        const isValidCandidate = this.voicePickerCoAgents.some(a => UUIDsEqual(a.ID, preferred));
+        const isValidCandidate = this.VoicePickerCoAgents.some(a => UUIDsEqual(a.ID, preferred));
         if (!isValidCandidate) {
             return null;
         }
@@ -757,8 +1336,12 @@ export class MessageInputComponent extends BaseAngularComponent {
         return PairingsAllowTarget(pairings, targetAgentId) ? preferred : null;
     }
     /** User dismissed the voice picker without starting a call. */
+    OnRealtimeAgentPickerCancelled() {
+        this.ShowRealtimeAgentPicker = false;
+    }
+    /** @deprecated Use {@link OnRealtimeAgentPickerCancelled}. */
     onRealtimeAgentPickerCancelled() {
-        this.showRealtimeAgentPicker = false;
+        return this.OnRealtimeAgentPickerCancelled();
     }
     /**
      * Shared session-start path for both the immediate (existing conversation)
@@ -777,11 +1360,11 @@ export class MessageInputComponent extends BaseAngularComponent {
      */
     async startRealtimeWithAgent(agentId, agentName, preferredModelId, coAgentId, configOverridesJson, recordingConsent) {
         try {
-            await this.realtimeSession.StartRealtimeSession(agentId, this.conversationId, null, agentName, preferredModelId ?? null, null, coAgentId ?? null, configOverridesJson ?? null, recordingConsent ?? null, null, 
+            await this.realtimeSession.StartRealtimeSession(agentId, this.ConversationId, null, agentName, preferredModelId ?? null, null, coAgentId ?? null, configOverridesJson ?? null, recordingConsent ?? null, null, 
             // App awareness: the app the session runs in + the live app-context snapshot (where the
             // user is, what they see, capability manifest) — drives the server-side app cascade + the
             // mint-time prompt injection, and seeds the ClientContextChannel's streaming.
-            this.applicationId, this.appContext);
+            this.ApplicationId, this.AppContext);
         }
         catch (error) {
             console.error('Failed to start voice session:', error);
@@ -794,8 +1377,8 @@ export class MessageInputComponent extends BaseAngularComponent {
     focusInput() {
         // Use setTimeout to ensure DOM is ready
         setTimeout(() => {
-            if (this.inputBox) {
-                this.inputBox.focus();
+            if (this.InputBox) {
+                this.InputBox.focus();
             }
         }, 100);
     }
@@ -807,14 +1390,14 @@ export class MessageInputComponent extends BaseAngularComponent {
      * 3. User returns to a conversation with in-progress messages
      * 4. Parent component explicitly triggers reconnection
      */
-    reconnectInProgressMessages() {
-        if (!this.inProgressMessageIds || this.inProgressMessageIds.length === 0) {
+    ReconnectInProgressMessages() {
+        if (!this.InProgressMessageIds || this.InProgressMessageIds.length === 0) {
             return;
         }
         // Unregister any previously registered callbacks for this component
         this.unregisterAllCallbacks();
         // Register new callbacks for each in-progress message
-        for (const messageId of this.inProgressMessageIds) {
+        for (const messageId of this.InProgressMessageIds) {
             // Create callback bound to this message ID
             const callback = this.createMessageProgressCallback(messageId);
             // Store reference for cleanup
@@ -823,6 +1406,10 @@ export class MessageInputComponent extends BaseAngularComponent {
             this.streamingService.registerMessageCallback(messageId, callback);
         }
     }
+    /** @deprecated Use {@link ReconnectInProgressMessages}. */
+    reconnectInProgressMessages() {
+        return this.ReconnectInProgressMessages();
+    }
     /**
      * Create a progress callback for a specific message ID.
      * This callback will be invoked by the streaming service when progress updates arrive.
@@ -835,7 +1422,7 @@ export class MessageInputComponent extends BaseAngularComponent {
         return async (progress) => {
             try {
                 // Get message from cache (single source of truth)
-                const message = (resolvedMessage ??= await this.dataCache.getConversationDetail(messageId, this.currentUser));
+                const message = (resolvedMessage ??= await this.dataCache.getConversationDetail(messageId, this.CurrentUser));
                 if (!message) {
                     console.warn(`[StreamingCallback] Message ${messageId} not found in cache`);
                     return;
@@ -857,7 +1444,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                 // bubble with the server-saved final message, so no append/merge is needed here.
                 if (progress.streaming) {
                     message.Message = progress.streaming.content;
-                    this.messageSent.emit(message);
+                    this.MessageSent.emit(message);
                     // Keep the tasks dropdown on a stable status line rather than the growing reply text.
                     this.activeTasks.updateStatusByConversationDetailId(message.ID, 'Responding…');
                     return;
@@ -875,7 +1462,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                 // Server now saves progress - client only updates in-memory and emits for UI
                 // (Prevents race condition where client's late save overwrites server's final Status)
                 // CRITICAL: Emit update to trigger UI refresh
-                this.messageSent.emit(message);
+                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'}`);
@@ -899,25 +1486,40 @@ export class MessageInputComponent extends BaseAngularComponent {
         }
         this.registeredCallbacks.clear();
     }
+    get CanSend() {
+        return !this.ReadOnly && !this.Disabled && !this.IsSending && this.MessageText.trim().length > 0;
+    }
+    /** @deprecated Use {@link CanSend}. */
     get canSend() {
-        return !this.disabled && !this.isSending && this.messageText.trim().length > 0;
+        return this.CanSend;
     }
     /**
      * Handle attachments changed from the input box
      */
-    onAttachmentsChanged(attachments) {
+    OnAttachmentsChanged(attachments) {
         this.pendingAttachments = attachments;
     }
+    /** @deprecated Use {@link OnAttachmentsChanged}. */
+    onAttachmentsChanged(attachments) {
+        return this.OnAttachmentsChanged(attachments);
+    }
     /**
      * Handle attachment errors from the input box
      */
-    onAttachmentError(error) {
+    OnAttachmentError(error) {
         this.toastService.error(error);
     }
+    /** @deprecated Use {@link OnAttachmentError}. */
+    onAttachmentError(error) {
+        return this.OnAttachmentError(error);
+    }
     /**
      * Handle text submitted from the input box
      */
-    async onTextSubmitted(text) {
+    async OnTextSubmitted(text) {
+        if (this.ReadOnly) {
+            return;
+        }
         // Check if we have either text or attachments
         const hasText = text && text.trim().length > 0;
         const hasAttachments = this.pendingAttachments.length > 0;
@@ -925,14 +1527,14 @@ export class MessageInputComponent extends BaseAngularComponent {
             return;
         }
         // In empty state mode, just emit the data and let parent handle conversation creation
-        if (this.emptyStateMode) {
+        if (this.EmptyStateMode) {
             const attachmentsToEmit = [...this.pendingAttachments];
             this.pendingAttachments = [];
-            this.messageText = '';
-            this.emptyStateSubmit.emit({ text: text?.trim() || '', attachments: attachmentsToEmit });
+            this.MessageText = '';
+            this.EmptyStateSubmit.emit({ text: text?.trim() || '', attachments: attachmentsToEmit });
             return;
         }
-        this.isSending = true;
+        this.IsSending = true;
         // Store attachments locally since we'll clear them after send
         const attachmentsToSave = [...this.pendingAttachments];
         try {
@@ -944,12 +1546,12 @@ export class MessageInputComponent extends BaseAngularComponent {
                 // separately when building AI messages - no need to add tokens to Message field
                 if (attachmentsToSave.length > 0) {
                     // Show upload indicator for attachments
-                    this.isUploadingAttachments = true;
-                    this.uploadingMessage = `Uploading ${attachmentsToSave.length} attachment${attachmentsToSave.length > 1 ? 's' : ''}...`;
-                    this.uploadStateChanged.emit({ isUploading: true, message: this.uploadingMessage });
+                    this.IsUploadingAttachments = true;
+                    this.UploadingMessage = `Uploading ${attachmentsToSave.length} attachment${attachmentsToSave.length > 1 ? 's' : ''}...`;
+                    this.UploadStateChanged.emit({ isUploading: true, message: this.UploadingMessage });
                     let attachmentRejection = null;
                     try {
-                        await this.attachmentService.saveAttachments(messageDetail.ID, attachmentsToSave, this.currentUser);
+                        await this.attachmentService.saveAttachments(messageDetail.ID, attachmentsToSave, this.CurrentUser);
                     }
                     catch (attachmentError) {
                         console.error('Failed to save attachments:', attachmentError);
@@ -958,8 +1560,8 @@ export class MessageInputComponent extends BaseAngularComponent {
                             : 'Some attachments could not be saved';
                     }
                     finally {
-                        this.isUploadingAttachments = false;
-                        this.uploadStateChanged.emit({ isUploading: false, message: '' });
+                        this.IsUploadingAttachments = false;
+                        this.UploadStateChanged.emit({ isUploading: false, message: '' });
                     }
                     // Plan §6: when attachments are rejected, the message itself must
                     // not go through. Roll back the ConversationDetail and notify the
@@ -974,7 +1576,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                         catch (rollbackErr) {
                             console.error('Failed to roll back conversation detail after attachment rejection:', rollbackErr);
                         }
-                        this.isSending = false;
+                        this.IsSending = false;
                         return;
                     }
                 }
@@ -990,9 +1592,13 @@ export class MessageInputComponent extends BaseAngularComponent {
             this.handleSendError(error);
         }
         finally {
-            this.isSending = false;
+            this.IsSending = false;
         }
     }
+    /** @deprecated Use {@link OnTextSubmitted}. */
+    async onTextSubmitted(text) {
+        return this.OnTextSubmitted(text);
+    }
     /**
      * Toggle sticky Plan Mode for THIS conversation (or the pending-new bucket on the
      * new-conversation composer). Writes through {@link PlanModePreference} — the
@@ -1001,12 +1607,12 @@ export class MessageInputComponent extends BaseAngularComponent {
      * until the user turns it off or approves a plan.
      */
     TogglePlanMode() {
-        PlanModePreference.Set(this.conversationId, !this.PlanModeEnabled);
+        PlanModePreference.Set(this.ConversationId, !this.PlanModeEnabled);
     }
-    async onSend() {
-        if (!this.canSend)
+    async OnSend() {
+        if (!this.CanSend)
             return;
-        this.isSending = true;
+        this.IsSending = true;
         try {
             const messageDetail = await this.createMessageDetail();
             const saved = await messageDetail.Save();
@@ -1021,9 +1627,13 @@ export class MessageInputComponent extends BaseAngularComponent {
             this.handleSendError(error);
         }
         finally {
-            this.isSending = false;
+            this.IsSending = false;
         }
     }
+    /** @deprecated Use {@link OnSend}. */
+    async onSend() {
+        return this.OnSend();
+    }
     /**
      * Send a message with custom text WITHOUT modifying the visible messageText input
      * Used for suggested responses and initial messages from empty state.
@@ -1035,7 +1645,10 @@ export class MessageInputComponent extends BaseAngularComponent {
      * `this.pendingAttachments` may not contain the attachment. Pass it in
      * explicitly and we merge + dedupe (by `id`) before saving.
      */
-    async sendMessageWithText(text, extraAttachments) {
+    async SendMessageWithText(text, extraAttachments) {
+        if (this.ReadOnly) {
+            return false;
+        }
         const merged = (() => {
             if (!extraAttachments || extraAttachments.length === 0) {
                 return [...this.pendingAttachments];
@@ -1055,31 +1668,31 @@ export class MessageInputComponent extends BaseAngularComponent {
         if (!hasText && !hasAttachments) {
             return false;
         }
-        if (this.isSending) {
+        if (this.IsSending) {
             return false;
         }
-        this.isSending = true;
+        this.IsSending = true;
         const attachmentsToSave = merged;
         try {
-            const detail = await this.dataCache.createConversationDetail(this.currentUser);
-            detail.ConversationID = this.conversationId;
+            const detail = await this.dataCache.createConversationDetail(this.CurrentUser);
+            detail.ConversationID = this.ConversationId;
             detail.Message = text?.trim() || '';
             detail.Role = 'User';
-            detail.UserID = this.currentUser.ID; // Set the user who sent the message
-            if (this.parentMessageId) {
-                detail.ParentID = this.parentMessageId;
+            detail.UserID = this.CurrentUser.ID; // Set the user who sent the message
+            if (this.ParentMessageId) {
+                detail.ParentID = this.ParentMessageId;
             }
             const saved = await detail.Save();
             if (saved) {
                 // Save attachments if any were pending
                 if (attachmentsToSave.length > 0) {
                     // Show upload indicator for attachments
-                    this.isUploadingAttachments = true;
-                    this.uploadingMessage = `Uploading ${attachmentsToSave.length} attachment${attachmentsToSave.length > 1 ? 's' : ''}...`;
-                    this.uploadStateChanged.emit({ isUploading: true, message: this.uploadingMessage });
+                    this.IsUploadingAttachments = true;
+                    this.UploadingMessage = `Uploading ${attachmentsToSave.length} attachment${attachmentsToSave.length > 1 ? 's' : ''}...`;
+                    this.UploadStateChanged.emit({ isUploading: true, message: this.UploadingMessage });
                     let attachmentRejection = null;
                     try {
-                        await this.attachmentService.saveAttachments(detail.ID, attachmentsToSave, this.currentUser);
+                        await this.attachmentService.saveAttachments(detail.ID, attachmentsToSave, this.CurrentUser);
                     }
                     catch (attachmentError) {
                         console.error('Failed to save attachments:', attachmentError);
@@ -1088,8 +1701,8 @@ export class MessageInputComponent extends BaseAngularComponent {
                             : 'Some attachments could not be saved';
                     }
                     finally {
-                        this.isUploadingAttachments = false;
-                        this.uploadStateChanged.emit({ isUploading: false, message: '' });
+                        this.IsUploadingAttachments = false;
+                        this.UploadStateChanged.emit({ isUploading: false, message: '' });
                     }
                     // Plan §6: roll back the message when attachments are rejected so
                     // the user sees the rejection clearly instead of the agent answering
@@ -1102,7 +1715,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                         catch (rollbackErr) {
                             console.error('Failed to roll back conversation detail after attachment rejection:', rollbackErr);
                         }
-                        this.isSending = false;
+                        this.IsSending = false;
                         return false;
                     }
                 }
@@ -1112,10 +1725,10 @@ export class MessageInputComponent extends BaseAngularComponent {
                 // The user-initiated send path (MessageInputBoxComponent.onSendClick)
                 // calls mentionEditor.clear() — we bypass that path here, so the chips
                 // would otherwise stay on screen after the message goes out.
-                this.inputBox?.mentionEditor?.clear();
-                this.messageSent.emit(detail);
+                this.InputBox?.mentionEditor?.clear();
+                this.MessageSent.emit(detail);
                 const mentionResult = this.parseMentionsFromMessage(detail.Message);
-                const isFirstMessage = this.conversationHistory.length === 0;
+                const isFirstMessage = this.ConversationHistory.length === 0;
                 await this.routeMessage(detail, mentionResult, isFirstMessage);
                 return true;
             }
@@ -1129,20 +1742,24 @@ export class MessageInputComponent extends BaseAngularComponent {
             return false;
         }
         finally {
-            this.isSending = false;
+            this.IsSending = false;
         }
     }
+    /** @deprecated Use {@link SendMessageWithText}. */
+    async sendMessageWithText(text, extraAttachments) {
+        return this.SendMessageWithText(text, extraAttachments);
+    }
     /**
      * Creates and configures a new conversation detail message
      */
     async createMessageDetail() {
-        const detail = await this.dataCache.createConversationDetail(this.currentUser);
-        detail.ConversationID = this.conversationId;
-        detail.Message = this.messageText.trim();
+        const detail = await this.dataCache.createConversationDetail(this.CurrentUser);
+        detail.ConversationID = this.ConversationId;
+        detail.Message = this.MessageText.trim();
         detail.Role = 'User';
-        detail.UserID = this.currentUser.ID; // Set the user who sent the message
-        if (this.parentMessageId) {
-            detail.ParentID = this.parentMessageId;
+        detail.UserID = this.CurrentUser.ID; // Set the user who sent the message
+        if (this.ParentMessageId) {
+            detail.ParentID = this.ParentMessageId;
         }
         return detail;
     }
@@ -1150,13 +1767,13 @@ export class MessageInputComponent extends BaseAngularComponent {
      * Creates and configures a new conversation detail message from provided text
      */
     async createMessageDetailFromText(text) {
-        const detail = await this.dataCache.createConversationDetail(this.currentUser);
-        detail.ConversationID = this.conversationId;
+        const detail = await this.dataCache.createConversationDetail(this.CurrentUser);
+        detail.ConversationID = this.ConversationId;
         detail.Message = text;
         detail.Role = 'User';
-        detail.UserID = this.currentUser.ID; // Set the user who sent the message
-        if (this.parentMessageId) {
-            detail.ParentID = this.parentMessageId;
+        detail.UserID = this.CurrentUser.ID; // Set the user who sent the message
+        if (this.ParentMessageId) {
+            detail.ParentID = this.ParentMessageId;
         }
         return detail;
     }
@@ -1164,10 +1781,10 @@ export class MessageInputComponent extends BaseAngularComponent {
      * Handles successful message send - routes to appropriate agent
      */
     async handleSuccessfulSend(messageDetail) {
-        this.messageSent.emit(messageDetail);
-        this.messageText = '';
+        this.MessageSent.emit(messageDetail);
+        this.MessageText = '';
         const mentionResult = this.parseMentionsFromMessage(messageDetail.Message);
-        const isFirstMessage = this.conversationHistory.length === 0;
+        const isFirstMessage = this.ConversationHistory.length === 0;
         await this.routeMessage(messageDetail, mentionResult, isFirstMessage);
         this.refocusTextarea();
     }
@@ -1179,9 +1796,15 @@ export class MessageInputComponent extends BaseAngularComponent {
         return mentionResult;
     }
     /**
-     * Routes the message to the appropriate agent or Sage based on context.
-     * Priority: explicit @mention > prior-agent continuity > embedder-supplied
-     * default agent > Sage fallback.
+     * Routes a saved message to the agent that answers it — or to none.
+     *
+     * Routing picks the agent ({@link resolveAgentTurnTarget}): a tagged agent, then (under
+     * `AgentReplyMode` `'Always'`) the last agent that answered, the conversation's pinned agent,
+     * the host's default agent, and the conversation manager, each only if the host allows it.
+     * With {@link EnableDecisionRouting} on, a routing decision may first put another agent in the
+     * last agent's place ({@link decideAgentRouting}).
+     * {@link BeforeAgentTurn} is then fired once, before any reply row exists, and the turn runs on
+     * MJ's path or through the host's {@link AgentTurnHandler}.
      */
     async routeMessage(messageDetail, mentionResult, isFirstMessage) {
         // A Plan Mode choice made on the new-conversation composer (no conversation yet) lives in a
@@ -1199,80 +1822,213 @@ export class MessageInputComponent extends BaseAngularComponent {
         this._pendingRequestedSkillIDs = mentionResult.skillMentions?.length
             ? mentionResult.skillMentions.map(m => m.id)
             : this.collectRequestedSkillIDs();
-        // Priority 1: Direct @mention
-        if (mentionResult.agentMention) {
-            await this.handleDirectMention(messageDetail, mentionResult.agentMention, isFirstMessage);
+        // Naming is about the conversation, not the turn, so it doesn't wait on (or depend on) one.
+        // It runs in the background: naming can take minutes to time out.
+        if (isFirstMessage && this.AutoNameConversation) {
+            void this.nameConversation(messageDetail.Message, messageDetail.ConversationID)
+                .catch(error => console.error('Conversation naming failed:', error));
+        }
+        // Read the candidates before any await. This composer stays cached while the person opens
+        // another conversation, and the chat area then rebinds its history and pinned agent, so a
+        // read after the routing decision could see another conversation's state (or none).
+        const candidates = this.agentTurnCandidates(this.agentMentionIds(mentionResult));
+        const routing = await this.decideAgentRouting(messageDetail, candidates);
+        const target = this.resolveAgentTurnTarget(candidates, routing);
+        if (!target) {
+            await this.finishWithoutAgentTurn(messageDetail, 'NoAgent');
             return;
         }
-        // Priority 2: Check for previous agent with intent check
-        const lastAgentId = this.findLastNonSageAgentId();
-        if (lastAgentId) {
-            await this.handleAgentContinuity(messageDetail, lastAgentId, mentionResult, isFirstMessage);
+        const turn = this.announceAgentTurn(messageDetail, target);
+        if (!turn) {
+            await this.finishWithoutAgentTurn(messageDetail, 'Declined');
             return;
         }
-        // Priority 3: User's per-conversation pinned default agent — sourced
-        // from MJConversationEntity.DefaultAgentID. Wins over the embedder's
-        // default because it represents an explicit user choice on this
-        // conversation (e.g. "always route to Research Agent for this thread").
-        if (this.conversationDefaultAgentId) {
-            await this.handleAgentContinuity(messageDetail, this.conversationDefaultAgentId, mentionResult, isFirstMessage);
-            return;
+        await this.runAgentTurn(messageDetail, mentionResult, turn, routing);
+    }
+    /**
+     * Asks the routing decision for this message when {@link EnableDecisionRouting} is on and the
+     * message qualifies (see `ShouldRunRoutingDecision`). Returns null, with no call, otherwise, and
+     * when anything fails: the message then keeps today's routing.
+     *
+     * @param candidates The turn's candidates, read before any await (see {@link routeMessage}).
+     */
+    async decideAgentRouting(message, candidates) {
+        const continuityAgentId = candidates.ContinuityAgentId;
+        const qualifies = ShouldRunRoutingDecision({
+            Enabled: this.EnableDecisionRouting,
+            ReplyMode: this.AgentReplyMode,
+            MentionedAgentIds: candidates.MentionedAgentIds,
+            Message: message.Message ?? '',
+            ContinuityAgentId: continuityAgentId
+        });
+        if (!qualifies || !continuityAgentId) {
+            return null;
+        }
+        try {
+            // Built before the first await, so it reads the same conversation as the candidates.
+            const input = this.buildRoutingDecisionInput(message, continuityAgentId);
+            if (!CanAskRoutingDecision(input)) {
+                return null;
+            }
+            input.ArtifactVersions = await this.loadRoutingArtifactVersions(message.ConversationID, input.Participants);
+            const outcome = await RunRoutingDecision(input, params => this.agentService.RunDecision(params));
+            LogStatusEx({
+                message: `Decision routing: ${outcome.Verdict}, ${outcome.Reason} (prompt run ${outcome.PromptRunID ?? 'none'})`,
+                verboseOnly: true
+            });
+            return outcome;
+        }
+        catch (error) {
+            console.warn('Decision routing failed, so the message keeps continuity:', error);
+            return null;
         }
-        // Priority 4: Embedder-supplied default agent. Set by chat surfaces
-        // that have a specialist agent for the context (e.g. Form Builder
-        // cockpit). Only kicks in when nothing more explicit is present —
-        // @mention always wins, conversation continuity always wins. The
-        // intent is to skip Sage's default delegation when the embedder
-        // already knows what agent owns this conversation.
-        if (this.defaultAgentId) {
-            await this.handleAgentContinuity(messageDetail, this.defaultAgentId, mentionResult, isFirstMessage);
+    }
+    /**
+     * The routing decision's input, rebuilt from the conversation as it is now: the agents that
+     * have answered within the history floor, the last few turns, and the conversation manager.
+     * Artifact versions are added after, once the input is known to be worth asking about.
+     *
+     * Participants come only from the '@' list's agents (`GetAvailableAgents`): active, top-level,
+     * unrestricted agents this person has run permission for. An agent that answered here but that
+     * the person can't run (a shared conversation, a revoked permission) is never offered, so routing
+     * can't send the turn to an agent the server would refuse. Before that list has loaded there are
+     * no participants, so no call is made and the message keeps today's routing. Speaker names in
+     * the recent turns still come from the full catalog, since any agent may have spoken.
+     */
+    buildRoutingDecisionInput(message, continuityAgentId) {
+        const history = this.ConversationHistory.filter(row => this.isWithinHistoryFloor(row) && !UUIDsEqual(row.ID, message.ID));
+        const findAgent = (agentId) => AIEngineBase.Instance.Agents.find(a => UUIDsEqual(a.ID, agentId));
+        const runnable = this.mentionAutocomplete.GetAvailableAgents();
+        const findRunnable = (agentId) => runnable.find(a => UUIDsEqual(a.ID, agentId));
+        const manager = this.ConverationManagerAgent;
+        return {
+            Message: message.Message ?? '',
+            ContinuityAgentId: continuityAgentId,
+            Participants: CollectRoutingParticipants(history, manager?.ID ?? null, this.AllowedAgentIDs, findRunnable),
+            ConversationManager: manager?.ID && IsAgentAllowed(manager.ID, this.AllowedAgentIDs) ? manager : null,
+            RecentTurns: BuildRecentTurns(history, findAgent),
+            ArtifactVersions: [],
+            AllowedAgentIDs: this.AllowedAgentIDs
+        };
+    }
+    /** Every participant's artifact versions in this conversation, for the artifact question. */
+    async loadRoutingArtifactVersions(conversationId, participants) {
+        const artifactsByAgent = await Promise.all(participants.map(async (participant) => ({
+            Agent: participant.Agent,
+            Artifacts: await this.agentService.FindAgentArtifacts(conversationId, participant.Agent.ID, this.AgentHistoryFrom)
+        })));
+        return BuildRoutingArtifactVersions(artifactsByAgent);
+    }
+    /** The host's rules, as the routing functions take them. */
+    get agentTurnRules() {
+        return { ReplyMode: this.AgentReplyMode, AllowedAgentIDs: this.AllowedAgentIDs };
+    }
+    /** The agent each route would use for this conversation, before the host's rules apply. */
+    agentTurnCandidates(mentionedAgentIds) {
+        return {
+            MentionedAgentIds: mentionedAgentIds,
+            ContinuityAgentId: this.findLastNonSageAgentId(),
+            ConversationDefaultAgentId: this.ConversationDefaultAgentId,
+            HostDefaultAgentId: this.DefaultAgentId,
+            ConversationManagerAgentId: this.ConverationManagerAgent?.ID ?? null
+        };
+    }
+    /**
+     * Picks the agent that answers this message and the route that chose it, or null for no turn.
+     * A routing decision, when there was one, is applied to the candidates first.
+     */
+    resolveAgentTurnTarget(candidates, routing) {
+        return ResolveAgentTurn(ApplyRoutingDecision(candidates, routing), this.agentTurnRules, agentId => this.isKnownAgent(agentId));
+    }
+    /** The agents a message tags, in the order they appear. */
+    agentMentionIds(mentionResult) {
+        return mentionResult.mentions.filter(m => m.type === 'agent').map(m => m.id);
+    }
+    /**
+     * Fires {@link BeforeAgentTurn} for the turn routing picked — before any reply row exists —
+     * and applies what its listeners decided. Returns the turn to run, or null when a listener
+     * canceled it or redirected it to an agent this chat can't use.
+     */
+    announceAgentTurn(userMessage, target) {
+        const args = new BeforeAgentTurnEventArgs(userMessage.ConversationID, userMessage.Message ?? '', this.ApplicationId, { ...target, AgentName: this.agentNameFor(target.AgentId), UserMessageId: userMessage.ID });
+        this.BeforeAgentTurn.emit(args);
+        if (args.Cancel) {
+            LogStatusEx({ message: `Agent turn canceled by a BeforeAgentTurn listener${args.CancelReason ? `: ${args.CancelReason}` : ''}` });
+            return null;
+        }
+        const redirectAgentId = args.RedirectAgentId;
+        if (!redirectAgentId || UUIDsEqual(redirectAgentId, target.AgentId)) {
+            return target;
+        }
+        if (!IsAgentAllowed(redirectAgentId, this.AllowedAgentIDs) || !this.isKnownAgent(redirectAgentId)) {
+            this.notifyAgentTurnProblem('That agent isn\'t available in this chat, so it didn\'t answer.', 'warning');
+            return null;
+        }
+        return { AgentId: redirectAgentId, Route: 'Redirect' };
+    }
+    /**
+     * Settles a message that starts no agent turn — `MentionOnly` with no tagged agent, no allowed
+     * agent left, or a turn declined in {@link BeforeAgentTurn}. Nothing new is written; the
+     * person's own row is only confirmed Complete.
+     */
+    async finishWithoutAgentTurn(userMessage, reason) {
+        // Under the default rules a turn always has somewhere to go, so reaching here with no agent
+        // means MJ's conversation manager failed to load. Say so rather than sit silent.
+        if (reason === 'NoAgent' && this.AgentReplyMode === 'Always' && this.AllowedAgentIDs == null) {
+            this.notifyAgentTurnProblem('No agent is available to answer this message.', 'error');
+        }
+        await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
+    }
+    /**
+     * Runs a turn that {@link BeforeAgentTurn} let through, on the host's handler or MJ's path.
+     * The routing decision, when there was one, supplies the artifact version the turn's agent
+     * continues from; a host's handler receives it as `TargetArtifactVersionId`.
+     */
+    async runAgentTurn(userMessage, mentionResult, turn, routing = null) {
+        const mention = turn.Route === 'Mention' ? this.findAgentMention(mentionResult, turn.AgentId) : null;
+        const targetArtifactVersionId = ArtifactVersionForTurn(routing, turn.AgentId);
+        if (this.AgentTurnHandler) {
+            await this.runHostAgentTurn(this.AgentTurnHandler, userMessage, turn, mention, targetArtifactVersionId);
             return;
         }
-        // Priority 5: Check if Sage was explicitly @mentioned with a config preset
-        // If so, treat it like agent continuity so the config preset is preserved
-        if (this.converationManagerAgent?.ID) {
-            const sageConfigPreset = this.conversationId
-                ? await this.agentService.FindConfigurationPresetForAgent(this.conversationId, this.converationManagerAgent.ID)
-                : undefined;
-            if (sageConfigPreset) {
-                // User explicitly @mentioned Sage with a config - use the shared execution helper directly
-                // Pass the already-found config preset to avoid redundant history search
-                await this.executeRouteWithNaming(() => this.executeAgentContinuation(messageDetail, this.converationManagerAgent.ID, this.converationManagerAgent.Name || 'Sage', messageDetail.ConversationID, null, // Sage doesn't use payload continuity
-                null, // Sage doesn't use artifact info
-                sageConfigPreset // Pass the already-found config preset
-                ), messageDetail.Message, isFirstMessage, messageDetail.ConversationID);
-                return;
-            }
+        if (mention) {
+            await this.invokeAgentDirectly(userMessage, mention, userMessage.ConversationID);
+        }
+        else if (turn.Route === 'ConversationManager' || (turn.Route === 'Redirect' && this.isConversationManager(turn.AgentId))) {
+            await this.runConversationManagerTurn(userMessage, mentionResult);
+        }
+        else {
+            // Pinned and host defaults keep their direct call even when they name the manager, as before.
+            await this.handleAgentContinuity(userMessage, turn.AgentId, targetArtifactVersionId);
         }
-        // Priority 6: No context - use Sage with default config
-        await this.handleNoAgentContext(messageDetail, mentionResult, isFirstMessage);
     }
     /**
-     * Handles routing when user directly mentions an agent with @
+     * The tagged agent's mention, with its configuration preset. A mention saved without one
+     * (legacy text format) takes the preset from its chip in the composer, when there is one.
      */
-    async handleDirectMention(messageDetail, agentMention, isFirstMessage) {
-        // The agentMention already has configurationId from JSON parsing
-        // If it wasn't in JSON (legacy format), try to get from chip data
-        if (!agentMention.configurationId) {
-            const chipData = this.inputBox?.getMentionChipsData() || [];
-            const agentChip = chipData.find(chip => chip.id === agentMention.id && chip.type === 'agent');
+    findAgentMention(mentionResult, agentId) {
+        const mention = mentionResult.mentions.find(m => m.type === 'agent' && UUIDsEqual(m.id, agentId));
+        if (!mention) {
+            return null;
+        }
+        if (!mention.configurationId) {
+            const chipData = this.InputBox?.getMentionChipsData() || [];
+            const agentChip = chipData.find(chip => chip.id === mention.id && chip.type === 'agent');
             if (agentChip?.presetId) {
-                agentMention.configurationId = agentChip.presetId;
+                mention.configurationId = agentChip.presetId;
             }
         }
-        if (agentMention.configurationId) {
-            //console.log(`🎯 Agent mention has configuration ID: ${agentMention.configurationId}`);
-        }
-        await this.executeRouteWithNaming(() => this.invokeAgentDirectly(messageDetail, agentMention, messageDetail.ConversationID), messageDetail.Message, isFirstMessage, messageDetail.ConversationID);
+        return mention;
     }
     /**
-     * Handles routing when there's a previous non-Sage agent in the conversation.
+     * Continues with an agent chosen without a mention: the last agent that answered, the pinned
+     * or host default agent, or a redirect.
      *
      * LATENCY OPTIMIZATION (PR #2309 / plans/agent-latency-optimization.md — Opt #1):
-     * Previously, this method made a separate LLM call via checkContinuityIntent() to decide
-     * whether the user's new message was still directed at the previous agent or should be
-     * routed to Sage. That call added ~300ms of latency on every message in a conversation
-     * with an active agent — the single largest source of non-inference overhead on the client.
+     * This used to make a separate LLM call via checkContinuityIntent() to decide whether the
+     * user's new message was still directed at the previous agent or should be routed to Sage.
+     * That call added ~300ms of latency on every message in a conversation with an active agent —
+     * the single largest source of non-inference overhead on the client.
      *
      * The heuristic replacement is simple: if a previous non-Sage agent exists, always continue
      * with it. The user can @mention a different agent (or Sage) to explicitly switch. This is
@@ -1283,50 +2039,163 @@ export class MessageInputComponent extends BaseAngularComponent {
      * method are preserved (not deleted) so we can reintroduce intent checking in the future
      * when browser-local inference is fast enough (~20-50ms) to do this without blocking the
      * user. See PR #2309 for the full discussion.
+     *
+     * With {@link EnableDecisionRouting} on, a typed routing decision runs before routing instead
+     * ({@link decideAgentRouting}); the prompt-based check stays unused. A confident answer from it
+     * may name the artifact version this agent should continue from.
+     *
+     * @param targetArtifactVersionId The artifact version the routing decision named, or null.
+     */
+    async handleAgentContinuity(messageDetail, agentId, targetArtifactVersionId = null) {
+        await this.continueWithAgent(messageDetail, agentId, messageDetail.ConversationID, targetArtifactVersionId ?? undefined // set only by a confident routing decision
+        );
+    }
+    /**
+     * The conversation manager's turn. When an earlier message @mentioned the manager with a
+     * configuration preset, the preset keeps applying and the manager answers directly;
+     * otherwise it evaluates the message and may delegate.
+     */
+    async runConversationManagerTurn(messageDetail, mentionResult) {
+        const manager = this.ConverationManagerAgent;
+        const managerPreset = manager?.ID && messageDetail.ConversationID
+            ? await this.agentService.FindConfigurationPresetForAgent(messageDetail.ConversationID, manager.ID)
+            : undefined;
+        if (manager?.ID && managerPreset) {
+            await this.executeAgentContinuation(messageDetail, manager.ID, manager.Name || 'Sage', messageDetail.ConversationID, null, // Sage doesn't use payload continuity
+            null, // Sage doesn't use artifact info
+            managerPreset // Pass the already-found config preset
+            );
+            return;
+        }
+        await this.processMessageThroughAgent(messageDetail, mentionResult);
+    }
+    /**
+     * The newest reply from an agent other than the conversation manager — among the replies a
+     * turn may read, so from {@link AgentHistoryFrom} onward when it's set.
      */
-    async handleAgentContinuity(messageDetail, lastAgentId, mentionResult, isFirstMessage) {
-        // COMMENTED OUT — LLM intent check removed for latency optimization (see JSDoc above).
-        // const intentResult = await this.checkContinuityIntent(lastAgentId, messageDetail.Message);
-        //
-        // if (intentResult.decision === 'YES') {
-        //   await this.executeRouteWithNaming(
-        //     () => this.continueWithAgent(
-        //       messageDetail,
-        //       lastAgentId,
-        //       this.conversationId,
-        //       intentResult.targetArtifactVersionId
-        //     ),
-        //     messageDetail.Message,
-        //     isFirstMessage
-        //   );
-        // } else {
-        //   await this.executeRouteWithNaming(
-        //     () => this.processMessageThroughAgent(messageDetail, mentionResult),
-        //     messageDetail.Message,
-        //     isFirstMessage
-        //   );
-        // }
-        // Always continue with the previous agent — user can @mention another agent to switch.
-        await this.executeRouteWithNaming(() => this.continueWithAgent(messageDetail, lastAgentId, messageDetail.ConversationID, undefined // artifact version targeting unavailable without intent check
-        ), messageDetail.Message, isFirstMessage, messageDetail.ConversationID);
-    }
-    /**
-     * Handles routing when there's no previous agent context
-     */
-    async handleNoAgentContext(messageDetail, mentionResult, isFirstMessage) {
-        await this.executeRouteWithNaming(() => this.processMessageThroughAgent(messageDetail, mentionResult), messageDetail.Message, isFirstMessage, messageDetail.ConversationID);
-    }
-    /**
-     * Finds the last agent ID that isn't Sage
-     */
-    findLastNonSageAgentId() {
-        const lastAIMessage = this.conversationHistory
+    findLastNonSageReply() {
+        return this.ConversationHistory
             .slice()
             .reverse()
             .find(msg => msg.Role === 'AI' &&
-            msg.AgentID &&
-            !UUIDsEqual(msg.AgentID, this.converationManagerAgent?.ID));
-        return lastAIMessage?.AgentID || null;
+            !!msg.AgentID &&
+            !UUIDsEqual(msg.AgentID, this.ConverationManagerAgent?.ID) &&
+            this.isWithinHistoryFloor(msg)) ?? null;
+    }
+    /**
+     * Finds the last agent ID that isn't Sage (see {@link findLastNonSageReply}).
+     */
+    findLastNonSageAgentId() {
+        return this.findLastNonSageReply()?.AgentID || null;
+    }
+    /** True when a row was written at or after {@link AgentHistoryFrom}; always true without one. */
+    isWithinHistoryFloor(detail) {
+        const floor = this.AgentHistoryFrom;
+        if (!floor) {
+            return true;
+        }
+        const createdAt = detail.__mj_CreatedAt;
+        return createdAt != null && new Date(createdAt).getTime() >= floor.getTime();
+    }
+    /** True when the agent is in the client's agent catalog. */
+    isKnownAgent(agentId) {
+        return AIEngineBase.Instance.Agents.some(a => UUIDsEqual(a.ID, agentId));
+    }
+    /** The agent's name, when the client's agent catalog has it. */
+    agentNameFor(agentId) {
+        return AIEngineBase.Instance.Agents.find(a => UUIDsEqual(a.ID, agentId))?.Name ?? null;
+    }
+    /** The ID of the agent with this name, or null when there is none. */
+    agentIdByName(agentName) {
+        return AIEngineBase.Instance.Agents.find(a => a.Name === agentName)?.ID ?? null;
+    }
+    /** True when the agent is MJ's conversation manager. */
+    isConversationManager(agentId) {
+        return !!this.ConverationManagerAgent?.ID && UUIDsEqual(agentId, this.ConverationManagerAgent.ID);
+    }
+    /** Shows the person why an agent turn didn't happen, or didn't finish. */
+    notifyAgentTurnProblem(message, style) {
+        MJNotificationService.Instance?.CreateSimpleNotification(message, style, 5000);
+    }
+    /**
+     * Refuses agents the host doesn't allow — named by the conversation manager's delegation or
+     * by a workflow it planned — and settles the person's message.
+     */
+    async refuseDisallowedAgents(userMessage, agentNames) {
+        const subject = agentNames.join(', ');
+        this.notifyAgentTurnProblem(agentNames.length === 1
+            ? `${subject} isn't available in this chat, so it didn't run.`
+            : `${subject} aren't available in this chat, so they didn't run.`, 'warning');
+        await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
+    }
+    /**
+     * Runs the turn through the host's {@link AgentTurnHandler} instead of MJ's path. Nothing is
+     * written here: the host writes the reply rows and reports them, and each is shown like a row
+     * MJ wrote — one still In-Progress is followed like any other in-progress reply.
+     */
+    async runHostAgentTurn(handler, userMessage, turn, mention, targetArtifactVersionId) {
+        const request = this.buildAgentTurnRequest(userMessage, turn, mention, targetArtifactVersionId);
+        const result = await this.callAgentTurnHandler(handler, request);
+        if (!result.Success) {
+            this.notifyAgentTurnProblem(result.ErrorMessage || 'The agent could not answer this message.', 'error');
+        }
+        else {
+            await this.showHostTurnRows(result.ReplyDetailIds ?? []);
+        }
+        await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
+        if (result.Success && result.Result) {
+            this.emitAfterAgentTurn(userMessage.ConversationID, result.Result, result.AgentRunId);
+        }
+    }
+    /** Calls the host's handler; a throw is reported as a failed turn, never swallowed. */
+    async callAgentTurnHandler(handler, request) {
+        try {
+            return await handler(request);
+        }
+        catch (error) {
+            console.error('AgentTurnHandler failed:', error);
+            return { Success: false, ErrorMessage: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    /**
+     * What the host's handler is told about the turn.
+     *
+     * @param targetArtifactVersionId The artifact version the routing decision named for this
+     *   turn's agent, or null.
+     */
+    buildAgentTurnRequest(userMessage, turn, mention, targetArtifactVersionId) {
+        return {
+            ConversationId: userMessage.ConversationID,
+            UserMessageId: userMessage.ID,
+            MessageText: userMessage.Message ?? '',
+            AgentId: turn.AgentId,
+            AgentName: this.agentNameFor(turn.AgentId),
+            Route: turn.Route,
+            ApplicationId: this.ApplicationId,
+            AppContext: this.AppContext,
+            AgentHistoryFrom: this.AgentHistoryFrom,
+            // A mention carries its own preset (or none); every other route follows the header picker.
+            ConfigurationPresetId: turn.Route === 'Mention' ? (mention?.configurationId ?? null) : this.AgentConfigurationPresetId,
+            RequestedSkillIDs: [...this._pendingRequestedSkillIDs],
+            PlanMode: this.PlanModeEnabled,
+            TargetArtifactVersionId: targetArtifactVersionId
+        };
+    }
+    /** Shows the rows a host's handler reported for its turn, oldest first. */
+    async showHostTurnRows(detailIds) {
+        for (const detailId of detailIds) {
+            const detail = await this.dataCache.getConversationDetail(detailId, this.CurrentUser);
+            if (detail) {
+                this.MessageSent.emit(detail);
+            }
+            else {
+                console.warn(`AgentTurnHandler reported conversation detail ${detailId}, but it could not be loaded`);
+            }
+        }
+    }
+    /** Fires {@link AfterAgentTurn} for a turn that succeeded. */
+    emitAfterAgentTurn(conversationId, result, agentRunId) {
+        this.AfterAgentTurn.emit(new AfterAgentTurnEventArgs(conversationId, agentRunId ?? result.agentRun?.ID ?? '', result));
     }
     /**
      * Checks if message should continue with the previous agent
@@ -1344,17 +2213,17 @@ export class MessageInputComponent extends BaseAngularComponent {
             };
         }
         // Emit event to show temporary "Analyzing intent..." message in conversation
-        this.intentCheckStarted.emit({ conversationId: this.conversationId });
+        this.IntentCheckStarted.emit({ conversationId: this.ConversationId });
         try {
             // The pre-loaded artifact/agent-run maps are no longer passed: they are scoped to the
             // loaded transcript window, and the service now queries for this agent's artifacts so
             // the classifier reasons over the whole conversation. A conversation id is what it
             // needs instead, and without one there is nothing to query.
-            if (!this.conversationId) {
+            if (!this.ConversationId) {
                 console.warn('⚠️ No conversation id available for intent check');
                 return { decision: 'UNSURE', reasoning: 'Conversation not available' };
             }
-            const intent = await this.agentService.checkAgentContinuityIntent(this.conversationId, agentId, message, this.conversationHistory);
+            const intent = await this.agentService.checkAgentContinuityIntent(this.ConversationId, agentId, message, this.ConversationHistory);
             return intent;
         }
         catch (error) {
@@ -1363,25 +2232,7 @@ export class MessageInputComponent extends BaseAngularComponent {
         }
         finally {
             // Emit event to remove temporary intent checking message
-            this.intentCheckCompleted.emit({ conversationId: this.conversationId });
-        }
-    }
-    /**
-     * Executes a routing function, optionally with conversation naming for first message
-     *
-     * IMPORTANT: Conversation naming runs asynchronously in the background and does NOT
-     * block the agent invocation. This prevents UI blocking if naming times out.
-     */
-    async executeRouteWithNaming(routeFunction, userMessage, isFirstMessage, conversationId) {
-        if (isFirstMessage) {
-            // Fire conversation naming in background (don't await)
-            // This prevents 2+ minute UI blocking if naming times out
-            this.nameConversation(userMessage, conversationId);
-            // Execute route immediately (don't wait for naming)
-            await routeFunction();
-        }
-        else {
-            await routeFunction();
+            this.IntentCheckCompleted.emit({ conversationId: this.ConversationId });
         }
     }
     /**
@@ -1389,8 +2240,8 @@ export class MessageInputComponent extends BaseAngularComponent {
      */
     refocusTextarea() {
         setTimeout(() => {
-            if (this.inputBox) {
-                this.inputBox.focus();
+            if (this.InputBox) {
+                this.InputBox.focus();
             }
         }, 100);
     }
@@ -1450,7 +2301,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                     // CRITICAL FIX: Emit FULL agent run object for incremental updates
                     // This contains live timestamps, status, and other fields that change during execution
                     if (progressAgentRun || progressAgentRunId) {
-                        this.agentRunUpdate.emit({
+                        this.AgentRunUpdate.emit({
                             conversationId: conversationDetail.ConversationID,
                             conversationDetailId: conversationDetail.ID,
                             agentRun: progressAgentRun,
@@ -1460,7 +2311,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                     else if (progressAgentRunId && !capturedAgentRunId) {
                         // Fallback: If we don't have the full object but have the ID, emit agentRunDetected
                         // This will trigger a database query to load the agent run
-                        this.agentRunDetected.emit({
+                        this.AgentRunDetected.emit({
                             conversationId: conversationDetail.ConversationID,
                             conversationDetailId: conversationDetail.ID,
                             agentRunId: progressAgentRunId
@@ -1470,7 +2321,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                         conversationDetail.Message = progressText;
                         // Server now saves progress - client only updates in-memory and emits for UI
                         // (Prevents race condition where client's late save overwrites server's final Status)
-                        this.messageSent.emit(conversationDetail);
+                        this.MessageSent.emit(conversationDetail);
                     }
                 }
             }
@@ -1481,7 +2332,8 @@ export class MessageInputComponent extends BaseAngularComponent {
     }
     /**
      * Process the message through agents (multi-stage: Sage -> possible sub-agent)
-     * Only called when there's no @mention and no implicit agent context
+     * Only called when there's no @mention and no implicit agent context.
+     * {@link BeforeAgentTurn} has already fired — routing announces the turn before any row exists.
      */
     async processMessageThroughAgent(userMessage, mentionResult) {
         let taskId = null;
@@ -1491,7 +2343,7 @@ export class MessageInputComponent extends BaseAngularComponent {
         const conversationId = userMessage.ConversationID;
         try {
             // Create AI message for Sage BEFORE invoking
-            conversationManagerMessage = await this.dataCache.createConversationDetail(this.currentUser);
+            conversationManagerMessage = await this.dataCache.createConversationDetail(this.CurrentUser);
             conversationManagerMessage.ConversationID = conversationId;
             conversationManagerMessage.Role = 'AI';
             conversationManagerMessage.Message = '⏳ Starting...';
@@ -1499,11 +2351,11 @@ export class MessageInputComponent extends BaseAngularComponent {
             conversationManagerMessage.Status = 'In-Progress';
             conversationManagerMessage.HiddenToUser = false;
             // Use the preloaded Sage agent instead of looking it up
-            if (this.converationManagerAgent?.ID) {
-                conversationManagerMessage.AgentID = this.converationManagerAgent.ID;
+            if (this.ConverationManagerAgent?.ID) {
+                conversationManagerMessage.AgentID = this.ConverationManagerAgent.ID;
             }
             await conversationManagerMessage.Save();
-            this.messageSent.emit(conversationManagerMessage);
+            this.MessageSent.emit(conversationManagerMessage);
             // Use Sage to evaluate and route
             // Stage 1: Sage evaluates the message
             taskId = this.activeTasks.add({
@@ -1512,39 +2364,22 @@ export class MessageInputComponent extends BaseAngularComponent {
                 relatedMessageId: userMessage.ID,
                 conversationDetailId: conversationManagerMessage.ID,
                 conversationId,
-                conversationName: this.conversationName
+                conversationName: this.ConversationName
             });
-            // ── PR 2c follow-up: Before/After cancelable event wiring ──
-            // Emit beforeAgentTurn so consumers can veto the turn (rate-limit, guardrail,
-            // confirm-dialog, etc.). Cancel propagates synchronously through the chat-area
-            // re-emit binding, so by the time .emit() returns, event.Cancel reflects every
-            // subscriber's final answer.
-            const beforeEvent = new BeforeAgentTurnEventArgs(conversationId, userMessage.Message ?? '', this.applicationId);
-            this.beforeAgentTurn.emit(beforeEvent);
-            if (beforeEvent.Cancel) {
-                // Mark the conversation-manager message as canceled + clear its task so the
-                // UI doesn't show a forever-pending spinner. afterAgentTurn is NOT emitted.
-                await this.updateConversationDetail(conversationManagerMessage, beforeEvent.CancelReason ?? '⛔ Turn canceled before agent invocation', 'Error');
-                await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
-                this.cleanupCompletionTimestamp(conversationManagerMessage.ID);
-                if (taskId) {
-                    this.activeTasks.remove(taskId);
-                    taskId = null;
-                }
-                return;
-            }
-            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._pendingRequestedSkillIDs);
+            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._pendingRequestedSkillIDs, // user-requested skills (/skill mentions)
+            this.AllowedAgentIDs, // the agents the manager may delegate to
+            this.AgentHistoryFrom);
             // 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.afterAgentTurn.emit(new AfterAgentTurnEventArgs(conversationId, (result.agentRun?.ID ?? ''), result));
+                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');
+                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;
@@ -1576,7 +2411,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                 // 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);
+                    this.MessageSent.emit(conversationManagerMessage);
                 }
                 await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
                 // Remove CM from active tasks
@@ -1595,7 +2430,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                     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);
+                    this.MessageSent.emit(conversationManagerMessage);
                     // Clean up completion timestamp after delay
                     this.cleanupCompletionTimestamp(conversationManagerMessage.ID);
                 }
@@ -1606,7 +2441,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                     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);
+                    this.MessageSent.emit(conversationManagerMessage);
                     await this.handleSilentObservation(userMessage, conversationId);
                     // Clean up completion timestamp after delay
                     this.cleanupCompletionTimestamp(conversationManagerMessage.ID);
@@ -1666,11 +2501,18 @@ export class MessageInputComponent extends BaseAngularComponent {
         const taskGraph = managerResult.payload?.taskGraph;
         if (!taskGraph)
             return;
+        // The host's allowed list holds for every agent step of the plan, not only for a single
+        // delegation: a workflow naming an agent the chat doesn't allow is not submitted at all.
+        const disallowedAgents = FindDisallowedTaskGraphAgents(Array.isArray(taskGraph.tasks) ? taskGraph.tasks : [], this.AllowedAgentIDs, agentName => this.agentIdByName(agentName));
+        if (disallowedAgents.length > 0) {
+            await this.refuseDisallowedAgents(userMessage, disallowedAgents);
+            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.dataCache.createConversationDetail(this.currentUser);
+        const taskExecutionMessage = await this.dataCache.createConversationDetail(this.CurrentUser);
         taskExecutionMessage.ConversationID = conversationId;
         taskExecutionMessage.Role = 'AI';
         taskExecutionMessage.Message = `⏳ **${workflowName}**\n\n${reasoning}\n\nSubmitting ${taskCount} task(s)…`;
@@ -1678,7 +2520,7 @@ export class MessageInputComponent extends BaseAngularComponent {
         taskExecutionMessage.Status = 'In-Progress';
         taskExecutionMessage.HiddenToUser = false;
         await taskExecutionMessage.Save();
-        this.messageSent.emit(taskExecutionMessage);
+        this.MessageSent.emit(taskExecutionMessage);
         const callback = this.createMessageProgressCallback(taskExecutionMessage.ID);
         this.registeredCallbacks.set(taskExecutionMessage.ID, callback);
         this.streamingService.registerMessageCallback(taskExecutionMessage.ID, callback);
@@ -1728,7 +2570,7 @@ export class MessageInputComponent extends BaseAngularComponent {
             await convoDetail.Load(convoDetail.ID);
             if (convoDetail.Status === 'Complete' || convoDetail.Status === 'Error') {
                 this.markMessageComplete(convoDetail);
-                this.messageSent.emit(convoDetail);
+                this.MessageSent.emit(convoDetail);
                 return;
             }
         }
@@ -1755,7 +2597,7 @@ export class MessageInputComponent extends BaseAngularComponent {
             await convoDetail.Save();
             if (convoDetail.Message === message && convoDetail.Status === status) {
                 done = true;
-                this.messageSent.emit(convoDetail);
+                this.MessageSent.emit(convoDetail);
             }
             else {
                 console.warn(`   ⚠️ ConversationDetail update attempt ${attempts + 1} did not persist. ${attempts + 1 < maxAttempts ? 'Retrying...' : 'Giving up.'}`);
@@ -1778,10 +2620,10 @@ export class MessageInputComponent extends BaseAngularComponent {
      * Direction, not on Visibility.
      */
     async loadPreviousPayloadForAgent(agentId) {
-        if (!this.conversationId) {
+        if (!this.ConversationId) {
             return { payload: null, artifactInfo: null };
         }
-        const source = await this.agentService.FindLatestAgentOutputVersion(this.conversationId, agentId);
+        const source = await this.agentService.FindLatestAgentOutputVersion(this.ConversationId, agentId, this.AgentHistoryFrom);
         if (!source || source.payload == null) {
             console.log(`📦 No previous payload found for agent ${agentId}`);
             return { payload: null, artifactInfo: null };
@@ -1809,8 +2651,14 @@ export class MessageInputComponent extends BaseAngularComponent {
         try {
             // Look up the agent to get its ID
             const agent = AIEngineBase.Instance.Agents.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.dataCache.createConversationDetail(this.currentUser);
+            agentResponseMessage = await this.dataCache.createConversationDetail(this.CurrentUser);
             agentResponseMessage.ConversationID = conversationId;
             agentResponseMessage.Role = 'AI';
             agentResponseMessage.Message = '⏳ Starting...'; // Initial message
@@ -1823,7 +2671,7 @@ export class MessageInputComponent extends BaseAngularComponent {
             }
             // Save the record to establish __mj_CreatedAt timestamp
             await agentResponseMessage.Save();
-            this.messageSent.emit(agentResponseMessage);
+            this.MessageSent.emit(agentResponseMessage);
             // Add sub-agent to active tasks
             const newTaskId = this.activeTasks.add({
                 agentName: agentName,
@@ -1831,7 +2679,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                 relatedMessageId: userMessage.ID,
                 conversationDetailId: agentResponseMessage.ID,
                 conversationId,
-                conversationName: this.conversationName
+                conversationName: this.ConversationName
             });
             // Load previous payload if agent has been invoked before
             const { payload: previousPayload, artifactInfo } = agent?.ID
@@ -1842,11 +2690,12 @@ export class MessageInputComponent extends BaseAngularComponent {
                 ? await this.agentService.FindConfigurationPresetForAgent(conversationId, agent.ID)
                 : 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
+            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.AppContext, // Embedder-supplied app/form context
             this.PlanModeEnabled, // per-request Plan Mode toggle
-            this._pendingRequestedSkillIDs);
+            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) {
@@ -1860,7 +2709,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                 // 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);
+                this.MessageSent.emit(agentResponseMessage);
                 // Mark user message as complete
                 await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
             }
@@ -1877,11 +2726,12 @@ export class MessageInputComponent extends BaseAngularComponent {
                 // 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
+                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
-                this.appContext, // Embedder-supplied app/form context
+                this.AppContext, // Embedder-supplied app/form context
                 this.PlanModeEnabled, // per-request Plan Mode toggle
-                this._pendingRequestedSkillIDs);
+                this._pendingRequestedSkillIDs, // user-requested skills (/skill mentions)
+                this.AgentHistoryFrom);
                 if (retryResult && retryResult.success) {
                     // Retry succeeded - update the same message
                     if (retryResult.agentRun.AgentID) {
@@ -1890,7 +2740,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                     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);
+                    this.MessageSent.emit(agentResponseMessage);
                     await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
                 }
                 else {
@@ -1929,19 +2779,19 @@ export class MessageInputComponent extends BaseAngularComponent {
      * check if we should continue with the last agent for iterative refinement
      */
     async handleSilentObservation(userMessage, conversationId) {
-        // Find the last AI message (excluding Sage) in the conversation history
-        const lastAIMessage = this.conversationHistory
-            .slice()
-            .reverse()
-            .find(msg => msg.Role === 'AI' &&
-            msg.AgentID &&
-            !UUIDsEqual(msg.AgentID, this.converationManagerAgent?.ID));
+        // Find the last AI message (excluding Sage) this turn may read
+        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');
             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');
+            await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
+            return;
+        }
         // Load the agent entity to get its name
         const previousAgent = AIEngineBase.Instance.Agents.find(a => UUIDsEqual(a.ID, lastAIMessage.AgentID));
         if (!previousAgent) {
@@ -1955,7 +2805,7 @@ export class MessageInputComponent extends BaseAngularComponent {
         // Resolved by QUERY, not from the window's artifact maps: `lastAIMessage` can sit inside
         // the loaded window while its artifact does not, and this path silently degrades to a
         // null payload when the lookup misses.
-        const source = await this.agentService.FindLatestAgentOutputVersion(conversationId, lastAIMessage.AgentID);
+        const source = await this.agentService.FindLatestAgentOutputVersion(conversationId, lastAIMessage.AgentID, this.AgentHistoryFrom);
         if (source && source.payload != null) {
             previousPayload = source.payload;
             previousArtifactInfo = {
@@ -1966,16 +2816,16 @@ export class MessageInputComponent extends BaseAngularComponent {
             console.log('📦 Loaded previous OUTPUT artifact as payload for continuity', previousArtifactInfo);
         }
         // Create status message showing agent continuity
-        const statusMessage = await this.dataCache.createConversationDetail(this.currentUser);
+        const statusMessage = await this.dataCache.createConversationDetail(this.CurrentUser);
         statusMessage.ConversationID = conversationId;
         statusMessage.Role = 'AI';
         statusMessage.Message = `Continuing with **${agentName}** for refinement...`;
         statusMessage.ParentID = userMessage.ID;
         statusMessage.Status = 'Complete';
         statusMessage.HiddenToUser = false;
-        statusMessage.AgentID = this.converationManagerAgent?.ID || null;
+        statusMessage.AgentID = this.ConverationManagerAgent?.ID || null;
         await statusMessage.Save();
-        this.messageSent.emit(statusMessage);
+        this.MessageSent.emit(statusMessage);
         // Add agent to active tasks
         const taskId = this.activeTasks.add({
             agentName: agentName,
@@ -1983,19 +2833,20 @@ export class MessageInputComponent extends BaseAngularComponent {
             relatedMessageId: userMessage.ID,
             conversationDetailId: statusMessage.ID,
             conversationId,
-            conversationName: this.conversationName
+            conversationName: this.ConversationName
         });
         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
-            this.appContext, // Embedder-supplied app/form context
+            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
+            this.AppContext, // Embedder-supplied app/form context
             this.PlanModeEnabled, // per-request Plan Mode toggle
-            this._pendingRequestedSkillIDs);
+            this._pendingRequestedSkillIDs, // user-requested skills (/skill mentions)
+            this.AgentHistoryFrom);
             // Remove from active tasks
             // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
             if (continuityResult && continuityResult.success) {
                 // Create response message
-                const agentResponseMessage = await this.dataCache.createConversationDetail(this.currentUser);
+                const agentResponseMessage = await this.dataCache.createConversationDetail(this.CurrentUser);
                 agentResponseMessage.ConversationID = conversationId;
                 agentResponseMessage.Role = 'AI';
                 agentResponseMessage.Message = continuityResult.agentRun?.Message || `✅ **${agentName}** completed refinement`;
@@ -2004,12 +2855,12 @@ export class MessageInputComponent extends BaseAngularComponent {
                 agentResponseMessage.HiddenToUser = false;
                 agentResponseMessage.AgentID = lastAIMessage.AgentID;
                 await agentResponseMessage.Save();
-                this.messageSent.emit(agentResponseMessage);
+                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);
+                    this.MessageSent.emit(agentResponseMessage);
                 }
                 // Mark user message as complete
                 await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
@@ -2037,7 +2888,7 @@ export class MessageInputComponent extends BaseAngularComponent {
             relatedMessageId: userMessage.ID,
             conversationDetailId: userMessage.ID,
             conversationId,
-            conversationName: this.conversationName
+            conversationName: this.ConversationName
         });
         // Declare agentResponseMessage outside try block so it's accessible in catch
         let agentResponseMessage = undefined;
@@ -2046,11 +2897,11 @@ export class MessageInputComponent extends BaseAngularComponent {
             // (No UI uses User message 'In-Progress' - only AI messages need that status)
             userMessage.Status = 'Complete';
             await userMessage.Save();
-            this.messageSent.emit(userMessage);
+            this.MessageSent.emit(userMessage);
             // 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)
-            agentResponseMessage = await this.dataCache.createConversationDetail(this.currentUser);
+            agentResponseMessage = await this.dataCache.createConversationDetail(this.CurrentUser);
             agentResponseMessage.ConversationID = conversationId;
             agentResponseMessage.Role = 'AI';
             agentResponseMessage.Message = '⏳ Starting...'; // Initial message
@@ -2063,23 +2914,25 @@ export class MessageInputComponent extends BaseAngularComponent {
             }
             // Save the record to establish __mj_CreatedAt timestamp
             await agentResponseMessage.Save();
-            this.messageSent.emit(agentResponseMessage);
+            this.MessageSent.emit(agentResponseMessage);
             // Load previous payload if agent has been invoked before
             const { payload: previousPayload, artifactInfo } = agent?.ID
                 ? await this.loadPreviousPayloadForAgent(agent.ID)
                 : { 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}`, agentResponseMessage.ID, 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.AppContext, // Embedder-supplied app/form context
             this.PlanModeEnabled, // per-request Plan Mode toggle
-            this._pendingRequestedSkillIDs);
+            this._pendingRequestedSkillIDs, // user-requested skills (/skill mentions)
+            this.AgentHistoryFrom);
             // Remove from active tasks
             // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
             if (result && result.success) {
                 if (result.agentRun.AgentID) {
                     agentResponseMessage.AgentID = result.agentRun.AgentID;
                 }
+                this.emitAfterAgentTurn(conversationId, result);
                 // Multi-stage response handling (same logic as ambient Sage)
                 // Stage 1: Check for task graph (multi-step orchestration)
                 if (result.payload?.taskGraph) {
@@ -2097,7 +2950,7 @@ export class MessageInputComponent extends BaseAngularComponent {
                     // Server created artifacts - emit event to trigger UI reload
                     if (result.payload && Object.keys(result.payload).length > 0) {
                         this.emitArtifactReload(agentResponseMessage);
-                        this.messageSent.emit(agentResponseMessage);
+                        this.MessageSent.emit(agentResponseMessage);
                     }
                     // Mark user message as complete
                     await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
@@ -2127,6 +2980,11 @@ export class MessageInputComponent extends BaseAngularComponent {
         // Load the agent entity to get its name
         const agent = AIEngineBase.Instance.Agents.find(a => UUIDsEqual(a.ID, agentId));
         if (!agent) {
+            if (!IsAgentAllowed(this.ConverationManagerAgent?.ID, this.AllowedAgentIDs)) {
+                console.warn('⚠️ Could not load agent for continuation, and Sage is not allowed in this chat');
+                await this.finishWithoutAgentTurn(userMessage, 'Declined');
+                return;
+            }
             console.warn('⚠️ Could not load agent for continuation - falling back to Sage');
             await this.processMessageThroughAgent(userMessage, { mentions: [], agentMention: null, userMentions: [], entityMentions: [], skillMentions: [] });
             return;
@@ -2163,8 +3021,8 @@ export class MessageInputComponent extends BaseAngularComponent {
         // High) and applies to all subsequent non-mention routes. A
         // history-derived preset still wins because it represents an
         // explicit per-message intent the user expressed earlier.
-        if (!previousConfigurationId && this.agentConfigurationPresetId) {
-            previousConfigurationId = this.agentConfigurationPresetId;
+        if (!previousConfigurationId && this.AgentConfigurationPresetId) {
+            previousConfigurationId = this.AgentConfigurationPresetId;
         }
         // Fall back to searching through all agent messages for an artifact
         // This ensures payload continuity even after clarifying exchanges without artifacts
@@ -2173,7 +3031,7 @@ export class MessageInputComponent extends BaseAngularComponent {
         // used to walk is the loaded window, so the artifact it is looking for is exactly the
         // one most likely to be missing from it.
         if (!previousPayload) {
-            const source = await this.agentService.FindLatestAgentOutputVersion(conversationId, agentId);
+            const source = await this.agentService.FindLatestAgentOutputVersion(conversationId, agentId, this.AgentHistoryFrom);
             if (source && source.payload != null) {
                 previousPayload = source.payload;
                 previousArtifactInfo = {
@@ -2210,7 +3068,7 @@ export class MessageInputComponent extends BaseAngularComponent {
             relatedMessageId: userMessage.ID,
             conversationDetailId: userMessage.ID,
             conversationId,
-            conversationName: this.conversationName
+            conversationName: this.ConversationName
         });
         // Declare agentResponseMessage outside try block so it's accessible in catch
         let agentResponseMessage = undefined;
@@ -2219,9 +3077,9 @@ export class MessageInputComponent extends BaseAngularComponent {
             // (No UI uses User message 'In-Progress' - only AI messages need that status)
             userMessage.Status = 'Complete';
             await userMessage.Save();
-            this.messageSent.emit(userMessage);
+            this.MessageSent.emit(userMessage);
             // Create AI response message BEFORE invoking agent (for duration tracking)
-            agentResponseMessage = await this.dataCache.createConversationDetail(this.currentUser);
+            agentResponseMessage = await this.dataCache.createConversationDetail(this.CurrentUser);
             agentResponseMessage.ConversationID = conversationId;
             agentResponseMessage.Role = 'AI';
             agentResponseMessage.Message = '⏳ Starting...'; // Initial message
@@ -2231,26 +3089,28 @@ export class MessageInputComponent extends BaseAngularComponent {
             agentResponseMessage.AgentID = agentId;
             // Save the record to establish __mj_CreatedAt timestamp
             await agentResponseMessage.Save();
-            this.messageSent.emit(agentResponseMessage);
+            this.MessageSent.emit(agentResponseMessage);
             // 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', agentResponseMessage.ID, 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.AppContext, // Embedder-supplied app/form context
             this.PlanModeEnabled, // per-request Plan Mode toggle
-            this._pendingRequestedSkillIDs);
+            this._pendingRequestedSkillIDs, // user-requested skills (/skill mentions)
+            this.AgentHistoryFrom);
             // Remove from active tasks
             // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
             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);
                 // Server created artifacts (handles versioning) - emit event to trigger UI reload
                 if (result.payload && Object.keys(result.payload).length > 0) {
                     this.emitArtifactReload(agentResponseMessage);
-                    this.messageSent.emit(agentResponseMessage);
+                    this.MessageSent.emit(agentResponseMessage);
                 }
                 // Mark user message as complete
                 await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
@@ -2284,11 +3144,11 @@ export class MessageInputComponent extends BaseAngularComponent {
             ConversationId: conversationId,
             MessageText: plainTextMessage,
             Provider: this.ProviderToUse,
-            CurrentUser: this.currentUser
+            CurrentUser: this.CurrentUser
         });
         if (result) {
             // Emit event for animation in conversation list
-            this.conversationRenamed.emit({
+            this.ConversationRenamed.emit({
                 conversationId,
                 name: result.Name,
                 description: result.Description
@@ -2352,7 +3212,7 @@ export class MessageInputComponent extends BaseAngularComponent {
             if (detail.Status === 'Complete' || detail.Status === 'Error') {
                 this.stopInFlightDetailWatch(detail.ID);
                 this.markMessageComplete(detail);
-                this.messageSent.emit(detail);
+                this.MessageSent.emit(detail);
                 return;
             }
         }
@@ -2444,7 +3304,7 @@ export class MessageInputComponent extends BaseAngularComponent {
             LogStatusEx({ message: `[MarkComplete] No task registered against completed message ${conversationDetail.ID} — expected for any message that did not start the turn`, verboseOnly: true });
         }
         // Emit completion event to parent so it can refresh agent run data
-        this.messageComplete.emit({
+        this.MessageComplete.emit({
             conversationId: conversationDetail.ConversationID,
             conversationDetailId: conversationDetail.ID,
             agentId: conversationDetail.AgentID || undefined
@@ -2458,7 +3318,7 @@ export class MessageInputComponent extends BaseAngularComponent {
      * detail entity's immutable ConversationID, never this.conversationId.
      */
     emitArtifactReload(detail) {
-        this.artifactCreated.emit({
+        this.ArtifactCreated.emit({
             conversationId: detail.ConversationID,
             artifactId: '',
             versionId: '',
@@ -2481,8 +3341,8 @@ export class MessageInputComponent extends BaseAngularComponent {
             i0.ɵɵviewQuery(_c0, 5);
         } if (rf & 2) {
             let _t;
-            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.inputBox = _t.first);
-        } }, inputs: { conversationId: "conversationId", conversationName: "conversationName", currentUser: "currentUser", disabled: "disabled", placeholder: "placeholder", parentMessageId: "parentMessageId", enableAttachments: "enableAttachments", enableMentions: "enableMentions", enableAgentMentions: "enableAgentMentions", enableEntityMentions: "enableEntityMentions", enableSkillCommands: "enableSkillCommands", enablePlanMode: "enablePlanMode", enableRealtime: "enableRealtime", maxAttachments: "maxAttachments", maxAttachmentSizeBytes: "maxAttachmentSizeBytes", acceptedFileTypes: "acceptedFileTypes", artifactsByDetailId: "artifactsByDetailId", systemArtifactsByDetailId: "systemArtifactsByDetailId", agentRunsByDetailId: "agentRunsByDetailId", emptyStateMode: "emptyStateMode", appContext: "appContext", defaultAgentId: "defaultAgentId", conversationDefaultAgentId: "conversationDefaultAgentId", agentConfigurationPresetId: "agentConfigurationPresetId", initialMessage: "initialMessage", initialAttachments: "initialAttachments", conversationHistory: "conversationHistory", inProgressMessageIds: "inProgressMessageIds", applicationId: "applicationId", initialDraft: "initialDraft" }, outputs: { messageSent: "messageSent", agentResponse: "agentResponse", beforeAgentTurn: "beforeAgentTurn", afterAgentTurn: "afterAgentTurn", agentRunDetected: "agentRunDetected", agentRunUpdate: "agentRunUpdate", messageComplete: "messageComplete", artifactCreated: "artifactCreated", conversationRenamed: "conversationRenamed", intentCheckStarted: "intentCheckStarted", intentCheckCompleted: "intentCheckCompleted", initialMessageAutoSendStarted: "initialMessageAutoSendStarted", initialMessageAutoSendFailed: "initialMessageAutoSendFailed", emptyStateSubmit: "emptyStateSubmit", uploadStateChanged: "uploadStateChanged", initialDraftApplied: "initialDraftApplied", DraftStateChanged: "DraftStateChanged", ComposerBlurred: "ComposerBlurred" }, standalone: false, features: [i0.ɵɵInheritDefinitionFeature, i0.ɵɵNgOnChangesFeature], decls: 6, vars: 27, consts: [["pickerOrigin", "cdkOverlayOrigin"], ["inputBox", ""], ["cdkOverlayOrigin", "", 1, "message-input-wrapper"], [1, "processing-indicator"], [3, "valueChange", "blurred", "textSubmitted", "attachmentsChanged", "attachmentError", "voiceRequested", "voiceOptionsRequested", "planModeToggle", "placeholder", "disabled", "showCharacterCount", "enableMentions", "EnableAgentMentions", "EnableEntityMentions", "EnableSkillCommands", "TargetAgentId", "enableAttachments", "maxAttachments", "maxAttachmentSizeBytes", "acceptedFileTypes", "currentUser", "Provider", "rows", "enableRealtime", "voiceActive", "canStartRealtime", "enablePlanMode", "planModeActive", "value"], ["cdkConnectedOverlay", "", "cdkConnectedOverlayBackdropClass", "cdk-overlay-transparent-backdrop", 3, "backdropClick", "detach", "cdkConnectedOverlayOrigin", "cdkConnectedOverlayOpen", "cdkConnectedOverlayPositions", "cdkConnectedOverlayPush", "cdkConnectedOverlayHasBackdrop"], [1, "fas", "fa-circle-notch", "fa-spin"], [3, "AgentPicked", "Cancelled", "Provider", "CurrentUser", "Agents", "DefaultAgentId", "CoAgents", "DefaultCoAgentId"]], template: function MessageInputComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.InputBox = _t.first);
+        } }, inputs: { ConversationId: "ConversationId", conversationId: "conversationId", ConversationName: "ConversationName", conversationName: "conversationName", CurrentUser: "CurrentUser", currentUser: "currentUser", Disabled: "Disabled", disabled: "disabled", ReadOnly: "ReadOnly", Placeholder: "Placeholder", placeholder: "placeholder", ParentMessageId: "ParentMessageId", parentMessageId: "parentMessageId", EnableAttachments: "EnableAttachments", enableAttachments: "enableAttachments", EnableMentions: "EnableMentions", enableMentions: "enableMentions", EnableAgentMentions: "EnableAgentMentions", enableAgentMentions: "enableAgentMentions", EnableEntityMentions: "EnableEntityMentions", enableEntityMentions: "enableEntityMentions", EnableSkillCommands: "EnableSkillCommands", enableSkillCommands: "enableSkillCommands", EnablePlanMode: "EnablePlanMode", enablePlanMode: "enablePlanMode", EnableRealtime: "EnableRealtime", enableRealtime: "enableRealtime", MaxAttachments: "MaxAttachments", maxAttachments: "maxAttachments", MaxAttachmentSizeBytes: "MaxAttachmentSizeBytes", maxAttachmentSizeBytes: "maxAttachmentSizeBytes", AcceptedFileTypes: "AcceptedFileTypes", acceptedFileTypes: "acceptedFileTypes", ArtifactsByDetailId: "ArtifactsByDetailId", artifactsByDetailId: "artifactsByDetailId", SystemArtifactsByDetailId: "SystemArtifactsByDetailId", systemArtifactsByDetailId: "systemArtifactsByDetailId", AgentRunsByDetailId: "AgentRunsByDetailId", agentRunsByDetailId: "agentRunsByDetailId", EmptyStateMode: "EmptyStateMode", emptyStateMode: "emptyStateMode", AppContext: "AppContext", appContext: "appContext", DefaultAgentId: "DefaultAgentId", defaultAgentId: "defaultAgentId", ConversationDefaultAgentId: "ConversationDefaultAgentId", conversationDefaultAgentId: "conversationDefaultAgentId", AgentConfigurationPresetId: "AgentConfigurationPresetId", agentConfigurationPresetId: "agentConfigurationPresetId", InitialMessage: "InitialMessage", initialMessage: "initialMessage", InitialAttachments: "InitialAttachments", initialAttachments: "initialAttachments", ConversationHistory: "ConversationHistory", conversationHistory: "conversationHistory", InProgressMessageIds: "InProgressMessageIds", inProgressMessageIds: "inProgressMessageIds", ApplicationId: "ApplicationId", applicationId: "applicationId", AgentReplyMode: "AgentReplyMode", AllowedAgentIDs: "AllowedAgentIDs", MentionPeople: "MentionPeople", AgentHistoryFrom: "AgentHistoryFrom", AgentTurnHandler: "AgentTurnHandler", AutoNameConversation: "AutoNameConversation", EnableDecisionRouting: "EnableDecisionRouting", InitialDraft: "InitialDraft", initialDraft: "initialDraft" }, outputs: { MessageSent: "MessageSent", messageSent: "messageSent", AgentResponse: "AgentResponse", agentResponse: "agentResponse", BeforeAgentTurn: "BeforeAgentTurn", beforeAgentTurn: "beforeAgentTurn", AfterAgentTurn: "AfterAgentTurn", afterAgentTurn: "afterAgentTurn", AgentRunDetected: "AgentRunDetected", agentRunDetected: "agentRunDetected", AgentRunUpdate: "AgentRunUpdate", agentRunUpdate: "agentRunUpdate", MessageComplete: "MessageComplete", messageComplete: "messageComplete", ArtifactCreated: "ArtifactCreated", artifactCreated: "artifactCreated", ConversationRenamed: "ConversationRenamed", conversationRenamed: "conversationRenamed", IntentCheckStarted: "IntentCheckStarted", intentCheckStarted: "intentCheckStarted", IntentCheckCompleted: "IntentCheckCompleted", intentCheckCompleted: "intentCheckCompleted", InitialMessageAutoSendStarted: "InitialMessageAutoSendStarted", initialMessageAutoSendStarted: "initialMessageAutoSendStarted", InitialMessageAutoSendFailed: "InitialMessageAutoSendFailed", initialMessageAutoSendFailed: "initialMessageAutoSendFailed", EmptyStateSubmit: "EmptyStateSubmit", emptyStateSubmit: "emptyStateSubmit", UploadStateChanged: "UploadStateChanged", uploadStateChanged: "uploadStateChanged", InitialDraftApplied: "InitialDraftApplied", initialDraftApplied: "initialDraftApplied", DraftStateChanged: "DraftStateChanged", ComposerBlurred: "ComposerBlurred" }, standalone: false, features: [i0.ɵɵInheritDefinitionFeature, i0.ɵɵNgOnChangesFeature], decls: 6, vars: 29, consts: [["pickerOrigin", "cdkOverlayOrigin"], ["inputBox", ""], ["cdkOverlayOrigin", "", 1, "message-input-wrapper"], [1, "processing-indicator"], [3, "valueChange", "blurred", "textSubmitted", "attachmentsChanged", "attachmentError", "voiceRequested", "voiceOptionsRequested", "planModeToggle", "placeholder", "disabled", "showCharacterCount", "enableMentions", "EnableAgentMentions", "EnableEntityMentions", "EnableSkillCommands", "TargetAgentId", "AllowedAgentIDs", "MentionPeople", "enableAttachments", "maxAttachments", "maxAttachmentSizeBytes", "acceptedFileTypes", "currentUser", "Provider", "rows", "enableRealtime", "voiceActive", "canStartRealtime", "enablePlanMode", "planModeActive", "value"], ["cdkConnectedOverlay", "", "cdkConnectedOverlayBackdropClass", "cdk-overlay-transparent-backdrop", 3, "backdropClick", "detach", "cdkConnectedOverlayOrigin", "cdkConnectedOverlayOpen", "cdkConnectedOverlayPositions", "cdkConnectedOverlayPush", "cdkConnectedOverlayHasBackdrop"], [1, "fas", "fa-circle-notch", "fa-spin"], [3, "AgentPicked", "Cancelled", "Provider", "CurrentUser", "Agents", "DefaultAgentId", "CoAgents", "DefaultCoAgentId"]], template: function MessageInputComponent_Template(rf, ctx) { if (rf & 1) {
             i0.ɵɵelementStart(0, "div", 2, 0);
             i0.ɵɵconditionalCreate(2, MessageInputComponent_Conditional_2_Template, 4, 1, "div", 3);
             i0.ɵɵelementStart(3, "mj-ai-composer", 4, 1);
@@ -2496,107 +3356,215 @@ export class MessageInputComponent extends BaseAngularComponent {
             i0.ɵɵadvance(2);
             i0.ɵɵconditional(ctx.isProcessing ? 2 : -1);
             i0.ɵɵadvance();
-            i0.ɵɵproperty("placeholder", ctx.placeholder)("disabled", ctx.disabled || ctx.isProcessing)("showCharacterCount", false)("enableMentions", ctx.enableMentions)("EnableAgentMentions", ctx.enableAgentMentions)("EnableEntityMentions", ctx.enableEntityMentions)("EnableSkillCommands", ctx.enableSkillCommands)("TargetAgentId", ctx.pickerTargetAgentId)("enableAttachments", ctx.enableAttachments)("maxAttachments", ctx.maxAttachments)("maxAttachmentSizeBytes", ctx.maxAttachmentSizeBytes)("acceptedFileTypes", ctx.acceptedFileTypes)("currentUser", ctx.currentUser)("Provider", ctx.Provider)("rows", 3)("enableRealtime", ctx.enableRealtime)("voiceActive", ctx.voiceActive)("canStartRealtime", ctx.canStartRealtime)("enablePlanMode", ctx.enablePlanMode)("planModeActive", ctx.PlanModeEnabled)("value", ctx.messageText);
+            i0.ɵɵproperty("placeholder", ctx.placeholder)("disabled", ctx.disabled || ctx.isProcessing)("showCharacterCount", false)("enableMentions", ctx.enableMentions)("EnableAgentMentions", ctx.enableAgentMentions)("EnableEntityMentions", ctx.enableEntityMentions)("EnableSkillCommands", ctx.enableSkillCommands)("TargetAgentId", ctx.pickerTargetAgentId)("AllowedAgentIDs", ctx.AllowedAgentIDs)("MentionPeople", ctx.MentionPeople)("enableAttachments", ctx.enableAttachments)("maxAttachments", ctx.maxAttachments)("maxAttachmentSizeBytes", ctx.maxAttachmentSizeBytes)("acceptedFileTypes", ctx.acceptedFileTypes)("currentUser", ctx.currentUser)("Provider", ctx.Provider)("rows", 3)("enableRealtime", ctx.enableRealtime)("voiceActive", ctx.voiceActive)("canStartRealtime", ctx.canStartRealtime)("enablePlanMode", ctx.enablePlanMode)("planModeActive", ctx.PlanModeEnabled)("value", ctx.messageText);
             i0.ɵɵadvance(2);
             i0.ɵɵproperty("cdkConnectedOverlayOrigin", pickerOrigin_r3)("cdkConnectedOverlayOpen", ctx.showRealtimeAgentPicker)("cdkConnectedOverlayPositions", ctx.pickerOverlayPositions)("cdkConnectedOverlayPush", true)("cdkConnectedOverlayHasBackdrop", true);
         } }, dependencies: [i11.CdkConnectedOverlay, i11.CdkOverlayOrigin, i12.RealtimeAgentPickerComponent, i13.AiComposerComponent], styles: [".message-input-wrapper[_ngcontent-%COMP%] {\n  position: relative;\n  width: 100%;\n}\n\n\n\n\n.processing-indicator[_ngcontent-%COMP%] {\n  position: absolute;\n  top: 50%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n  display: flex;\n  align-items: center;\n  gap: 0.5rem;\n  padding: 0.75rem 1.25rem;\n  background: color-mix(in srgb, var(--mj-bg-surface-card) 95%, transparent);\n  border-radius: 8px;\n  box-shadow: var(--mj-shadow-sm);\n  z-index: 10;\n  pointer-events: none;\n}\n.processing-indicator[_ngcontent-%COMP%]   i[_ngcontent-%COMP%] {\n  color: var(--mj-brand-primary);\n}\n.processing-indicator[_ngcontent-%COMP%]   span[_ngcontent-%COMP%] {\n  font-size: 0.9rem;\n  color: var(--mj-text-primary);\n}"] });
 }
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MessageInputComponent, [{
         type: Component,
-        args: [{ standalone: false, selector: 'mj-message-input', template: "<div class=\"message-input-wrapper\" cdkOverlayOrigin #pickerOrigin=\"cdkOverlayOrigin\">\n  <!-- Processing Indicator Overlay -->\n  @if (isProcessing) {\n    <div class=\"processing-indicator\">\n      <i class=\"fas fa-circle-notch fa-spin\"></i>\n      <span>{{ processingMessage }}</span>\n    </div>\n  }\n\n  <!-- AI composer (mic + Plan Mode buttons live in its in-composer toolbar): wraps the\n       generic mj-message-input-box with the '@' agent / '#' record / '/' skill trigger\n       plugins built in \u2014 all three on by default, preserving the standard chat behavior. -->\n  <mj-ai-composer\n    #inputBox\n    [placeholder]=\"placeholder\"\n    [disabled]=\"disabled || isProcessing\"\n    [showCharacterCount]=\"false\"\n    [enableMentions]=\"enableMentions\"\n    [EnableAgentMentions]=\"enableAgentMentions\"\n    [EnableEntityMentions]=\"enableEntityMentions\"\n    [EnableSkillCommands]=\"enableSkillCommands\"\n    [TargetAgentId]=\"pickerTargetAgentId\"\n    [enableAttachments]=\"enableAttachments\"\n    [maxAttachments]=\"maxAttachments\"\n    [maxAttachmentSizeBytes]=\"maxAttachmentSizeBytes\"\n    [acceptedFileTypes]=\"acceptedFileTypes\"\n    [currentUser]=\"currentUser\"\n    [Provider]=\"Provider\"\n    [rows]=\"3\"\n    [enableRealtime]=\"enableRealtime\"\n    [voiceActive]=\"voiceActive\"\n    [canStartRealtime]=\"canStartRealtime\"\n    [enablePlanMode]=\"enablePlanMode\"\n    [planModeActive]=\"PlanModeEnabled\"\n    [value]=\"messageText\"\n    (valueChange)=\"OnComposerValueChanged($event)\"\n    (blurred)=\"ComposerBlurred.emit()\"\n    (textSubmitted)=\"onTextSubmitted($event)\"\n    (attachmentsChanged)=\"onAttachmentsChanged($event)\"\n    (attachmentError)=\"onAttachmentError($event)\"\n    (voiceRequested)=\"onStartRealtime()\"\n    (voiceOptionsRequested)=\"onRealtimeOptions()\"\n    (planModeToggle)=\"TogglePlanMode()\">\n  </mj-ai-composer>\n\n  <!-- Voice agent/co-agent/model picker \u2014 shown when starting a call on a conversation\n       with NO prior agent participation, or on demand via the caret next to the phone\n       button (any conversation). Rendered in a body-level CDK overlay anchored above the\n       composer so it POPS OUT of the chat overlay's clipping border instead of being cut\n       off at the top of a narrow (~390px) overlay. -->\n  <ng-template\n    cdkConnectedOverlay\n    [cdkConnectedOverlayOrigin]=\"pickerOrigin\"\n    [cdkConnectedOverlayOpen]=\"showRealtimeAgentPicker\"\n    [cdkConnectedOverlayPositions]=\"pickerOverlayPositions\"\n    [cdkConnectedOverlayPush]=\"true\"\n    [cdkConnectedOverlayHasBackdrop]=\"true\"\n    cdkConnectedOverlayBackdropClass=\"cdk-overlay-transparent-backdrop\"\n    (backdropClick)=\"onRealtimeAgentPickerCancelled()\"\n    (detach)=\"onRealtimeAgentPickerCancelled()\">\n    <mj-realtime-agent-picker\n      [Provider]=\"ProviderToUse\"\n      [CurrentUser]=\"currentUser\"\n      [Agents]=\"voicePickerAgents\"\n      [DefaultAgentId]=\"voicePickerDefaultAgentId\"\n      [CoAgents]=\"voicePickerCoAgents\"\n      [DefaultCoAgentId]=\"voicePickerDefaultCoAgentId\"\n      (AgentPicked)=\"onRealtimeAgentPicked($event)\"\n      (Cancelled)=\"onRealtimeAgentPickerCancelled()\">\n    </mj-realtime-agent-picker>\n  </ng-template>\n</div>\n\n<!-- The voice \"call mode\" overlay is hosted by <mj-conversation-chat-area> (it fills the\n     whole conversation panel in place); this component only owns the trigger wiring. -->\n", styles: [".message-input-wrapper {\n  position: relative;\n  width: 100%;\n}\n\n/* Plan Mode moved into the in-composer toolbar (message-input-box) as a toggle icon button\n   next to the attachment/voice buttons \u2014 see .plan-mode-button-icon there. */\n\n.processing-indicator {\n  position: absolute;\n  top: 50%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n  display: flex;\n  align-items: center;\n  gap: 0.5rem;\n  padding: 0.75rem 1.25rem;\n  background: color-mix(in srgb, var(--mj-bg-surface-card) 95%, transparent);\n  border-radius: 8px;\n  box-shadow: var(--mj-shadow-sm);\n  z-index: 10;\n  pointer-events: none;\n}\n.processing-indicator i {\n  color: var(--mj-brand-primary);\n}\n.processing-indicator span {\n  font-size: 0.9rem;\n  color: var(--mj-text-primary);\n}\n"] }]
-    }], () => [{ type: i1.DialogService }, { type: i2.ToastService }, { type: i3.ConversationAgentService }, { type: i4.DataCacheService }, { type: i5.ActiveTasksService }, { type: i6.ConversationStreamingService }, { type: i7.MentionParserService }, { type: i8.ConversationAttachmentService }, { type: i9.ConversationBridgeService }, { type: i10.RealtimeSessionService }], { conversationId: [{
+        args: [{ standalone: false, selector: 'mj-message-input', template: "<div class=\"message-input-wrapper\" cdkOverlayOrigin #pickerOrigin=\"cdkOverlayOrigin\">\n  <!-- Processing Indicator Overlay -->\n  @if (isProcessing) {\n    <div class=\"processing-indicator\">\n      <i class=\"fas fa-circle-notch fa-spin\"></i>\n      <span>{{ processingMessage }}</span>\n    </div>\n  }\n\n  <!-- AI composer (mic + Plan Mode buttons live in its in-composer toolbar): wraps the\n       generic mj-message-input-box with the '@' agent / '#' record / '/' skill trigger\n       plugins built in \u2014 all three on by default, preserving the standard chat behavior. -->\n  <mj-ai-composer\n    #inputBox\n    [placeholder]=\"placeholder\"\n    [disabled]=\"disabled || isProcessing\"\n    [showCharacterCount]=\"false\"\n    [enableMentions]=\"enableMentions\"\n    [EnableAgentMentions]=\"enableAgentMentions\"\n    [EnableEntityMentions]=\"enableEntityMentions\"\n    [EnableSkillCommands]=\"enableSkillCommands\"\n    [TargetAgentId]=\"pickerTargetAgentId\"\n    [AllowedAgentIDs]=\"AllowedAgentIDs\"\n    [MentionPeople]=\"MentionPeople\"\n    [enableAttachments]=\"enableAttachments\"\n    [maxAttachments]=\"maxAttachments\"\n    [maxAttachmentSizeBytes]=\"maxAttachmentSizeBytes\"\n    [acceptedFileTypes]=\"acceptedFileTypes\"\n    [currentUser]=\"currentUser\"\n    [Provider]=\"Provider\"\n    [rows]=\"3\"\n    [enableRealtime]=\"enableRealtime\"\n    [voiceActive]=\"voiceActive\"\n    [canStartRealtime]=\"canStartRealtime\"\n    [enablePlanMode]=\"enablePlanMode\"\n    [planModeActive]=\"PlanModeEnabled\"\n    [value]=\"messageText\"\n    (valueChange)=\"OnComposerValueChanged($event)\"\n    (blurred)=\"ComposerBlurred.emit()\"\n    (textSubmitted)=\"onTextSubmitted($event)\"\n    (attachmentsChanged)=\"onAttachmentsChanged($event)\"\n    (attachmentError)=\"onAttachmentError($event)\"\n    (voiceRequested)=\"onStartRealtime()\"\n    (voiceOptionsRequested)=\"onRealtimeOptions()\"\n    (planModeToggle)=\"TogglePlanMode()\">\n  </mj-ai-composer>\n\n  <!-- Voice agent/co-agent/model picker \u2014 shown when starting a call on a conversation\n       with NO prior agent participation, or on demand via the caret next to the phone\n       button (any conversation). Rendered in a body-level CDK overlay anchored above the\n       composer so it POPS OUT of the chat overlay's clipping border instead of being cut\n       off at the top of a narrow (~390px) overlay. -->\n  <ng-template\n    cdkConnectedOverlay\n    [cdkConnectedOverlayOrigin]=\"pickerOrigin\"\n    [cdkConnectedOverlayOpen]=\"showRealtimeAgentPicker\"\n    [cdkConnectedOverlayPositions]=\"pickerOverlayPositions\"\n    [cdkConnectedOverlayPush]=\"true\"\n    [cdkConnectedOverlayHasBackdrop]=\"true\"\n    cdkConnectedOverlayBackdropClass=\"cdk-overlay-transparent-backdrop\"\n    (backdropClick)=\"onRealtimeAgentPickerCancelled()\"\n    (detach)=\"onRealtimeAgentPickerCancelled()\">\n    <mj-realtime-agent-picker\n      [Provider]=\"ProviderToUse\"\n      [CurrentUser]=\"currentUser\"\n      [Agents]=\"voicePickerAgents\"\n      [DefaultAgentId]=\"voicePickerDefaultAgentId\"\n      [CoAgents]=\"voicePickerCoAgents\"\n      [DefaultCoAgentId]=\"voicePickerDefaultCoAgentId\"\n      (AgentPicked)=\"onRealtimeAgentPicked($event)\"\n      (Cancelled)=\"onRealtimeAgentPickerCancelled()\">\n    </mj-realtime-agent-picker>\n  </ng-template>\n</div>\n\n<!-- The voice \"call mode\" overlay is hosted by <mj-conversation-chat-area> (it fills the\n     whole conversation panel in place); this component only owns the trigger wiring. -->\n", styles: [".message-input-wrapper {\n  position: relative;\n  width: 100%;\n}\n\n/* Plan Mode moved into the in-composer toolbar (message-input-box) as a toggle icon button\n   next to the attachment/voice buttons \u2014 see .plan-mode-button-icon there. */\n\n.processing-indicator {\n  position: absolute;\n  top: 50%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n  display: flex;\n  align-items: center;\n  gap: 0.5rem;\n  padding: 0.75rem 1.25rem;\n  background: color-mix(in srgb, var(--mj-bg-surface-card) 95%, transparent);\n  border-radius: 8px;\n  box-shadow: var(--mj-shadow-sm);\n  z-index: 10;\n  pointer-events: none;\n}\n.processing-indicator i {\n  color: var(--mj-brand-primary);\n}\n.processing-indicator span {\n  font-size: 0.9rem;\n  color: var(--mj-text-primary);\n}\n"] }]
+    }], () => [{ type: i1.DialogService }, { type: i2.ToastService }, { type: i3.ConversationAgentService }, { type: i4.DataCacheService }, { type: i5.ActiveTasksService }, { type: i6.ConversationStreamingService }, { type: i7.MentionParserService }, { type: i8.ConversationAttachmentService }, { type: i9.ConversationBridgeService }, { type: i10.RealtimeSessionService }], { ConversationId: [{
+            type: Input
+        }], conversationId: [{
+            type: Input
+        }], ConversationName: [{
             type: Input
         }], conversationName: [{
             type: Input
+        }], CurrentUser: [{
+            type: Input
         }], currentUser: [{
             type: Input
+        }], Disabled: [{
+            type: Input
         }], disabled: [{
             type: Input
+        }], ReadOnly: [{
+            type: Input
+        }], Placeholder: [{
+            type: Input
         }], placeholder: [{
             type: Input
+        }], ParentMessageId: [{
+            type: Input
         }], parentMessageId: [{
             type: Input
+        }], EnableAttachments: [{
+            type: Input
         }], enableAttachments: [{
             type: Input
+        }], EnableMentions: [{
+            type: Input
         }], enableMentions: [{
             type: Input
+        }], EnableAgentMentions: [{
+            type: Input
         }], enableAgentMentions: [{
             type: Input
+        }], EnableEntityMentions: [{
+            type: Input
         }], enableEntityMentions: [{
             type: Input
+        }], EnableSkillCommands: [{
+            type: Input
         }], enableSkillCommands: [{
             type: Input
+        }], EnablePlanMode: [{
+            type: Input
         }], enablePlanMode: [{
             type: Input
+        }], EnableRealtime: [{
+            type: Input
         }], enableRealtime: [{
             type: Input
+        }], MaxAttachments: [{
+            type: Input
         }], maxAttachments: [{
             type: Input
+        }], MaxAttachmentSizeBytes: [{
+            type: Input
         }], maxAttachmentSizeBytes: [{
             type: Input
+        }], AcceptedFileTypes: [{
+            type: Input
         }], acceptedFileTypes: [{
             type: Input
+        }], ArtifactsByDetailId: [{
+            type: Input
         }], artifactsByDetailId: [{
             type: Input
+        }], SystemArtifactsByDetailId: [{
+            type: Input
         }], systemArtifactsByDetailId: [{
             type: Input
+        }], AgentRunsByDetailId: [{
+            type: Input
         }], agentRunsByDetailId: [{
             type: Input
+        }], EmptyStateMode: [{
+            type: Input
         }], emptyStateMode: [{
             type: Input
+        }], AppContext: [{
+            type: Input
         }], appContext: [{
             type: Input
+        }], DefaultAgentId: [{
+            type: Input
         }], defaultAgentId: [{
             type: Input
+        }], ConversationDefaultAgentId: [{
+            type: Input
         }], conversationDefaultAgentId: [{
             type: Input
+        }], AgentConfigurationPresetId: [{
+            type: Input
         }], agentConfigurationPresetId: [{
             type: Input
+        }], InitialMessage: [{
+            type: Input
         }], initialMessage: [{
             type: Input
+        }], InitialAttachments: [{
+            type: Input
         }], initialAttachments: [{
             type: Input
+        }], ConversationHistory: [{
+            type: Input
         }], conversationHistory: [{
             type: Input
+        }], InProgressMessageIds: [{
+            type: Input
         }], inProgressMessageIds: [{
             type: Input
+        }], ApplicationId: [{
+            type: Input
         }], applicationId: [{
             type: Input
+        }], AgentReplyMode: [{
+            type: Input
+        }], AllowedAgentIDs: [{
+            type: Input
+        }], MentionPeople: [{
+            type: Input
+        }], AgentHistoryFrom: [{
+            type: Input
+        }], AgentTurnHandler: [{
+            type: Input
+        }], AutoNameConversation: [{
+            type: Input
+        }], EnableDecisionRouting: [{
+            type: Input
+        }], MessageSent: [{
+            type: Output
         }], messageSent: [{
             type: Output
+        }], AgentResponse: [{
+            type: Output
         }], agentResponse: [{
             type: Output
+        }], BeforeAgentTurn: [{
+            type: Output
         }], beforeAgentTurn: [{
             type: Output
+        }], AfterAgentTurn: [{
+            type: Output
         }], afterAgentTurn: [{
             type: Output
+        }], AgentRunDetected: [{
+            type: Output
         }], agentRunDetected: [{
             type: Output
+        }], AgentRunUpdate: [{
+            type: Output
         }], agentRunUpdate: [{
             type: Output
+        }], MessageComplete: [{
+            type: Output
         }], messageComplete: [{
             type: Output
+        }], ArtifactCreated: [{
+            type: Output
         }], artifactCreated: [{
             type: Output
+        }], ConversationRenamed: [{
+            type: Output
         }], conversationRenamed: [{
             type: Output
+        }], IntentCheckStarted: [{
+            type: Output
         }], intentCheckStarted: [{
             type: Output
+        }], IntentCheckCompleted: [{
+            type: Output
         }], intentCheckCompleted: [{
             type: Output
+        }], InitialMessageAutoSendStarted: [{
+            type: Output
         }], initialMessageAutoSendStarted: [{
             type: Output
+        }], InitialMessageAutoSendFailed: [{
+            type: Output
         }], initialMessageAutoSendFailed: [{
             type: Output
+        }], EmptyStateSubmit: [{
+            type: Output
         }], emptyStateSubmit: [{
             type: Output
+        }], UploadStateChanged: [{
+            type: Output
         }], uploadStateChanged: [{
             type: Output
-        }], inputBox: [{
+        }], InputBox: [{
             type: ViewChild,
             args: ['inputBox']
+        }], InitialDraft: [{
+            type: Input
         }], initialDraft: [{
             type: Input
+        }], InitialDraftApplied: [{
+            type: Output
         }], initialDraftApplied: [{
             type: Output
         }], DraftStateChanged: [{
@@ -2604,5 +3572,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: 45 }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(MessageInputComponent, { className: "MessageInputComponent", filePath: "src/lib/components/message/message-input.component.ts", lineNumber: 66 }); })();
 //# sourceMappingURL=message-input.component.js.map