@memberjunction/server 2.109.0 → 2.110.1

package/src/resolvers/RunAIAgentResolver.ts

@@ -1,7 +1,7 @@
 import { Resolver, Mutation, Query, Arg, Ctx, ObjectType, Field, PubSub, PubSubEngine, Subscription, Root, ResolverFilterData, ID } from 'type-graphql';
 import { AppContext, UserPayload } from '../types.js';
-import { DatabaseProviderBase, LogError, LogStatus } from '@memberjunction/core';
-import { AIAgentEntityExtended } from '@memberjunction/core-entities';
+import { DatabaseProviderBase, LogError, LogStatus, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { AIAgentEntityExtended, ArtifactEntity, ArtifactVersionEntity, ConversationDetailArtifactEntity, ConversationDetailEntity, UserNotificationEntity, AIAgentRunEntityExtended } from '@memberjunction/core-entities';
 import { AgentRunner } from '@memberjunction/ai-agents';
 import { ExecuteAgentResult } from '@memberjunction/ai-core-plus';
 import { AIEngine } from '@memberjunction/aiengine';
@@ -314,12 +314,16 @@ export class RunAIAgentResolver extends ResolverBase {
         sessionId: string,
         pubSub: PubSubEngine,
         data?: string,
-        payload?: string,   
+        payload?: string,
         templateData?: string,
         lastRunId?: string,
         autoPopulateLastRunPayload?: boolean,
         configurationId?: string,
-        conversationDetailId?: string
+        conversationDetailId?: string,
+        createArtifacts: boolean = false,
+        createNotification: boolean = false,
+        sourceArtifactId?: string,
+        sourceArtifactVersionId?: string
     ): Promise<AIAgentRunResult> {
         const startTime = Date.now();
         
@@ -380,6 +384,37 @@ export class RunAIAgentResolver extends ResolverBase {
             // Publish final events
             this.publishFinalEvents(pubSub, sessionId, userPayload, result);
 
+            // Process completion for artifacts and notifications (if enabled)
+            if (result.success && conversationDetailId && result.payload) {
+                const currentUser = this.GetUserFromPayload(userPayload);
+
+                if (createArtifacts) {
+                    const artifactInfo = await this.processAgentCompletionForArtifacts(
+                        result.agentRun,
+                        result.payload,
+                        currentUser,
+                        conversationDetailId,
+                        sourceArtifactId
+                    );
+
+                    // Create notification if enabled and artifact was created successfully
+                    if (createNotification && artifactInfo.artifactId && artifactInfo.versionId && artifactInfo.versionNumber) {
+                        await this.createCompletionNotification(
+                            result.agentRun,
+                            {
+                                artifactId: artifactInfo.artifactId,
+                                versionId: artifactInfo.versionId,
+                                versionNumber: artifactInfo.versionNumber
+                            },
+                            conversationDetailId,
+                            currentUser,
+                            pubSub,
+                            userPayload
+                        );
+                    }
+                }
+            }
+
             // Create sanitized payload for JSON serialization
             const sanitizedResult = this.sanitizeAgentResult(result);
             const returnResult = JSON.stringify(sanitizedResult);
@@ -473,7 +508,11 @@ export class RunAIAgentResolver extends ResolverBase {
         @Arg('lastRunId', { nullable: true }) lastRunId?: string,
         @Arg('autoPopulateLastRunPayload', { nullable: true }) autoPopulateLastRunPayload?: boolean,
         @Arg('configurationId', { nullable: true }) configurationId?: string,
-        @Arg('conversationDetailId', { nullable: true }) conversationDetailId?: string
+        @Arg('conversationDetailId', { nullable: true }) conversationDetailId?: string,
+        @Arg('createArtifacts', { nullable: true }) createArtifacts?: boolean,
+        @Arg('createNotification', { nullable: true }) createNotification?: boolean,
+        @Arg('sourceArtifactId', { nullable: true }) sourceArtifactId?: string,
+        @Arg('sourceArtifactVersionId', { nullable: true }) sourceArtifactVersionId?: string
     ): Promise<AIAgentRunResult> {
         const p = GetReadWriteProvider(providers);
         return this.executeAIAgent(
@@ -489,7 +528,11 @@ export class RunAIAgentResolver extends ResolverBase {
             lastRunId,
             autoPopulateLastRunPayload,
             configurationId,
-            conversationDetailId
+            conversationDetailId,
+            createArtifacts || false,
+            createNotification || false,
+            sourceArtifactId,
+            sourceArtifactVersionId
         );
     }
 
@@ -511,7 +554,11 @@ export class RunAIAgentResolver extends ResolverBase {
         @Arg('lastRunId', { nullable: true }) lastRunId?: string,
         @Arg('autoPopulateLastRunPayload', { nullable: true }) autoPopulateLastRunPayload?: boolean,
         @Arg('configurationId', { nullable: true }) configurationId?: string,
-        @Arg('conversationDetailId', { nullable: true }) conversationDetailId?: string
+        @Arg('conversationDetailId', { nullable: true }) conversationDetailId?: string,
+        @Arg('createArtifacts', { nullable: true }) createArtifacts?: boolean,
+        @Arg('createNotification', { nullable: true }) createNotification?: boolean,
+        @Arg('sourceArtifactId', { nullable: true }) sourceArtifactId?: string,
+        @Arg('sourceArtifactVersionId', { nullable: true }) sourceArtifactVersionId?: string
     ): Promise<AIAgentRunResult> {
         const p = GetReadWriteProvider(providers);
         return this.executeAIAgent(
@@ -527,8 +574,349 @@ export class RunAIAgentResolver extends ResolverBase {
             lastRunId,
             autoPopulateLastRunPayload,
             configurationId,
-            conversationDetailId
+            conversationDetailId,
+            createArtifacts || false,
+            createNotification || false,
+            sourceArtifactId,
+            sourceArtifactVersionId
         );
     }
- 
+
+    /**
+     * Get the maximum version number for an artifact
+     * Used when creating new version of an explicitly specified artifact
+     */
+    private async getMaxVersionForArtifact(
+        artifactId: string,
+        contextUser: UserInfo
+    ): Promise<number> {
+        try {
+            const rv = new RunView();
+
+            // Query all versions for this artifact to find max version number
+            const result = await rv.RunView<ArtifactVersionEntity>({
+                EntityName: 'MJ: Artifact Versions',
+                ExtraFilter: `ArtifactID='${artifactId}'`,
+                OrderBy: 'VersionNumber DESC',
+                MaxRows: 1,
+                ResultType: 'entity_object'
+            }, contextUser);
+
+            if (result.Success && result.Results && result.Results.length > 0) {
+                return result.Results[0].VersionNumber || 0;
+            }
+
+            return 0; // No versions found, will create version 1
+        } catch (error) {
+            LogError(`Error getting max version for artifact: ${(error as Error).message}`);
+            return 0;
+        }
+    }
+
+    /**
+     * Find the most recent artifact for a conversation detail to determine versioning
+     * Returns artifact info if exists, null if this is first artifact
+     */
+    private async findPreviousArtifactForMessage(
+        conversationDetailId: string,
+        contextUser: UserInfo
+    ): Promise<{ artifactId: string; versionNumber: number } | null> {
+        try {
+            const rv = new RunView();
+
+            // Query junction table to find artifacts for this message
+            const result = await rv.RunView<ConversationDetailArtifactEntity>({
+                EntityName: 'MJ: Conversation Detail Artifacts',
+                ExtraFilter: `ConversationDetailID='${conversationDetailId}' AND Direction='Output'`,
+                OrderBy: '__mj_CreatedAt DESC',
+                MaxRows: 1,
+                ResultType: 'entity_object'
+            }, contextUser);
+
+            if (!result.Success || !result.Results || result.Results.length === 0) {
+                return null;
+            }
+
+            const junction = result.Results[0];
+
+            // Load the artifact version to get version number and artifact ID
+            const md = new Metadata();
+            const version = await md.GetEntityObject<ArtifactVersionEntity>(
+                'MJ: Artifact Versions',
+                contextUser
+            );
+
+            if (!(await version.Load(junction.ArtifactVersionID))) {
+                return null;
+            }
+
+            return {
+                artifactId: version.ArtifactID,
+                versionNumber: version.VersionNumber
+            };
+        } catch (error) {
+            LogError(`Error finding previous artifact: ${(error as Error).message}`);
+            return null;
+        }
+    }
+
+    /**
+     * Process agent completion to create artifacts from payload
+     * Called after agent run completes successfully
+     */
+    private async processAgentCompletionForArtifacts(
+        agentRun: AIAgentRunEntityExtended,
+        payload: any,
+        contextUser: UserInfo,
+        conversationDetailId?: string,
+        sourceArtifactId?: string
+    ): Promise<{ artifactId?: string; versionId?: string; versionNumber?: number }> {
+        // Validate inputs
+        if (!payload || Object.keys(payload).length === 0) {
+            LogStatus('No payload to create artifact from');
+            return {};
+        }
+
+        if (!conversationDetailId) {
+            LogStatus('Skipping artifact creation - no conversationDetailId provided');
+            return {};
+        }
+
+        // Check agent's ArtifactCreationMode
+        await AIEngine.Instance.Config(false, contextUser);
+        const agent = AIEngine.Instance.Agents.find(a => a.ID === agentRun.AgentID);
+        const creationMode = agent?.ArtifactCreationMode;
+
+        if (creationMode === 'Never') {
+            LogStatus(`Skipping artifact creation - agent "${agent?.Name}" has ArtifactCreationMode='Never'`);
+            return {};
+        }
+
+        try {
+            const md = new Metadata();
+            const JSON_ARTIFACT_TYPE_ID = 'ae674c7e-ea0d-49ea-89e4-0649f5eb20d4';
+
+            // 1. Determine if creating new artifact or new version
+            let artifactId: string;
+            let newVersionNumber: number;
+            let isNewArtifact = false;
+
+            // Priority 1: Use explicit source artifact if provided (agent continuity/refinement)
+            if (sourceArtifactId) {
+                const maxVersion = await this.getMaxVersionForArtifact(sourceArtifactId, contextUser);
+                artifactId = sourceArtifactId;
+                newVersionNumber = maxVersion + 1;
+                LogStatus(`Creating version ${newVersionNumber} of source artifact ${artifactId} (explicit source)`);
+            }
+            // Priority 2: Try to find previous artifact for this message (fallback)
+            else {
+                const previousArtifact = await this.findPreviousArtifactForMessage(
+                    conversationDetailId,
+                    contextUser
+                );
+
+                if (previousArtifact) {
+                    // Create new version of existing artifact
+                    artifactId = previousArtifact.artifactId;
+                    newVersionNumber = previousArtifact.versionNumber + 1;
+                    LogStatus(`Creating version ${newVersionNumber} of existing artifact ${artifactId}`);
+                } else {
+                    // Create new artifact header
+                    const artifact = await md.GetEntityObject<ArtifactEntity>(
+                    'MJ: Artifacts',
+                    contextUser
+                );
+
+                // Get agent info for naming and visibility control
+                await AIEngine.Instance.Config(false, contextUser);
+                const agent = AIEngine.Instance.Agents.find(a => a.ID === agentRun.AgentID);
+                const agentName = agent?.Name || 'Agent';
+
+                artifact.Name = `${agentName} Payload - ${new Date().toLocaleString()}`;
+                artifact.Description = `Payload returned by ${agentName}`;
+
+                // Use agent's DefaultArtifactTypeID if available, otherwise JSON
+                const defaultArtifactTypeId = (agent as any)?.DefaultArtifactTypeID;
+                artifact.TypeID = defaultArtifactTypeId || JSON_ARTIFACT_TYPE_ID;
+
+                artifact.UserID = contextUser.ID;
+                artifact.EnvironmentID = (contextUser as any).EnvironmentID ||
+                                        'F51358F3-9447-4176-B313-BF8025FD8D09';
+
+                // Set visibility based on agent's ArtifactCreationMode
+                // Will compile after CodeGen adds the new fields
+                const creationMode = agent.ArtifactCreationMode;
+                if (creationMode === 'System Only') {
+                    artifact.Visibility = 'System Only';
+                    LogStatus(`Artifact marked as "System Only" per agent configuration`);
+                } else {
+                    artifact.Visibility = 'Always';
+                }
+
+                if (!(await artifact.Save())) {
+                    throw new Error('Failed to save artifact');
+                }
+
+                    artifactId = artifact.ID;
+                    newVersionNumber = 1;
+                    isNewArtifact = true;
+                    LogStatus(`Created new artifact: ${artifact.Name} (${artifactId})`);
+                }
+            }
+
+            // 2. Create artifact version with content
+            const version = await md.GetEntityObject<ArtifactVersionEntity>(
+                'MJ: Artifact Versions',
+                contextUser
+            );
+            version.ArtifactID = artifactId;
+            version.VersionNumber = newVersionNumber;
+            version.Content = JSON.stringify(payload, null, 2);
+            version.UserID = contextUser.ID;
+
+            if (!(await version.Save())) {
+                throw new Error('Failed to save artifact version');
+            }
+
+            LogStatus(`Created artifact version ${newVersionNumber} (${version.ID})`);
+
+            // If this is the first version of a new artifact, check for extracted Name attribute and update artifact
+            if (isNewArtifact && newVersionNumber === 1) {
+                const nameAttr = (version as any).Attributes?.find((attr: any) =>
+                    attr.StandardProperty === 'name' || attr.Name?.toLowerCase() === 'name'
+                );
+
+                // Check for valid name value (not null, not empty, not string "null")
+                let extractedName = nameAttr?.Value?.trim();
+                if (extractedName && extractedName.toLowerCase() !== 'null') {
+                    // Strip surrounding quotes (double or single) from start and end
+                    extractedName = extractedName.replace(/^["']|["']$/g, '');
+
+                    // Load artifact to update with extracted name
+                    const artifact = await md.GetEntityObject<ArtifactEntity>(
+                        'MJ: Artifacts',
+                        contextUser
+                    );
+
+                    if (!(await artifact.Load(artifactId))) {
+                        LogError('Failed to reload artifact for name update');
+                    } else {
+                        artifact.Name = extractedName;
+                        if (await artifact.Save()) {
+                            LogStatus(`✨ Updated artifact name to: ${artifact.Name}`);
+                        }
+                    }
+                }
+            }
+
+            // 3. Create junction record linking artifact to conversation detail
+            const junction = await md.GetEntityObject<ConversationDetailArtifactEntity>(
+                'MJ: Conversation Detail Artifacts',
+                contextUser
+            );
+            junction.ConversationDetailID = conversationDetailId;
+            junction.ArtifactVersionID = version.ID;
+            junction.Direction = 'Output';
+
+            if (!(await junction.Save())) {
+                throw new Error('Failed to create artifact-message association');
+            }
+
+            LogStatus(`Linked artifact to conversation detail ${conversationDetailId}`);
+
+            return {
+                artifactId,
+                versionId: version.ID,
+                versionNumber: newVersionNumber
+            };
+        } catch (error) {
+            LogError(`Failed to process agent completion for artifacts: ${(error as Error).message}`);
+            return {};
+        }
+    }
+
+    /**
+     * Create a user notification for agent completion with artifact
+     * Notification includes navigation link back to the conversation
+     */
+    private async createCompletionNotification(
+        agentRun: AIAgentRunEntityExtended,
+        artifactInfo: { artifactId: string; versionId: string; versionNumber: number },
+        conversationDetailId: string,
+        contextUser: UserInfo,
+        pubSub: PubSubEngine,
+        userPayload: UserPayload
+    ): Promise<void> {
+        try {
+            const md = new Metadata();
+
+            // Get agent info for notification message
+            await AIEngine.Instance.Config(false, contextUser);
+            const agent = AIEngine.Instance.Agents.find(a => a.ID === agentRun.AgentID);
+            const agentName = agent?.Name || 'Agent';
+
+            // Load conversation detail to get conversation info
+            const detail = await md.GetEntityObject<ConversationDetailEntity>(
+                'Conversation Details',
+                contextUser
+            );
+            if (!(await detail.Load(conversationDetailId))) {
+                throw new Error(`Failed to load conversation detail ${conversationDetailId}`);
+            }
+
+            // Create notification entity
+            const notification = await md.GetEntityObject<UserNotificationEntity>(
+                'User Notifications',
+                contextUser
+            );
+
+            notification.UserID = contextUser.ID;
+            notification.Title = `${agentName} completed your request`;
+
+            // Craft message based on versioning
+            if (artifactInfo.versionNumber > 1) {
+                notification.Message = `${agentName} has finished processing and created version ${artifactInfo.versionNumber}`;
+            } else {
+                notification.Message = `${agentName} has finished processing and created a new artifact`;
+            }
+
+            // Store navigation configuration as JSON
+            // Client will parse this to navigate to the conversation with artifact visible
+            notification.ResourceConfiguration = JSON.stringify({
+                type: 'conversation',
+                conversationId: detail.ConversationID,
+                messageId: conversationDetailId,
+                artifactId: artifactInfo.artifactId,
+                versionNumber: artifactInfo.versionNumber
+            });
+
+            notification.Unread = true;  // Default unread
+            // ResourceTypeID and ResourceRecordID left null - using custom navigation
+
+            if (!(await notification.Save())) {
+                throw new Error('Failed to save notification');
+            }
+
+            LogStatus(`📬 Created notification ${notification.ID} for user ${contextUser.ID}`);
+
+            // Publish real-time notification event so client updates immediately
+            pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+                userPayload: JSON.stringify(userPayload),
+                message: JSON.stringify({
+                    type: 'notification',
+                    notificationId: notification.ID,
+                    action: 'create',
+                    title: notification.Title,
+                    message: notification.Message
+                })
+            });
+
+            LogStatus(`📡 Published notification event to client`);
+
+        } catch (error) {
+            LogError(`Failed to create completion notification: ${(error as Error).message}`);
+            // Don't throw - notification failure shouldn't fail the agent run
+        }
+    }
+
 }

package/src/resolvers/TaskResolver.ts

@@ -53,7 +53,8 @@ export class TaskOrchestrationResolver extends ResolverBase {
         @Arg('environmentId') environmentId: string,
         @Arg('sessionId') sessionId: string,
         @PubSub() pubSub: PubSubEngine,
-        @Ctx() { userPayload }: AppContext
+        @Ctx() { userPayload }: AppContext,
+        @Arg('createNotifications', { nullable: true }) createNotifications?: boolean
     ): Promise<ExecuteTaskGraphResult> {
         try {
             LogStatus(`=== EXECUTING TASK GRAPH FOR CONVERSATION: ${conversationDetailId} ===`);
@@ -78,7 +79,7 @@ export class TaskOrchestrationResolver extends ResolverBase {
             }
 
             // Create task orchestrator with PubSub for progress updates
-            const orchestrator = new TaskOrchestrator(currentUser, pubSub, sessionId, userPayload);
+            const orchestrator = new TaskOrchestrator(currentUser, pubSub, sessionId, userPayload, createNotifications || false);
 
             // Create parent task and child tasks with dependencies
             const { parentTaskId, taskIdMap } = await orchestrator.createTasksFromGraph(

package/src/services/TaskOrchestrator.ts

@@ -1,5 +1,5 @@
 import { Metadata, RunView, UserInfo, LogError, LogStatus } from '@memberjunction/core';
-import { TaskEntity, TaskDependencyEntity, TaskTypeEntity, AIAgentEntityExtended, ConversationDetailEntity, ArtifactEntity, ArtifactVersionEntity, ConversationDetailArtifactEntity } from '@memberjunction/core-entities';
+import { TaskEntity, TaskDependencyEntity, TaskTypeEntity, AIAgentEntityExtended, ConversationDetailEntity, ArtifactEntity, ArtifactVersionEntity, ConversationDetailArtifactEntity, UserNotificationEntity } from '@memberjunction/core-entities';
 import { AgentRunner } from '@memberjunction/ai-agents';
 import { ChatMessageRole } from '@memberjunction/ai';
 import { PubSubEngine } from 'type-graphql';
@@ -50,7 +50,8 @@ export class TaskOrchestrator {
         private contextUser: UserInfo,
         private pubSub?: PubSubEngine,
         private sessionId?: string,
-        private userPayload?: UserPayload
+        private userPayload?: UserPayload,
+        private createNotifications: boolean = false
     ) {}
 
     /**
@@ -408,9 +409,14 @@ export class TaskOrchestrator {
         parentTask.Status = 'Complete';
         parentTask.PercentComplete = 100;
         parentTask.CompletedAt = new Date();
-        await parentTask.Save();
+        const saved = await parentTask.Save();
 
         LogStatus(`Parent workflow task completed: ${parentTask.Name}`);
+
+        // If notifications enabled, create user notification
+        if (this.createNotifications && saved) {
+            await this.createTaskGraphCompletionNotification(parentTask);
+        }
     }
 
     /**
@@ -703,6 +709,16 @@ export class TaskOrchestrator {
             artifact.UserID = this.contextUser.ID;
             artifact.EnvironmentID = (this.contextUser as any).EnvironmentID || 'F51358F3-9447-4176-B313-BF8025FD8D09';
 
+            // Set visibility based on agent's ArtifactCreationMode
+            // Will compile after CodeGen adds the new fields
+            const creationMode = agent.ArtifactCreationMode;
+            if (creationMode === 'System Only') {
+                artifact.Visibility = 'System Only';
+                LogStatus(`Task artifact marked as "System Only" per agent configuration`);
+            } else {
+                artifact.Visibility = 'Always';
+            }
+
             const artifactSaved = await artifact.Save();
             if (!artifactSaved) {
                 LogError('Failed to save artifact');
@@ -733,6 +749,23 @@ export class TaskOrchestrator {
 
             LogStatus(`Created artifact version: ${version.ID}`);
 
+            // Check for extracted Name attribute and update artifact with better name
+            const nameAttr = (version as any).Attributes?.find((attr: any) =>
+                attr.StandardProperty === 'name' || attr.Name?.toLowerCase() === 'name'
+            );
+
+            // Check for valid name value (not null, not empty, not string "null")
+            let extractedName = nameAttr?.Value?.trim();
+            if (extractedName && extractedName.toLowerCase() !== 'null') {
+                // Strip surrounding quotes (double or single) from start and end
+                extractedName = extractedName.replace(/^["']|["']$/g, '');
+
+                artifact.Name = extractedName;
+                if (await artifact.Save()) {
+                    LogStatus(`✨ Updated artifact name to: ${artifact.Name}`);
+                }
+            }
+
             // Create M2M relationship linking artifact to conversation detail
             const junction = await md.GetEntityObject<ConversationDetailArtifactEntity>(
                 'MJ: Conversation Detail Artifacts',
@@ -753,4 +786,86 @@ export class TaskOrchestrator {
             LogError(`Error creating artifact from output: ${error}`);
         }
     }
+
+    /**
+     * Create user notification for task graph completion
+     * Notifies user that their multi-step workflow has completed
+     */
+    private async createTaskGraphCompletionNotification(parentTask: TaskEntity): Promise<void> {
+        try {
+            if (!parentTask.ConversationDetailID) {
+                LogStatus('Skipping notification - no conversation detail linked');
+                return;
+            }
+
+            const md = new Metadata();
+
+            // Load conversation detail to get conversation ID
+            const detail = await md.GetEntityObject<ConversationDetailEntity>(
+                'Conversation Details',
+                this.contextUser
+            );
+            if (!(await detail.Load(parentTask.ConversationDetailID))) {
+                throw new Error(`Failed to load conversation detail ${parentTask.ConversationDetailID}`);
+            }
+
+            // Count child tasks and success rate
+            const rv = new RunView();
+            const tasksResult = await rv.RunView<TaskEntity>({
+                EntityName: 'MJ: Tasks',
+                ExtraFilter: `ParentID='${parentTask.ID}'`,
+                ResultType: 'entity_object'
+            }, this.contextUser);
+
+            const childTasks = tasksResult.Success ? (tasksResult.Results || []) : [];
+            const successCount = childTasks.filter(t => t.Status === 'Complete').length;
+            const totalCount = childTasks.length;
+
+            // Create notification
+            const notification = await md.GetEntityObject<UserNotificationEntity>(
+                'User Notifications',
+                this.contextUser
+            );
+
+            notification.UserID = this.contextUser.ID;
+            notification.Title = `Workflow "${parentTask.Name}" completed`;
+            notification.Message = `Your ${totalCount}-step workflow has finished. ${successCount} of ${totalCount} tasks completed successfully.`;
+
+            // Navigation configuration
+            notification.ResourceConfiguration = JSON.stringify({
+                type: 'conversation',
+                conversationId: detail.ConversationID,
+                messageId: parentTask.ConversationDetailID,
+                taskId: parentTask.ID
+            });
+
+            notification.Unread = true;
+
+            if (!(await notification.Save())) {
+                throw new Error('Failed to save notification');
+            }
+
+            LogStatus(`📬 Created task graph notification ${notification.ID} for user ${this.contextUser.ID}`);
+
+            // Publish real-time event if pubSub available
+            if (this.pubSub && this.userPayload) {
+                this.pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+                    userPayload: JSON.stringify(this.userPayload),
+                    message: JSON.stringify({
+                        type: 'notification',
+                        notificationId: notification.ID,
+                        action: 'create',
+                        title: notification.Title,
+                        message: notification.Message
+                    })
+                });
+
+                LogStatus(`📡 Published task graph notification event to client`);
+            }
+
+        } catch (error) {
+            LogError(`Failed to create task graph notification: ${(error as Error).message}`);
+            // Don't throw - notification failure shouldn't fail the task
+        }
+    }
 }