@memberjunction/server 6.2.0-edge.0 → 6.2.0-edge.2

package/src/resolvers/RunAIAgentResolver.ts

@@ -4,14 +4,15 @@ import { DatabaseProviderBase, LogError, LogStatus, Metadata, RunView, UserInfo,
 import { MJConversationDetailEntity, MJConversationDetailAttachmentEntity, MJConversationDetailArtifactEntity, MJArtifactVersionEntity, MJAIAgentRequestEntity, ArtifactMetadataEngine, ConversationEngine } from '@memberjunction/core-entities';
 import { RouteArtifact } from './artifact-routing.js';
 import { AgentRunner, ArtifactToolManager } from '@memberjunction/ai-agents';
-import { MJAIAgentEntityExtended, MJAIAgentRunEntityExtended, ExecuteAgentResult, ConversationUtility, AttachmentData, AgentExecutionStreamingCallback } from '@memberjunction/ai-core-plus';
+import { MJAIAgentEntityExtended, MJAIAgentRunEntityExtended, ExecuteAgentResult, ConversationUtility, AttachmentData } from '@memberjunction/ai-core-plus';
 import { AIEngine } from '@memberjunction/aiengine';
 import { ChatMessage, ChatMessageContent } from '@memberjunction/ai';
 import { ResolverBase } from '../generic/ResolverBase.js';
-import { startLivenessPulse } from '../generic/FireAndForgetHeartbeat.js';
+import { AgentRunStatusPublisher } from './AgentRunStatusPublisher.js';
+import { StartLivenessPulse } from '../generic/FireAndForgetHeartbeat.js';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { GetReadWriteProvider } from '../util.js';
-import { resolveWidgetGuestRunContext, elevateUserPayload } from '../realtimeWidget/widgetGuestElevation.js';
+import { ResolveWidgetGuestRunContext, ElevateUserPayload } from '../realtimeWidget/widgetGuestElevation.js';
 import { SafeJSONParse, UUIDsEqual } from '@memberjunction/global';
 import { GetAttachmentService } from '@memberjunction/aiengine';
 import { NotificationEngine } from '@memberjunction/notifications';
@@ -25,58 +26,63 @@ import { NotificationEngine } from '@memberjunction/notifications';
  */
 const INLINE_SIZE_CAP = 100 * 1024;
 
+/** Progress metadata is an untyped bag. A run is an object that carries an ID field. */
+function isAgentRunEntity(value: unknown): value is MJAIAgentRunEntityExtended {
+    return typeof value === 'object' && value !== null && 'ID' in value;
+}
+
 @ObjectType()
 export class AIAgentRunResult {
     @Field()
-    success: boolean;
+    success: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    errorMessage?: string;
+    errorMessage?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    executionTimeMs?: number;
+    executionTimeMs?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    result: string; // JSON serialized ExecuteAgentResult with scalars only
+    result: string; // JSON serialized ExecuteAgentResult with scalars only — case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class AgentExecutionProgress {
     @Field()
-    currentStep: string;
+    currentStep: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    percentage?: number;
+    percentage?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    message: string;
+    message: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    agentName?: string;
+    agentName?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    agentType?: string;
+    agentType?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    stepCount?: number;
+    stepCount?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    hierarchicalStep?: string;
+    hierarchicalStep?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class AgentStreamingContent {
     @Field()
-    content: string;
+    content: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    isPartial: boolean;
+    isPartial: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    stepName?: string;
+    stepName?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    agentName?: string;
+    agentName?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     /**
      * Content discriminator passed through from the agent's streaming chunk (see
@@ -87,73 +93,73 @@ export class AgentStreamingContent {
      * rendered by the conversation client.
      */
     @Field({ nullable: true })
-    kind?: string;
+    kind?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class AgentExecutionStepSummary {
     @Field()
-    stepId: string;
+    stepId: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    stepName: string;
+    stepName: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    agentName?: string;
+    agentName?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    agentType?: string;
+    agentType?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    startTime: Date;
+    startTime: Date;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    endTime?: Date;
+    endTime?: Date;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    status: string;
+    status: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    result?: string;
+    result?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class AgentPartialResult {
     @Field()
-    currentStep: string;
+    currentStep: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    partialOutput?: string;
+    partialOutput?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class AgentExecutionStreamMessage {
     @Field(() => ID)
-    sessionId: string;
+    sessionId: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => ID)
-    agentRunId: string;
+    agentRunId: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    type: 'progress' | 'streaming' | 'partial_result' | 'complete';
+    type: 'progress' | 'streaming' | 'partial_result' | 'complete';  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    progress?: AgentExecutionProgress;
+    progress?: AgentExecutionProgress;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    streaming?: AgentStreamingContent;
+    streaming?: AgentStreamingContent;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field({ nullable: true })
-    partialResult?: AgentPartialResult;
+    partialResult?: AgentPartialResult;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    timestamp: Date;
+    timestamp: Date;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     // Not a GraphQL field - used internally for streaming
-    agentRun?: any;
+    agentRun?: any;  // case-violation-ok-legacy-back-compat: an accessor cannot be optional, so a stub would turn this into a required member
 
     // Not a GraphQL field - used for completion routing to correct conversation detail
-    conversationDetailId?: string;
+    conversationDetailId?: string;  // case-violation-ok-legacy-back-compat: an accessor cannot be optional, so a stub would turn this into a required member
 }
 
 
@@ -249,111 +255,6 @@ export class RunAIAgentResolver extends ResolverBase {
         return agentEntity;
     }
 
-    /**
-     * Create streaming progress callback
-     */
-    private createProgressCallback(pubSub: PubSubEngine, sessionId: string, userPayload: UserPayload, agentRunRef: { current: any }) {
-        return (progress: any) => {
-            // Capture the agent run into the ref as soon as any progress event carries it (even
-            // "noise" steps), so the fire-and-forget liveness pulse can read its id/status mid-run
-            // rather than only after RunAgentInConversation returns.
-            if (progress.metadata?.agentRun) {
-                agentRunRef.current = progress.metadata.agentRun;
-            }
-
-            // Only publish progress for significant steps (not initialization noise)
-            const significantSteps = ['prompt_execution', 'action_execution', 'subagent_execution', 'decision_processing'];
-            if (!significantSteps.includes(progress.step)) {
-                console.log(`🔇 Skipping noise progress: ${progress.step}`);
-                return;
-            }
-            
-            // Get the agent run from the progress metadata or use the ref
-            const agentRun = progress.metadata?.agentRun || agentRunRef.current;
-            if (!agentRun) {
-                console.error('❌ No agent run available for progress callback');
-                return;
-            }
-            
-            console.log('📡 Publishing progress update:', {
-                step: progress.step,
-                percentage: progress.percentage,
-                message: progress.message,
-                sessionId,
-                agentRunId: agentRun.ID
-            });
-            
-            // Publish progress updates with the full serialized agent run
-            const progressMsg: AgentExecutionStreamMessage = {
-                sessionId,
-                agentRunId: agentRun.ID,
-                type: 'progress',
-                agentRun: agentRun.GetAll(), // Serialize the full agent run
-                progress: {
-                    currentStep: progress.step,
-                    percentage: progress.percentage,
-                    message: progress.message,
-                    agentName: (progress.metadata as any)?.agentName || undefined,
-                    agentType: (progress.metadata as any)?.agentType || undefined,
-                    stepCount: (progress.metadata as any)?.stepCount || undefined,
-                    hierarchicalStep: (progress.metadata as any)?.hierarchicalStep || undefined
-                },
-                timestamp: new Date()
-            };
-            this.PublishProgressUpdate(pubSub, progressMsg, userPayload);
-        };
-    }
-
-    private PublishProgressUpdate(pubSub: PubSubEngine, data: any, userPayload: UserPayload) {
-        this.PublishStatusUpdate(pubSub, userPayload.sessionId, JSON.stringify({
-            resolver: 'RunAIAgentResolver',
-            type: 'ExecutionProgress',
-            status: 'ok',
-            data,
-        }), userPayload);
-    }
-
-
-    private PublishStreamingUpdate(pubSub: PubSubEngine, data: any, userPayload: UserPayload) {
-        this.PublishStatusUpdate(pubSub, userPayload.sessionId, JSON.stringify({
-            resolver: 'RunAIAgentResolver',
-            type: 'StreamingContent',
-            status: 'ok',
-            data,
-        }), userPayload);
-    }
-
-    /**
-     * Create streaming content callback
-     */
-    private createStreamingCallback(pubSub: PubSubEngine, sessionId: string, userPayload: UserPayload, agentRunRef: { current: MJAIAgentRunEntityExtended | null }): AgentExecutionStreamingCallback {
-        return (chunk) => {
-            // Use the agent run from the ref
-            const agentRun = agentRunRef.current;
-            if (!agentRun) {
-                console.error('❌ No agent run available for streaming callback');
-                return;
-            }
-
-            // Publish streaming content with the full serialized agent run
-            const streamMsg: AgentExecutionStreamMessage = {
-                sessionId,
-                agentRunId: agentRun.ID,
-                type: 'streaming',
-                agentRun: agentRun.GetAll(), // Include the full serialized agent run
-                streaming: {
-                    content: chunk.content,
-                    isPartial: !chunk.isComplete,
-                    stepName: chunk.stepType,
-                    agentName: chunk.modelName,
-                    kind: chunk.kind
-                },
-                timestamp: new Date()
-            };
-            this.PublishStreamingUpdate(pubSub, streamMsg, userPayload);
-        };
-    }
-
     /**
      * Internal method that handles the core AI agent execution logic.
      * This method is called by both the regular and system user resolvers.
@@ -389,7 +290,10 @@ export class RunAIAgentResolver extends ResolverBase {
          *  The framework intersects them with the agent's accepted skills AND the user's Run permission. */
         requestedSkillIDs?: string[],
         /** JSON `{ paused?: boolean }` — seeds `$.debug` on a submitted task graph at insert. */
-        taskGraphDebug?: string
+        taskGraphDebug?: string,
+        /** History floor for a conversation run — threaded into ExecuteAgentParams.ConversationHistoryFrom,
+         *  so the framework's own conversation reads (retrieval tools, artifacts, compaction) honour it too. */
+        conversationHistoryFrom?: Date
     ): Promise<AIAgentRunResult> {
         const startTime = Date.now();
         // Best-effort handle for persistInFlightAgentFailure. Populated from a
@@ -431,6 +335,11 @@ export class RunAIAgentResolver extends ResolverBase {
 
             console.log(`🚀 Starting agent execution with sessionId: ${sessionId}`);
 
+            // The publisher owns every status message. The resolver still copies the run into
+            // agentRunRef, including noise steps, for the fire-and-forget liveness pulse.
+            const statusPublisher = new AgentRunStatusPublisher(pubSub, userPayload, sessionId);
+            const publishProgress = statusPublisher.OnProgress;
+
             // Execute the agent in conversation context - handles conversation, artifacts, etc.
             const conversationResult = await agentRunner.RunAgentInConversation({
                 agent: agentEntity,
@@ -438,14 +347,21 @@ export class RunAIAgentResolver extends ResolverBase {
                 payload: payload ? SafeJSONParse(payload) : undefined,
                 contextUser: currentUser,
                 sessionID: sessionId,
-                onProgress: this.createProgressCallback(pubSub, sessionId, userPayload, agentRunRef),
-                onStreaming: this.createStreamingCallback(pubSub, sessionId, userPayload, agentRunRef),
+                onProgress: (progress) => {
+                    const fromEvent = progress.metadata?.agentRun;
+                    if (isAgentRunEntity(fromEvent)) {
+                        agentRunRef.current = fromEvent;
+                    }
+                    publishProgress(progress);
+                },
+                onStreaming: statusPublisher.OnStreaming,
                 lastRunId: lastRunId,
                 autoPopulateLastRunPayload: autoPopulateLastRunPayload,
                 configurationId: configurationId,
                 planMode: planMode,
                 requestedSkillIDs: requestedSkillIDs,
                 taskGraphDebug: parseTaskGraphDebug(taskGraphDebug),
+                ConversationHistoryFrom: conversationHistoryFrom,
                 data: parsedData,
                 context: {
                     dataSource: dataSource
@@ -522,7 +438,7 @@ export class RunAIAgentResolver extends ResolverBase {
             const returnResult = JSON.stringify(sanitizedResult);
 
             // Publish final events with enriched result data for fire-and-forget clients
-            this.publishFinalEvents(pubSub, sessionId, userPayload, result, returnResult);
+            statusPublisher.PublishFinal(result, result.agentRun?.ConversationDetailID, returnResult);
 
             // Log completion
             if (result.success) {
@@ -598,7 +514,10 @@ export class RunAIAgentResolver extends ResolverBase {
                     detail.Message = errorMessage;
                     detail.Error = errorMessage;
                     if (!(await detail.Save())) {
-                        LogError(`Failed to persist Error on conversation detail ${conversationDetailId}`);
+                        LogError(
+                            `Failed to persist Error on conversation detail ${conversationDetailId}: ` +
+                                `${detail.LatestResult?.CompleteMessage?.trim() || 'no failure detail recorded'}`,
+                        );
                     }
                 }
             }
@@ -607,58 +526,6 @@ export class RunAIAgentResolver extends ResolverBase {
         }
     }
 
-    /**
-     * Publish final streaming events (partial result and completion).
-     * The completion event includes the full result JSON so clients using
-     * fire-and-forget mode can receive the result via WebSocket.
-     */
-    private publishFinalEvents(
-        pubSub: PubSubEngine,
-        sessionId: string,
-        userPayload: UserPayload,
-        result: ExecuteAgentResult,
-        resultJson?: string
-    ) {
-        if (result.agentRun) {
-            // Get the last step from agent run
-            let lastStep = 'Completed';
-            if (result.agentRun?.Steps && result.agentRun.Steps.length > 0) {
-                // Get the last step from the Steps array
-                const lastStepEntity = result.agentRun.Steps[result.agentRun.Steps.length - 1];
-                lastStep = lastStepEntity?.StepName || 'Completed';
-            }
-
-            // Publish partial result
-            const partialResult: AgentPartialResult = {
-                currentStep: lastStep,
-                partialOutput: result.payload || undefined
-            };
-
-            const partialMsg: AgentExecutionStreamMessage = {
-                sessionId,
-                agentRunId: result.agentRun.ID,
-                type: 'partial_result',
-                partialResult,
-                timestamp: new Date()
-            };
-            this.PublishStreamingUpdate(pubSub, partialMsg, userPayload);
-        }
-
-        // Publish completion with conversationDetailId for client-side routing.
-        // Include result data so fire-and-forget clients can receive the full result via WebSocket.
-        const completionData: Record<string, unknown> = {
-            sessionId,
-            agentRunId: result.agentRun?.ID || 'unknown',
-            type: 'complete',
-            timestamp: new Date(),
-            conversationDetailId: result.agentRun?.ConversationDetailID,
-            success: result.success,
-            errorMessage: result.agentRun?.ErrorMessage || undefined,
-            result: resultJson || undefined
-        };
-        this.PublishStreamingUpdate(pubSub, completionData, userPayload);
-    }
-
     /**
      * Public mutation for regular users to run AI agents with authentication.
      * Supports fire-and-forget mode to avoid Azure proxy timeouts on long-running agent executions.
@@ -1017,7 +884,13 @@ export class RunAIAgentResolver extends ResolverBase {
         @Arg('sourceArtifactVersionId', { nullable: true }) sourceArtifactVersionId?: string,
         @Arg('fireAndForget', { nullable: true }) fireAndForget?: boolean,
         @Arg('planMode', { nullable: true }) planMode?: boolean,
-        @Arg('requestedSkillIDs', () => [String], { nullable: true }) requestedSkillIDs?: string[]
+        @Arg('requestedSkillIDs', () => [String], { nullable: true }) requestedSkillIDs?: string[],
+        /** History floor: an ISO-8601 timestamp, the first moment of the conversation this run may
+         *  read. The history is loaded from there and no summary of earlier messages is used, and the
+         *  run's own conversation reads honour it too. Omitted (clients send it only when set, so an
+         *  older client never does), the run reads the whole conversation as before. An unreadable
+         *  value fails the request rather than being dropped. */
+        @Arg('agentHistoryFrom', { nullable: true }) agentHistoryFrom?: string
     ): Promise<AIAgentRunResult> {
         // Check API key scope authorization for agent execution
         await this.CheckAPIKeyScopeAuthorization('agent:execute', agentId, userPayload);
@@ -1040,11 +913,14 @@ export class RunAIAgentResolver extends ResolverBase {
         // Conversation OWNERSHIP is still enforced under the guest principal below: the guest loads its
         // own ConversationDetail through the Widget Guest RLS filters, so a detail id from another
         // session resolves to "not found" before any elevated work happens.
-        const widgetElevation = await resolveWidgetGuestRunContext(userPayload, p);
-        const effectiveAgentId = widgetElevation ? widgetElevation.pinnedAgentId : agentId;
-        const effectiveUserPayload = widgetElevation ? elevateUserPayload(userPayload, widgetElevation.elevatedUser) : userPayload;
+        const widgetElevation = await ResolveWidgetGuestRunContext(userPayload, p);
+        const effectiveAgentId = widgetElevation ? widgetElevation.PinnedAgentId : agentId;
+        const effectiveUserPayload = widgetElevation ? ElevateUserPayload(userPayload, widgetElevation.ElevatedUser) : userPayload;
 
         try {
+            // Parsed before anything loads: a floor the caller asked for must never be dropped.
+            const historyFrom = parseAgentHistoryFrom(agentHistoryFrom);
+
             // LATENCY OPTIMIZATION (Opt #2 + #3): Load ConversationDetail once here to extract
             // conversationId, then pass it downstream. Previously this record was loaded multiple
             // times: once in loadConversationHistoryWithAttachments (just to get conversationId),
@@ -1067,7 +943,8 @@ export class RunAIAgentResolver extends ResolverBase {
                 p,
                 // The UI creates the agent-response placeholder row ('⏳ ...') before invoking
                 // this mutation — exclude it so the model never sees an empty assistant turn.
-                [conversationDetailId]
+                [conversationDetailId],
+                historyFrom
             );
 
             // Convert to JSON string for the existing executeAIAgent method
@@ -1080,7 +957,9 @@ export class RunAIAgentResolver extends ResolverBase {
                     p, dataSource, effectiveAgentId, effectiveUserPayload, messagesJson, sessionId, pubSub,
                     data, payload, lastRunId, autoPopulateLastRunPayload, configurationId,
                     conversationDetailId, createArtifacts || false, createNotification || false,
-                    sourceArtifactId, sourceArtifactVersionId, conversationId, planMode, requestedSkillIDs
+                    sourceArtifactId, sourceArtifactVersionId, conversationId, planMode, requestedSkillIDs,
+                    undefined, // taskGraphDebug
+                    historyFrom
                 );
 
                 LogStatus(`🔥 Fire-and-forget: Agent ${effectiveAgentId} execution started in background for session ${sessionId}`);
@@ -1114,7 +993,9 @@ export class RunAIAgentResolver extends ResolverBase {
                 conversationId, // LATENCY OPT #2: pass pre-resolved conversationId
                 undefined, // runRef
                 planMode,
-                requestedSkillIDs
+                requestedSkillIDs,
+                undefined, // taskGraphDebug
+                historyFrom
             );
         } catch (error) {
             const errorMessage = (error as Error).message || 'Unknown error loading conversation history';
@@ -1334,11 +1215,13 @@ export class RunAIAgentResolver extends ResolverBase {
         planMode?: boolean,
         /** Skill IDs the user requested — threaded through to ExecuteAgentParams.requestedSkillIDs. */
         requestedSkillIDs?: string[],
-        taskGraphDebug?: string
+        taskGraphDebug?: string,
+        /** History floor — threaded through to ExecuteAgentParams.ConversationHistoryFrom. */
+        conversationHistoryFrom?: Date
     ): void {
         // Ref the liveness pulse reads to enrich heartbeats once the run is created.
         const runRef: { current: MJAIAgentRunEntityExtended | null } = { current: null };
-        const pulse = startLivenessPulse({
+        const pulse = StartLivenessPulse({
             pubSub,
             sessionId,
             ownerUserId: userPayload.userRecord.ID,
@@ -1353,26 +1236,18 @@ export class RunAIAgentResolver extends ResolverBase {
             p, dataSource, agentId, userPayload, messagesJson, sessionId, pubSub,
             data, payload, undefined, lastRunId, autoPopulateLastRunPayload,
             configurationId, conversationDetailId, createArtifacts, createNotification,
-            sourceArtifactId, sourceArtifactVersionId, conversationId, runRef, planMode, requestedSkillIDs, taskGraphDebug
+            sourceArtifactId, sourceArtifactVersionId, conversationId, runRef, planMode, requestedSkillIDs, taskGraphDebug,
+            conversationHistoryFrom
         ).catch((error: unknown) => {
             // Background execution failed unexpectedly (executeAIAgent has its own try-catch,
             // so this would only fire for truly unexpected errors).
             const errorMessage = (error instanceof Error) ? error.message : 'Unknown background execution error';
             LogError(`🔥 Fire-and-forget background execution failed: ${errorMessage}`, undefined, error);
 
-            // Publish error completion event so the client knows the agent failed
-            const errorCompletionData: Record<string, unknown> = {
-                sessionId,
-                agentRunId: 'unknown',
-                type: 'complete',
-                timestamp: new Date(),
-                conversationDetailId,
-                success: false,
-                errorMessage,
-                result: JSON.stringify({ success: false, errorMessage })
-            };
-            this.PublishStreamingUpdate(pubSub, errorCompletionData, userPayload);
-        }).finally(() => pulse.stop());
+            // Publish error completion event so the client knows the agent failed.
+            // The publisher is created inside executeAIAgent, which rejected before returning one.
+            new AgentRunStatusPublisher(pubSub, userPayload, sessionId).PublishFailure(conversationDetailId, errorMessage);
+        }).finally(() => pulse.Stop());
     }
 
     /**
@@ -1389,7 +1264,7 @@ export class RunAIAgentResolver extends ResolverBase {
      *
      * Opt #8: Switched from ResultType 'entity_object' to 'simple' with explicit Fields.
      * The history query only needs the window-assembly fields (ConversationWindowFields:
-     * ID, Sequence, Role, Message, SummaryOfEarlierConversation) from each
+     * ID, Sequence, Role, Message, SummaryOfEarlierConversation, __mj_CreatedAt) from each
      * ConversationDetail record. Using 'entity_object' created full BaseEntity instances
      * with getters/setters, dirty tracking, and validation — none of which are needed for
      * read-only history assembly. The 'simple' result type returns plain JS objects,
@@ -1400,13 +1275,15 @@ export class RunAIAgentResolver extends ResolverBase {
         contextUser: UserInfo,
         maxMessages: number,
         provider: IMetadataProvider,
-        excludeDetailIds?: string[]
+        excludeDetailIds?: string[],
+        /** History floor: only rows written at or after it are loaded, and no summary is used. */
+        historyFrom?: Date
     ): Promise<ChatMessage[]> {
         // Context windowing (summary boundary + raw tail, or legacy last-N when no
         // summary exists) shares ONE fold implementation with all other callers —
         // ConversationEngine.AssembleContextWindow — and the ROWS come from the
         // single-sourced fresh-per-request loader (same one the compaction pass uses).
-        // Three deliberate properties vs. the engine's cached GetAgentContextWindow:
+        // Four deliberate properties vs. the engine's cached GetAgentContextWindow:
         //   1. Entity RLS applies (the engine path loads via a stored query with no
         //      row-level security — wrong for guest/widget-scoped users), and the
         //      process-global per-conversation cache — keyed by conversation, not user —
@@ -1415,10 +1292,13 @@ export class RunAIAgentResolver extends ResolverBase {
         //      cross-server staleness (a warm cache misses rows written by other nodes).
         //   3. Load failure THROWS → the mutation fails, instead of silently running
         //      the agent against zero history.
-        const rows = await ConversationEngine.LoadWindowRowsFresh(conversationId, contextUser, provider);
+        //   4. A history floor (`historyFrom`) is applied in the query, so rows before it never
+        //      leave the database, and again in the assembly, which then skips the summary.
+        const rows = await ConversationEngine.LoadWindowRowsFresh(conversationId, contextUser, provider, historyFrom);
         const window = ConversationEngine.AssembleContextWindow(rows, {
             maxTailMessages: maxMessages,
-            excludeDetailIds
+            excludeDetailIds,
+            historyFrom
         });
 
         // Batch load input artifacts for the windowed messages. Since the backfill migration
@@ -1477,20 +1357,20 @@ export class RunAIAgentResolver extends ResolverBase {
                 const artifactType = ArtifactMetadataEngine.Instance.GetArtifactTypeByMimeType(artifactMime, ext);
 
                 const decision = RouteArtifact({
-                    typeDefault: artifactType?.DefaultDeliveryMode ?? 'ToolsOnly',
-                    forceToolsOnly: artifactVersion.ForceToolsOnly,
+                    TypeDefault: artifactType?.DefaultDeliveryMode ?? 'ToolsOnly',
+                    ForceToolsOnly: artifactVersion.ForceToolsOnly,
                     mimeType: artifactMime,
-                    sizeBytes: artifactVersion.ContentSizeBytes ?? 0,
-                    inlineSizeCap: INLINE_SIZE_CAP,
-                    modelSupportsModality: () => true,
-                    modelName: '<resolver>',
-                    artifactTypeName: artifactType?.Name ?? artifactMime,
+                    SizeBytes: artifactVersion.ContentSizeBytes ?? 0,
+                    InlineSizeCap: INLINE_SIZE_CAP,
+                    ModelSupportsModality: () => true,
+                    ModelName: '<resolver>',
+                    ArtifactTypeName: artifactType?.Name ?? artifactMime,
                 });
 
                 if (artifactVersion.ContentMode === 'File' && artifactVersion.FileID) {
                     if (decision.delivery !== 'inline') {
-                        if (decision.delivery === 'tools' && decision.annotation) {
-                            LogStatus(`[RunAIAgentResolver] ${decision.annotation}`);
+                        if (decision.delivery === 'tools' && decision.Annotation) {
+                            LogStatus(`[RunAIAgentResolver] ${decision.Annotation}`);
                         }
                         continue;
                     }
@@ -1508,8 +1388,8 @@ export class RunAIAgentResolver extends ResolverBase {
                     // Text-mode artifact (ContentMode = 'Text'). Honor the
                     // routing decision the same way as for file-mode.
                     if (decision.delivery !== 'inline') {
-                        if (decision.delivery === 'tools' && decision.annotation) {
-                            LogStatus(`[RunAIAgentResolver] ${decision.annotation}`);
+                        if (decision.delivery === 'tools' && decision.Annotation) {
+                            LogStatus(`[RunAIAgentResolver] ${decision.Annotation}`);
                         }
                         continue;
                     }
@@ -1648,6 +1528,21 @@ export class RunAIAgentResolver extends ResolverBase {
 
 }
 
+/**
+ * Reads the `agentHistoryFrom` argument of `RunAIAgentFromConversationDetail`: an ISO-8601
+ * timestamp. Absent means no floor. A value that is present but not a timestamp throws — a
+ * floor the caller asked for must fail the request, never be dropped, since dropping it lets
+ * the run read the history it was meant to keep out.
+ */
+function parseAgentHistoryFrom(raw?: string | null): Date | undefined {
+    if (raw == null) return undefined;
+    const parsed = new Date(raw);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new Error(`agentHistoryFrom must be an ISO-8601 timestamp; received "${raw}"`);
+    }
+    return parsed;
+}
+
 function parseTaskGraphDebug(raw?: string): { paused?: boolean } | undefined {
     if (!raw) return undefined;
     const parsed: unknown = SafeJSONParse(raw);