@memberjunction/server 5.51.0 → 6.1.0-edge.1

package/src/resolvers/TaskGraphFrameResolver.ts

@@ -0,0 +1,160 @@
+/**
+ * @fileoverview Live signal for durable task graphs — the dispatcher's lifecycle frames, published
+ * to anyone watching a given graph.
+ *
+ * **Why frames rather than cache invalidation.** The alternative considered was emitting
+ * invalidation events after each CAS claim so clients re-read Task rows. That works, but it makes
+ * every consumer reconstruct meaning by diffing rows, and couples the UI to claim mechanics. A
+ * frame says what happened — "this step failed, here is why" — so a viewer renders progress
+ * directly. This is §3.4's originally-promised mechanism.
+ *
+ * **Addressed by `ParentTaskID`, deliberately not by session.** A durable graph outlives the tab
+ * that submitted it, and may be started by a schedule with no session at all. Keying on the graph
+ * means "watch this workflow run" works for whoever is permitted to see it, whenever they arrive —
+ * including after a page refresh, which a session-keyed push cannot survive.
+ *
+ * @module @memberjunction/server
+ */
+import { Arg, Field, ID, ObjectType, PubSubEngine, Resolver, ResolverFilterData, Root, Subscription } from 'type-graphql';
+import { LogError } from '@memberjunction/core';
+import { UUIDsEqual } from '@memberjunction/global';
+import type { TaskGraphFrame, TaskGraphObserver } from '@memberjunction/task-graph';
+
+export const TASK_GRAPH_FRAMES_TOPIC = 'TASK_GRAPH_FRAMES';
+
+/** One lifecycle event, as it reaches a subscriber. */
+@ObjectType()
+export class TaskGraphFrameNotification {
+  @Field(() => String)
+  kind!: string;
+
+  @Field(() => ID)
+  parentTaskId!: string;
+
+  @Field(() => ID, { nullable: true })
+  taskId?: string;
+
+  @Field(() => String, { nullable: true })
+  taskName?: string;
+
+  @Field(() => String, { nullable: true })
+  status?: string;
+
+  @Field(() => String, { nullable: true })
+  errorMessage?: string;
+
+  @Field(() => ID, { nullable: true })
+  assignedUserId?: string;
+
+  @Field(() => Number, { nullable: true })
+  completedCount?: number;
+
+  @Field(() => Number, { nullable: true })
+  totalCount?: number;
+
+  @Field(() => Date)
+  date!: Date;
+}
+
+/**
+ * Wire payload. Identical to {@link TaskGraphFrame} plus the graph's owner, which exists ONLY as the
+ * server-side filter key and is never returned to a subscriber — the same discipline
+ * `PushStatusNotificationPayload` uses for `ownerUserId`.
+ */
+export interface TaskGraphFramePayload extends TaskGraphFrame {
+  /** User the graph belongs to. Filter key; never sent to the client. */
+  ownerUserId: string;
+}
+
+interface TaskGraphFrameArgs {
+  parentTaskId: string;
+}
+
+/** Minimal shape of the subscription's connection context needed by the filter. */
+export interface TaskGraphFrameFilterContext {
+  userPayload?: { userRecord?: { ID?: string } };
+}
+
+/**
+ * Delivery predicate. A frame reaches a subscriber only when BOTH hold:
+ *   1. it belongs to the graph the subscriber asked to watch, AND
+ *   2. the graph's owner matches the subscriber CONNECTION's authenticated identity.
+ *
+ * Condition 2 is load-bearing, and for the same reason `statusUpdatesFilter` needs it: a
+ * `parentTaskId` is discoverable, so without an identity check anyone holding one could watch
+ * another user's workflow — including its per-step error messages. **Fails closed** — a missing
+ * identity on either side never matches.
+ */
+export function taskGraphFrameFilter(data: {
+  payload: TaskGraphFramePayload;
+  args: TaskGraphFrameArgs;
+  context: TaskGraphFrameFilterContext | undefined;
+}): boolean {
+  const { payload, args, context } = data;
+  if (!payload.ParentTaskID || !args.parentTaskId) {
+    return false;
+  }
+  if (!UUIDsEqual(payload.ParentTaskID, args.parentTaskId)) {
+    return false;
+  }
+  const connectionUserId = context?.userPayload?.userRecord?.ID;
+  if (!connectionUserId || !payload.ownerUserId) {
+    return false; // fail closed
+  }
+  return UUIDsEqual(payload.ownerUserId, connectionUserId);
+}
+
+/**
+ * MJServer's `TaskGraphObserver` — turns dispatcher frames into a PubSub publish.
+ *
+ * `OnFrame` is synchronous and swallows everything by contract: a frame is commentary on work, never
+ * a step of it, so nothing here may stall or fail a graph. The publish itself is fire-and-forget for
+ * the same reason.
+ */
+export class TaskGraphFrameBroadcaster implements TaskGraphObserver {
+  constructor(private readonly pubSub: PubSubEngine) {}
+
+  public OnFrame(frame: TaskGraphFrame): void {
+    try {
+      if (!frame.OwnerUserID) {
+        // A graph with no recorded owner cannot be authorized to anyone, so publishing would only
+        // produce frames the filter refuses. Dropping is the same outcome, without the traffic.
+        // Reachable for graphs submitted before ownership was recorded on the parent.
+        return;
+      }
+      void this.pubSub.publish(
+        TASK_GRAPH_FRAMES_TOPIC,
+        { ...frame, ownerUserId: frame.OwnerUserID } satisfies TaskGraphFramePayload,
+      );
+    } catch (e) {
+      LogError(`[TaskGraphFrameBroadcaster] Could not publish ${frame.Kind} (ignored): ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+}
+
+@Resolver()
+export class TaskGraphFrameResolver {
+  @Subscription(() => TaskGraphFrameNotification, {
+    topics: TASK_GRAPH_FRAMES_TOPIC,
+    filter: (data: ResolverFilterData<TaskGraphFramePayload, TaskGraphFrameArgs, TaskGraphFrameFilterContext>) =>
+      taskGraphFrameFilter(data),
+  })
+  taskGraphFrames(
+    @Root() payload: TaskGraphFramePayload,
+    @Arg('parentTaskId', () => ID) parentTaskId: string
+  ): TaskGraphFrameNotification {
+    // ownerUserId is intentionally NOT returned — it is a server-side filter key only.
+    return {
+      kind: payload.Kind,
+      parentTaskId,
+      taskId: payload.TaskID,
+      taskName: payload.TaskName,
+      status: payload.Status,
+      errorMessage: payload.ErrorMessage,
+      assignedUserId: payload.AssignedUserID,
+      completedCount: payload.CompletedCount,
+      totalCount: payload.TotalCount,
+      date: new Date(),
+    };
+  }
+}

package/src/resolvers/VersionHistoryResolver.ts

@@ -1,11 +1,10 @@
 import { Resolver, Mutation, Arg, Ctx, ObjectType, Field, Int, InputType, PubSub, PubSubEngine } from 'type-graphql';
-import { AppContext } from '../types.js';
+import { AppContext, UserPayload } from '../types.js';
 import { LogError, LogStatus, CompositeKey, KeyValuePair } from '@memberjunction/core';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { VersionHistoryEngine } from '@memberjunction/version-history';
 import { CreateLabelParams, CreateLabelProgressUpdate, VersionLabelScope } from '@memberjunction/version-history';
 import { KeyValuePairInput } from '../generic/KeyValuePairInput.js';
-import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
 
 // =========================================================================
 // GraphQL types
@@ -115,7 +114,7 @@ export class VersionHistoryResolver extends ResolverBase {
 
             // Build progress callback that publishes to PubSub
             const resolvedSessionId = sessionId ?? context.userPayload.sessionId;
-            const onProgress = this.buildProgressCallback(pubSub, resolvedSessionId);
+            const onProgress = this.buildProgressCallback(pubSub, resolvedSessionId, context.userPayload);
 
             const params: CreateLabelParams = {
                 Name: input.Name,
@@ -160,18 +159,16 @@ export class VersionHistoryResolver extends ResolverBase {
      */
     private buildProgressCallback(
         pubSub: PubSubEngine,
-        sessionId: string
+        sessionId: string,
+        userPayload: UserPayload
     ): (progress: CreateLabelProgressUpdate) => void {
         return (progress: CreateLabelProgressUpdate) => {
-            pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
-                message: JSON.stringify({
-                    resolver: 'VersionHistoryResolver',
-                    type: 'CreateLabelProgress',
-                    status: 'ok',
-                    data: progress,
-                }),
-                sessionId,
-            });
+            this.PublishStatusUpdate(pubSub, sessionId, JSON.stringify({
+                resolver: 'VersionHistoryResolver',
+                type: 'CreateLabelProgress',
+                status: 'ok',
+                data: progress,
+            }), userPayload);
         };
     }
 }

package/src/rest/RESTEndpointHandler.ts

@@ -189,8 +189,7 @@ export class RESTEndpointHandler {
         // Transaction operations
         this.router.post('/transactions', this.executeTransaction.bind(this));
         
-        // Reports and queries
-        this.router.get('/reports/:reportId', this.runReport.bind(this));
+        // Queries
         this.router.post('/queries/run', this.runQuery.bind(this));
         
         // Error handling
@@ -781,19 +780,6 @@ export class RESTEndpointHandler {
         }
     }
 
-    /**
-     * Run a report
-     */
-    private async runReport(req: express.Request, res: express.Response): Promise<void> {
-        try {
-            // Placeholder implementation - this would need to be implemented to run reports
-            res.status(501).json({ error: 'Not implemented' });
-        } catch (error) {
-            LogError(error);
-            res.status(500).json({ error: (error as Error)?.message || 'Unknown error' });
-        }
-    }
-
     /**
      * Run a query
      */

package/src/services/StartTaskGraphDispatcher.ts

@@ -0,0 +1,61 @@
+/**
+ * @fileoverview Boots the durable task-graph dispatcher inside MJServer.
+ *
+ * Phase 2 landed the dispatcher and the submission path but never started anything, so a submitted
+ * graph persisted correctly and then sat in `Pending` forever. Submission being durable is only
+ * half the promise — something has to *pick the work up*.
+ *
+ * The continuation deliverer is supplied here for the same reason the agent runner is: posting into
+ * a conversation is a host concern the package deliberately refuses to know about.
+ *
+ * Registration of the package's Remote Operations is a separate concern handled by the generated
+ * class-registration manifests (`ServerBootstrap` / `ServerBootstrapLite`), which import the
+ * subclasses so their `@RegisterClass` decorators run. `LoadTaskGraphOperations` is called here
+ * anyway as a cheap guard: a host that starts a dispatcher but never loaded a manifest would accept
+ * submissions that route to the CodeGen contract-only base and silently do nothing.
+ *
+ * @module @memberjunction/server
+ */
+import { UserInfo } from '@memberjunction/core';
+import { LoadTaskGraphOperations, TaskGraphDispatcher } from '@memberjunction/task-graph';
+import sql from 'mssql';
+import { CreateTaskGraphProviderFactory } from './TaskGraphProviderFactory.js';
+import { TaskGraphAgentRunner } from './TaskGraphAgentRunner.js';
+import { TaskGraphContinuationDeliverer } from './TaskGraphContinuationDeliverer.js';
+import { PubSubManager } from '../generic/PubSubManager.js';
+import { TaskGraphFrameBroadcaster } from '../resolvers/TaskGraphFrameResolver.js';
+
+/**
+ * Starts one dispatcher for this process and returns it.
+ *
+ * The instance ID must be stable for the process lifetime and distinct per instance — it is what
+ * lets reconciliation tell "my own orphaned work, reclaim it" from "another live instance's work,
+ * leave it alone". `pid` plus hostname satisfies both: stable while the process lives, and never
+ * reused by a peer.
+ *
+ * The dispatcher self-registers with `ShutdownRegistry`, so the caller does not wire teardown.
+ */
+export async function StartTaskGraphDispatcher(
+    pool: sql.ConnectionPool,
+    contextUser: UserInfo,
+    instanceID?: string,
+): Promise<TaskGraphDispatcher> {
+    LoadTaskGraphOperations();
+
+    const providerFactory = CreateTaskGraphProviderFactory(pool);
+    const pubSub = PubSubManager.Instance.PubSubEngine;
+    const dispatcher = new TaskGraphDispatcher(
+        providerFactory,
+        new TaskGraphAgentRunner(),
+        contextUser,
+        { InstanceID: instanceID ?? `${process.env.HOSTNAME ?? 'mjapi'}-${process.pid}` },
+        // Without this the dispatcher had nowhere to deliver: a finished graph logged its outcome,
+        // marked itself delivered, and said nothing to the conversation that asked for it.
+        new TaskGraphContinuationDeliverer(providerFactory, contextUser),
+        // Live signal. Supplied only when a PubSub engine exists — in a worker or a test there is
+        // nobody to publish to, and the dispatcher runs identically without one.
+        pubSub ? new TaskGraphFrameBroadcaster(pubSub) : undefined,
+    );
+    await dispatcher.Start();
+    return dispatcher;
+}

package/src/services/TaskGraphAgentRunner.ts

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview MJServer's implementation of the task-graph `TaskAgentRunner` seam.
+ *
+ * The dispatcher knows *when* a task should run and *what* it depends on, but nothing about how an
+ * agent executes. That is injected, so the package stays testable without standing up the agent
+ * framework and so a host with a different execution strategy (a queue, a remote worker) can
+ * substitute its own.
+ *
+ * This adapter is the thin translation between the two: it turns a task's input payload and its
+ * dependencies' outputs into agent messages, runs the agent, and maps the result back into the
+ * shape the dispatcher persists.
+ *
+ * @module @memberjunction/server
+ */
+import { AgentRunner } from '@memberjunction/ai-agents';
+import { ChatMessageRole } from '@memberjunction/ai';
+import { LogError } from '@memberjunction/core';
+import { MJAIAgentEntityExtended } from '@memberjunction/ai-core-plus';
+import type { TaskAgentRunner, TaskAgentRunParams, TaskAgentRunResult } from '@memberjunction/task-graph';
+
+export class TaskGraphAgentRunner implements TaskAgentRunner {
+    public async RunAgentForTask(params: TaskAgentRunParams): Promise<TaskAgentRunResult> {
+        try {
+            const agent = await params.Provider.GetEntityObject<MJAIAgentEntityExtended>('MJ: AI Agents', params.ContextUser);
+            if (!(await agent.Load(params.AgentID))) {
+                return { Success: false, ErrorMessage: `Agent ${params.AgentID} could not be loaded.` };
+            }
+
+            const result = await new AgentRunner().RunAgent({
+                agent,
+                conversationMessages: [{ role: ChatMessageRole.user, content: this.buildPrompt(params) }],
+                contextUser: params.ContextUser,
+            });
+
+            const success = result?.success === true;
+            return {
+                Success: success,
+                Output: this.extractOutput(result),
+                ErrorMessage: success ? undefined : (result?.agentRun?.ErrorMessage ?? 'Agent execution failed'),
+                AgentRunID: result?.agentRun?.ID,
+            };
+        } catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            LogError(`[TaskGraphAgentRunner] Task ${params.TaskID} failed: ${message}`);
+            return { Success: false, ErrorMessage: message };
+        }
+    }
+
+    /**
+     * Builds the agent's instruction from the task's own input plus its dependencies' outputs.
+     *
+     * Dependency outputs are included inline because a task's whole reason for depending on another
+     * is to consume what it produced. They are rendered as labelled JSON rather than prose so the
+     * agent can parse them reliably rather than inferring structure from formatting.
+     */
+    private buildPrompt(params: TaskAgentRunParams): string {
+        const sections: string[] = [];
+
+        if (params.InputPayload != null) {
+            sections.push(`## Task input\n\`\`\`json\n${JSON.stringify(params.InputPayload, null, 2)}\n\`\`\``);
+        }
+
+        if (params.DependencyOutputs.size > 0) {
+            const rendered = [...params.DependencyOutputs.entries()]
+                .map(([taskID, output]) => `### Output of task ${taskID}\n\`\`\`json\n${JSON.stringify(output, null, 2)}\n\`\`\``)
+                .join('\n\n');
+            sections.push(`## Results from prerequisite tasks\n\n${rendered}`);
+        }
+
+        return sections.length > 0
+            ? sections.join('\n\n')
+            : 'Execute this task.';
+    }
+
+    /** Prefers a structured payload over prose, so downstream tasks get data rather than text. */
+    private extractOutput(result: unknown): unknown {
+        const r = result as { payload?: unknown; agentRun?: { Message?: string } } | null;
+        if (r?.payload != null) return r.payload;
+        return r?.agentRun?.Message ?? null;
+    }
+}

package/src/services/TaskGraphContinuationDeliverer.ts

@@ -0,0 +1,181 @@
+/**
+ * @fileoverview MJServer's implementation of the task-graph `TaskContinuationDeliverer` seam.
+ *
+ * **The dispatcher shipped with nowhere to deliver.** `StartTaskGraphDispatcher` constructed it
+ * without a deliverer at all, so a graph that finished logged its outcome, marked itself delivered,
+ * and said nothing to the conversation that asked for it. Durable execution nobody hears about is
+ * half a promise — the same shape as Phase 2's dispatcher that ran nothing.
+ *
+ * Posting into a conversation is a host concern by design: the task-graph package must not depend on
+ * the conversation layer, and cannot depend on the agent framework at all without a cycle (agents
+ * submit graphs). This adapter is where those dependencies are allowed to live.
+ *
+ * @module @memberjunction/server
+ */
+import { LogError, LogStatus, type IMetadataProvider, type UserInfo } from '@memberjunction/core';
+import { MJAIAgentRunEntity, MJConversationDetailEntity } from '@memberjunction/core-entities';
+import { MJAIAgentEntityExtended } from '@memberjunction/ai-core-plus';
+import { AgentRunner } from '@memberjunction/ai-agents';
+import { ChatMessageRole } from '@memberjunction/ai';
+import type { ProviderFactory, TaskContinuationDeliverer, TaskContinuationParams } from '@memberjunction/task-graph';
+
+/** How many per-task lines a posted summary shows before collapsing the rest into a count. */
+const MAX_LISTED_TASKS = 20;
+
+/**
+ * Delivers a finished graph's outcome — as a conversation message, or by starting the submitting
+ * agent a fresh turn.
+ *
+ * **The chain is bounded, and that is what took a schema change to make true.** A graph may declare
+ * `continuation: 'reinvoke'`, and the agent it restarts can emit another graph, which can reinvoke
+ * again. The guard for that (`MAX_REINVOKE_DEPTH`) shipped in Phase 3, but the number it compared
+ * was permanently zero: `TaskGraphService.Submit` reads `ReinvokeDepth` from its caller, and a
+ * reinvoked agent had no way to know it *was* a continuation. `AIAgentRun.ContinuationDepth` closes
+ * that loop — this stamps depth + 1 on the run it starts, `BaseAgent` passes it into any graph that
+ * run submits, and the cap finally compares against something real.
+ */
+export class TaskGraphContinuationDeliverer implements TaskContinuationDeliverer {
+    /**
+     * @param providerFactory mints a fresh provider per delivery, for the same reason the dispatcher
+     *        does: deliveries run outside any request and concurrently with task execution, so
+     *        sharing one provider would share one transaction scope across unrelated work.
+     */
+    constructor(
+        private readonly providerFactory: ProviderFactory,
+        private readonly contextUser: UserInfo,
+    ) {}
+
+    /**
+     * Posts the roll-up as an AI-role message in the graph's conversation.
+     *
+     * Never throws. The dispatcher calls this inside the compare-and-swap that marks a completion
+     * delivered; an error escaping would either abort that guard or leave the graph looking
+     * undelivered and re-notifying on every later sweep.
+     */
+    public async PostMessage(params: TaskContinuationParams): Promise<void> {
+        try {
+            if (!params.ConversationDetailID) {
+                // A graph submitted headlessly — a schedule, an entity-change trigger, an API call —
+                // has no conversation to answer. Not an error; most workflows are in this shape.
+                LogStatus(`[TaskGraphContinuationDeliverer] "${params.WorkflowName}" finished with no conversation to post to.`);
+                return;
+            }
+
+            const provider = await this.providerFactory.CreateProvider();
+            const conversationID = await this.resolveConversationID(params.ConversationDetailID, provider);
+            if (!conversationID) {
+                LogError(
+                    `[TaskGraphContinuationDeliverer] Conversation detail ${params.ConversationDetailID} could not be loaded — ` +
+                    `"${params.WorkflowName}" has nowhere to post its outcome.`
+                );
+                return;
+            }
+
+            const detail = await provider.GetEntityObject<MJConversationDetailEntity>('MJ: Conversation Details', this.contextUser);
+            detail.NewRecord();
+            detail.ConversationID = conversationID;
+            detail.Role = 'AI';
+            detail.Status = 'Complete';
+            detail.HiddenToUser = false;
+            detail.Message = this.renderMessage(params);
+
+            if (!(await detail.Save())) {
+                LogError(
+                    `[TaskGraphContinuationDeliverer] Could not post the outcome of "${params.WorkflowName}": ` +
+                    `${detail.LatestResult?.CompleteMessage ?? 'unknown error'}`
+                );
+            }
+        } catch (e) {
+            LogError(`[TaskGraphContinuationDeliverer] Posting the outcome of "${params.WorkflowName}" threw`, undefined, e);
+        }
+    }
+
+    /**
+     * Starts the submitting agent a fresh turn carrying the graph's outcome.
+     *
+     * Never throws, for the same reason `PostMessage` does not: the dispatcher calls this inside the
+     * compare-and-swap that marks a completion delivered.
+     *
+     * The new run records `ReinvokeDepth + 1` so the chain is bounded. The dispatcher has already
+     * refused to call this when the cap is reached — it degrades to `PostMessage` — so arriving here
+     * means there is budget left, and stamping the depth is what keeps that true for the next hop.
+     */
+    public async Reinvoke(params: TaskContinuationParams): Promise<void> {
+        try {
+            if (!params.SubmittedByAgentRunID) {
+                // Nothing to restart. A graph with no submitting run came from a schedule or a
+                // trigger, where "continue the conversation" has no meaning.
+                LogStatus(`[TaskGraphContinuationDeliverer] "${params.WorkflowName}" asked to reinvoke but records no submitting agent run — posting instead.`);
+                await this.PostMessage(params);
+                return;
+            }
+
+            const provider = await this.providerFactory.CreateProvider();
+            const priorRun = await provider.GetEntityObject<MJAIAgentRunEntity>('MJ: AI Agent Runs', this.contextUser);
+            if (!(await priorRun.Load(params.SubmittedByAgentRunID))) {
+                LogError(`[TaskGraphContinuationDeliverer] Submitting run ${params.SubmittedByAgentRunID} could not be loaded — posting "${params.WorkflowName}" instead.`);
+                await this.PostMessage(params);
+                return;
+            }
+
+            const agent = await provider.GetEntityObject<MJAIAgentEntityExtended>('MJ: AI Agents', this.contextUser);
+            if (!(await agent.Load(priorRun.AgentID))) {
+                LogError(`[TaskGraphContinuationDeliverer] Agent ${priorRun.AgentID} could not be loaded — posting "${params.WorkflowName}" instead.`);
+                await this.PostMessage(params);
+                return;
+            }
+
+            await new AgentRunner().RunAgent({
+                agent,
+                conversationMessages: [{ role: ChatMessageRole.user, content: this.renderMessage(params) }],
+                contextUser: this.contextUser,
+                conversationDetailId: params.ConversationDetailID ?? undefined,
+                // The load-bearing value: without it the next graph this run submits restarts the
+                // chain at zero and the cap never fires.
+                continuationDepth: params.ReinvokeDepth + 1,
+            });
+        } catch (e) {
+            LogError(`[TaskGraphContinuationDeliverer] Reinvoking for "${params.WorkflowName}" threw`, undefined, e);
+        }
+    }
+
+    /** The conversation a detail belongs to. */
+    private async resolveConversationID(conversationDetailID: string, provider: IMetadataProvider): Promise<string | null> {
+        const detail = await provider.GetEntityObject<MJConversationDetailEntity>('MJ: Conversation Details', this.contextUser);
+        return (await detail.Load(conversationDetailID)) ? detail.ConversationID : null;
+    }
+
+    /**
+     * Renders the outcome as Markdown.
+     *
+     * Per-task lines rather than one aggregate status: a graph where nine of ten steps succeeded is a
+     * materially different message from one that failed outright, and the roll-up alone cannot say
+     * which step went wrong. Long graphs truncate so a fifty-step workflow does not bury the
+     * conversation — the task rows remain the complete record.
+     */
+    private renderMessage(params: TaskContinuationParams): string {
+        const lines = [`**${params.WorkflowName}** finished.`, '', params.Summary];
+
+        if (params.Tasks.length > 0) {
+            lines.push('');
+            for (const task of params.Tasks.slice(0, MAX_LISTED_TASKS)) {
+                const detail = task.ErrorMessage ?? task.Summary;
+                lines.push(`- ${this.statusIcon(task.Status)} **${task.Name}** — ${task.Status}${detail ? `: ${detail}` : ''}`);
+            }
+            if (params.Tasks.length > MAX_LISTED_TASKS) {
+                lines.push(`- …and ${params.Tasks.length - MAX_LISTED_TASKS} more`);
+            }
+        }
+
+        return lines.join('\n');
+    }
+
+    private statusIcon(status: string): string {
+        switch (status) {
+            case 'Complete': return '✅';
+            case 'Failed': return '❌';
+            case 'Cancelled': return '⊘';
+            default: return '•';
+        }
+    }
+}

package/src/services/TaskGraphProviderFactory.ts

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview MJServer's implementation of the task-graph `ProviderFactory` seam.
+ *
+ * The durable dispatcher runs outside any HTTP request and executes tasks concurrently, so it must
+ * never share one provider — and therefore one transaction scope and one set of entity instances —
+ * across parallel work. It needs a way to mint providers on demand.
+ *
+ * Rather than have `@memberjunction/task-graph` import MJServer to get at that machinery (which
+ * would invert the dependency: MJServer depends on task-graph, not the reverse), the package
+ * declares a `ProviderFactory` interface and the host supplies an implementation. This is that
+ * implementation.
+ *
+ * It mints exactly what the per-request path already mints — a fresh provider over the **shared
+ * connection pool**, with metadata reuse — which is proven cheap at request scale and is why the
+ * plan chose this mechanism rather than inventing a dispatcher-specific one. The pool remains the
+ * real concurrency governor; the dispatcher's own `MaxConcurrentTasks` sits below it.
+ *
+ * @module @memberjunction/server
+ */
+import { DatabaseProviderBase, IMetadataProvider } from '@memberjunction/core';
+import type { ProviderFactory } from '@memberjunction/task-graph';
+import { SQLServerDataProvider, SQLServerProviderConfigData } from '@memberjunction/sqlserver-dataprovider';
+import sql from 'mssql';
+import { mj_core_schema } from '../config.js';
+
+/**
+ * Creates providers for the dispatcher, one per task execution.
+ *
+ * SQL Server path only for now, matching where the dispatcher is hosted. The PostgreSQL branch of
+ * `createPerRequestProviders` is deliberately not duplicated here — when PG hosting is needed, the
+ * right move is to lift the shared branch out of `context.ts` rather than fork it a second time.
+ */
+export class TaskGraphProviderFactory implements ProviderFactory {
+    constructor(private readonly pool: sql.ConnectionPool) {}
+
+    public async CreateProvider(): Promise<IMetadataProvider> {
+        // `loadIfNeeded = false` (the trailing false) reuses already-loaded metadata rather than
+        // re-reading it per provider — the difference between "cheap enough to do per task" and
+        // "prohibitively expensive".
+        const config = new SQLServerProviderConfigData(this.pool, mj_core_schema, 0, undefined, undefined, false);
+        const provider = new SQLServerDataProvider();
+        await provider.Config(config);
+        return provider as unknown as IMetadataProvider;
+    }
+}
+
+/** Convenience for hosts that already hold a pool. */
+export function CreateTaskGraphProviderFactory(pool: sql.ConnectionPool): ProviderFactory {
+    return new TaskGraphProviderFactory(pool);
+}
+
+/** Re-exported for hosts that need the concrete type. */
+export type { DatabaseProviderBase };

package/dist/resolvers/ReportResolver.d.ts

@@ -1,24 +0,0 @@
-import { AppContext } from '../types.js';
-import { ResolverBase } from '../generic/ResolverBase.js';
-export declare class RunReportResultType {
-    ReportID: string;
-    Success: boolean;
-    Results: string;
-    RowCount: number;
-    ExecutionTime: number;
-    ErrorMessage: string;
-}
-export declare class CreateReportResultType {
-    ReportID: string;
-    ReportName: string;
-    Success: boolean;
-    ErrorMessage: string;
-}
-export declare class ReportResolverExtended extends ResolverBase {
-    GetReportData(ReportID: string, context: AppContext): Promise<RunReportResultType>;
-    /**
-     * This mutation will create a new report from a conversation detail ID
-     */
-    CreateReportFromConversationDetailID(ConversationDetailID: string, { dataSource, userPayload, providers }: AppContext): Promise<CreateReportResultType>;
-}
-//# sourceMappingURL=ReportResolver.d.ts.map

package/dist/resolvers/ReportResolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ReportResolver.d.ts","sourceRoot":"","sources":["../../src/resolvers/ReportResolver.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAOzC,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE1D,qBACa,mBAAmB;IAE9B,QAAQ,EAAE,MAAM,CAAC;IAGjB,OAAO,EAAE,OAAO,CAAC;IAGjB,OAAO,EAAE,MAAM,CAAC;IAGhB,QAAQ,EAAE,MAAM,CAAC;IAGjB,aAAa,EAAE,MAAM,CAAC;IAGtB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,qBACa,sBAAsB;IAEjC,QAAQ,EAAE,MAAM,CAAC;IAGjB,UAAU,EAAE,MAAM,CAAC;IAGnB,OAAO,EAAE,OAAO,CAAC;IAGjB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,qBACa,sBAAuB,SAAQ,YAAY;IAEhD,aAAa,CAAgC,QAAQ,EAAE,MAAM,EAAS,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAkB9H;;OAEG;IAEG,oCAAoC,CACG,oBAAoB,EAAE,MAAM,EAChE,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE,UAAU,GACxD,OAAO,CAAC,sBAAsB,CAAC;CAiFnC"}