@memberjunction/server 5.51.2 → 5.51.4

package/src/resolvers/RunTestResolver.ts

@@ -15,7 +15,6 @@ import { AppContext, UserPayload } from '../types.js';
 import { LogError, LogStatus, UserInfo } from '@memberjunction/core';
 import { TestEngine } from '@memberjunction/testing-engine';
 import { ResolverBase } from '../generic/ResolverBase.js';
-import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
 import { startLivenessPulse } from '../generic/FireAndForgetHeartbeat.js';
 import { TestRunVariables, TestLogMessage, TestRunResult as EngineTestRunResult } from '@memberjunction/testing-engine-base';
 
@@ -257,7 +256,7 @@ export class RunTestResolver extends ResolverBase {
     ): void {
         // Keep-alive pulse so a long-running test never trips the client idle timeout.
         // The client captures the testRunId from progress events for reconciliation.
-        const pulse = startLivenessPulse({ pubSub, sessionId: userPayload.sessionId, resolver: 'RunTestResolver' });
+        const pulse = startLivenessPulse({ pubSub, sessionId: userPayload.sessionId, ownerUserId: userPayload.userRecord.ID, resolver: 'RunTestResolver' });
 
         this.executeTest(testId, verbose, environment, tags, variables, pubSub, userPayload, user)
             .catch((error: unknown) => {
@@ -353,7 +352,7 @@ export class RunTestResolver extends ResolverBase {
         // (Suite reconciliation isn't wired: suite progress carries the per-test run id, not the
         // Test Suite Run id, so the client has no handle to reconcile against — the pulse is the
         // protection here.)
-        const pulse = startLivenessPulse({ pubSub, sessionId: userPayload.sessionId, resolver: 'RunTestResolver' });
+        const pulse = startLivenessPulse({ pubSub, sessionId: userPayload.sessionId, ownerUserId: userPayload.userRecord.ID, resolver: 'RunTestResolver' });
 
         this.executeSuite(
             suiteId, verbose, environment, parallel, tags, variables,
@@ -494,51 +493,42 @@ export class RunTestResolver extends ResolverBase {
     // ===== PubSub Publishing =====
 
     private publishProgress(pubSub: PubSubEngine, data: TestExecutionStreamMessage, userPayload: UserPayload) {
-        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
-            message: JSON.stringify({
-                resolver: 'RunTestResolver',
-                type: 'TestExecutionProgress',
-                status: 'ok',
-                data,
-            }),
-            sessionId: userPayload.sessionId,
-        });
+        this.PublishStatusUpdate(pubSub, userPayload.sessionId, JSON.stringify({
+            resolver: 'RunTestResolver',
+            type: 'TestExecutionProgress',
+            status: 'ok',
+            data,
+        }), userPayload);
     }
 
     private publishComplete(pubSub: PubSubEngine, userPayload: UserPayload, result: EngineTestRunResult) {
-        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
-            message: JSON.stringify({
-                resolver: 'RunTestResolver',
-                type: 'TestExecutionComplete',
-                status: 'ok',
-                data: {
-                    sessionId: userPayload.sessionId,
-                    testRunId: result.testRunId,
-                    type: 'complete',
-                    result: JSON.stringify(result),
-                    timestamp: new Date()
-                },
-            }),
-            sessionId: userPayload.sessionId,
-        });
+        this.PublishStatusUpdate(pubSub, userPayload.sessionId, JSON.stringify({
+            resolver: 'RunTestResolver',
+            type: 'TestExecutionComplete',
+            status: 'ok',
+            data: {
+                sessionId: userPayload.sessionId,
+                testRunId: result.testRunId,
+                type: 'complete',
+                result: JSON.stringify(result),
+                timestamp: new Date()
+            },
+        }), userPayload);
     }
 
     private publishError(pubSub: PubSubEngine, userPayload: UserPayload, testId: string, errorMsg: string) {
-        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
-            message: JSON.stringify({
-                resolver: 'RunTestResolver',
-                type: 'TestExecutionError',
-                status: 'error',
-                data: {
-                    sessionId: userPayload.sessionId,
-                    testRunId: testId,
-                    type: 'error',
-                    errorMessage: errorMsg,
-                    timestamp: new Date()
-                },
-            }),
-            sessionId: userPayload.sessionId,
-        });
+        this.PublishStatusUpdate(pubSub, userPayload.sessionId, JSON.stringify({
+            resolver: 'RunTestResolver',
+            type: 'TestExecutionError',
+            status: 'error',
+            data: {
+                sessionId: userPayload.sessionId,
+                testRunId: testId,
+                type: 'error',
+                errorMessage: errorMsg,
+                timestamp: new Date()
+            },
+        }), userPayload);
     }
 
     /**
@@ -551,24 +541,21 @@ export class RunTestResolver extends ResolverBase {
         testId: string,
         testRunResult: TestRunResult
     ) {
-        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
-            message: JSON.stringify({
-                resolver: 'RunTestResolver',
-                type: 'FireAndForgetComplete',
-                status: 'ok',
-                data: {
-                    sessionId: userPayload.sessionId,
-                    testId,
-                    type: 'complete',
-                    success: testRunResult.success,
-                    errorMessage: testRunResult.errorMessage,
-                    executionTimeMs: testRunResult.executionTimeMs,
-                    result: testRunResult.result,
-                    timestamp: new Date()
-                },
-            }),
-            sessionId: userPayload.sessionId,
-        });
+        this.PublishStatusUpdate(pubSub, userPayload.sessionId, JSON.stringify({
+            resolver: 'RunTestResolver',
+            type: 'FireAndForgetComplete',
+            status: 'ok',
+            data: {
+                sessionId: userPayload.sessionId,
+                testId,
+                type: 'complete',
+                success: testRunResult.success,
+                errorMessage: testRunResult.errorMessage,
+                executionTimeMs: testRunResult.executionTimeMs,
+                result: testRunResult.result,
+                timestamp: new Date()
+            },
+        }), userPayload);
     }
 
     /**
@@ -580,23 +567,20 @@ export class RunTestResolver extends ResolverBase {
         testId: string,
         errorMessage: string
     ) {
-        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
-            message: JSON.stringify({
-                resolver: 'RunTestResolver',
-                type: 'FireAndForgetComplete',
-                status: 'ok',
-                data: {
-                    sessionId: userPayload.sessionId,
-                    testId,
-                    type: 'complete',
-                    success: false,
-                    errorMessage,
-                    result: JSON.stringify({ success: false, errorMessage }),
-                    timestamp: new Date()
-                },
-            }),
-            sessionId: userPayload.sessionId,
-        });
+        this.PublishStatusUpdate(pubSub, userPayload.sessionId, JSON.stringify({
+            resolver: 'RunTestResolver',
+            type: 'FireAndForgetComplete',
+            status: 'ok',
+            data: {
+                sessionId: userPayload.sessionId,
+                testId,
+                type: 'complete',
+                success: false,
+                errorMessage,
+                result: JSON.stringify({ success: false, errorMessage }),
+                timestamp: new Date()
+            },
+        }), userPayload);
     }
 
     /**
@@ -609,24 +593,21 @@ export class RunTestResolver extends ResolverBase {
         suiteId: string,
         suiteRunResult: TestSuiteRunResult
     ) {
-        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
-            message: JSON.stringify({
-                resolver: 'RunTestResolver',
-                type: 'FireAndForgetSuiteComplete',
-                status: 'ok',
-                data: {
-                    sessionId: userPayload.sessionId,
-                    suiteId,
-                    type: 'complete',
-                    success: suiteRunResult.success,
-                    errorMessage: suiteRunResult.errorMessage,
-                    executionTimeMs: suiteRunResult.executionTimeMs,
-                    result: suiteRunResult.result,
-                    timestamp: new Date()
-                },
-            }),
-            sessionId: userPayload.sessionId,
-        });
+        this.PublishStatusUpdate(pubSub, userPayload.sessionId, JSON.stringify({
+            resolver: 'RunTestResolver',
+            type: 'FireAndForgetSuiteComplete',
+            status: 'ok',
+            data: {
+                sessionId: userPayload.sessionId,
+                suiteId,
+                type: 'complete',
+                success: suiteRunResult.success,
+                errorMessage: suiteRunResult.errorMessage,
+                executionTimeMs: suiteRunResult.executionTimeMs,
+                result: suiteRunResult.result,
+                timestamp: new Date()
+            },
+        }), userPayload);
     }
 
     /**
@@ -638,22 +619,19 @@ export class RunTestResolver extends ResolverBase {
         suiteId: string,
         errorMessage: string
     ) {
-        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
-            message: JSON.stringify({
-                resolver: 'RunTestResolver',
-                type: 'FireAndForgetSuiteComplete',
-                status: 'ok',
-                data: {
-                    sessionId: userPayload.sessionId,
-                    suiteId,
-                    type: 'complete',
-                    success: false,
-                    errorMessage,
-                    result: JSON.stringify({ success: false, errorMessage }),
-                    timestamp: new Date()
-                },
-            }),
-            sessionId: userPayload.sessionId,
-        });
+        this.PublishStatusUpdate(pubSub, userPayload.sessionId, JSON.stringify({
+            resolver: 'RunTestResolver',
+            type: 'FireAndForgetSuiteComplete',
+            status: 'ok',
+            data: {
+                sessionId: userPayload.sessionId,
+                suiteId,
+                type: 'complete',
+                success: false,
+                errorMessage,
+                result: JSON.stringify({ success: false, errorMessage }),
+                timestamp: new Date()
+            },
+        }), userPayload);
     }
 }

package/src/resolvers/SyncRolesUsersResolver.ts

@@ -385,8 +385,17 @@ export class SyncRolesAndUsersResolver {
         if (await user.Delete()) {
             return;
         }
-        // FK constraint fallback: when the user has dependent records that block hard delete,
-        // we mark the user inactive instead. A failure to soft-delete IS a real error and rolls back.
+        // Fallback when the hard delete does not happen. TWO distinct causes reach here, and this
+        // path deliberately treats them the same way:
+        //   1. FK constraints — the user has dependent records that block a hard delete.
+        //   2. Authorization — `MJUserEntityServer` (issue #4260) refuses a delete outright for any
+        //      caller whose `Type` is not 'Owner'. This mutation carries `@RequireSystemUser()` and
+        //      `getSystemUser()` resolves the seeded Owner, so cause 2 does not arise on a default
+        //      install; it does on a deployment whose system user is not an Owner.
+        // Soft-deleting is the right response to (1) and an acceptable one to (2) — but note the
+        // subsequent Save() is subject to the SAME guard, so under cause 2 it fails too and the
+        // error below is what the operator sees. Read `LatestResult` rather than assuming FK.
+        // A failure to soft-delete IS a real error and rolls back.
         user.IsActive = false;
         if (!await user.Save()) {
             throw new Error(`Failed to delete or deactivate user '${user.Email}': ${user.LatestResult?.CompleteMessage ?? 'unknown error'}`);

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/resolvers/__tests__/GetDataResolver.validation.test.ts

@@ -0,0 +1,95 @@
+// type-graphql decorators on the resolver class need the reflect-metadata polyfill.
+import 'reflect-metadata';
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { MockInstance } from 'vitest';
+import { SQLExpressionValidator } from '@memberjunction/global';
+
+const { executedSQL } = vi.hoisted(() => ({ executedSQL: [] as string[] }));
+
+// GetData's server bootstrap, provider, auth and driver imports are replaced so the resolver runs
+// offline. The fake driver records every text it is asked to run.
+vi.mock('../../index.js', () => ({ getDbType: () => 'sqlserver' }));
+vi.mock('@memberjunction/generic-database-provider', () => ({
+  QueryCompositionEngine: class {
+    HasCompositionTokens(): boolean {
+      return false;
+    }
+  },
+}));
+vi.mock('../../util.js', () => ({ GetReadOnlyDataSource: () => ({}), GetReadOnlyProvider: () => null }));
+vi.mock('../../auth/index.js', () => ({ getSystemUser: async () => ({}) }));
+vi.mock('mssql', () => ({
+  default: {
+    Request: class {
+      async query(text: string): Promise<{ recordset: Array<Record<string, unknown>> }> {
+        executedSQL.push(text);
+        return { recordset: [] };
+      }
+    },
+  },
+}));
+
+import { GetDataResolver, GetDataInputType, GetDataOutputType, registerAccessToken } from '../GetDataResolver.js';
+import type { AppContext } from '../../types.js';
+
+const CONTEXT = { dataSources: [] } as unknown as AppContext;
+
+let tokenSeq = 0;
+
+/** Calls GetData with a fresh valid token. */
+async function runGetData(queries: string[]): Promise<GetDataOutputType> {
+  const token = `getdata-validation-${Date.now()}-${++tokenSeq}`;
+  registerAccessToken(token, 60_000);
+  const input = Object.assign(new GetDataInputType(), { Token: token, Queries: queries });
+  return new GetDataResolver().GetData(input, CONTEXT);
+}
+
+/** The text of every call to the validator's `validate` method. */
+function validatedTexts(spy: MockInstance<SQLExpressionValidator['validate']>): string[] {
+  return spy.mock.calls.map(([text]) => text);
+}
+
+describe('GetData runs exactly the SQL it validated', () => {
+  beforeEach(() => {
+    executedSQL.length = 0;
+  });
+
+  it('validates and runs the same text when the query contains backslash sequences', async () => {
+    const query = String.raw`SELECT Name FROM __mj.vwFiles WHERE Path = 'C:\new\temp'`;
+    const validateSpy = vi.spyOn(SQLExpressionValidator.Instance, 'validate');
+
+    const output = await runGetData([query]);
+
+    expect(output.ErrorMessages).toEqual([null]);
+    expect(executedSQL).toEqual(validatedTexts(validateSpy));
+    expect(executedSQL).toEqual([query]);
+    expect(validateSpy).toHaveBeenCalledWith(query, { context: 'full_query', Dialect: 'sqlserver' });
+  });
+
+  it('runs the trimmed text that the validator reads', async () => {
+    const validateSpy = vi.spyOn(SQLExpressionValidator.Instance, 'validate');
+
+    const output = await runGetData(['\n  SELECT 1 AS One  \n']);
+
+    expect(output.ErrorMessages).toEqual([null]);
+    expect(executedSQL).toEqual(['SELECT 1 AS One']);
+    expect(validatedTexts(validateSpy)).toEqual(executedSQL);
+  });
+
+  it('refuses a query whose text, as written, does not open with SELECT or WITH', async () => {
+    const output = await runGetData(["-- note\\n SELECT 1\nPRINT 'hello'"]);
+
+    expect(executedSQL).toEqual([]);
+    expect(output.Success).toBe(false);
+    expect(output.ErrorMessages[0]).toMatch(/must start with SELECT or WITH/);
+  });
+
+  it('does not run a refused query and still runs the others', async () => {
+    const output = await runGetData(['SELECT 1; SELECT 2', 'SELECT 1 AS One']);
+
+    expect(executedSQL).toEqual(['SELECT 1 AS One']);
+    expect(output.ErrorMessages[0]).toMatch(/Semicolons are not allowed/);
+    expect(output.ErrorMessages[1]).toBeNull();
+  });
+});

package/src/resolvers/__tests__/ReportResolver.test.ts

@@ -133,6 +133,8 @@ vi.mock('@memberjunction/core', async () => {
 });
 
 vi.mock('@memberjunction/core-entities', () => ({}));
+// ResolverBase imports the client clause screen from generic-database-provider; these tests do not reach it.
+vi.mock('@memberjunction/generic-database-provider', () => ({}));
 
 // ─── Import after mocks ──────────────────────────────────────────────────
 import { ReportResolverExtended } from '../ReportResolver';

package/src/resolvers/adhocTimeout.ts

@@ -0,0 +1,12 @@
+/** The timeout an ad-hoc query gets when the caller names none. */
+const DEFAULT_TIMEOUT_SECONDS = 30;
+
+/**
+ * The timeout an ad-hoc query runs with: what the caller asked for (or the default), but never
+ * longer than the server's `requestTimeout`, so a caller cannot hold a read-only connection longer
+ * than any other request may. `requestTimeoutMs` of 0 or less means the server sets no limit.
+ */
+export function ClampAdhocTimeoutSeconds(requested: number | undefined, requestTimeoutMs: number): number {
+    const seconds = requested != null && requested > 0 ? requested : DEFAULT_TIMEOUT_SECONDS;
+    return requestTimeoutMs > 0 ? Math.min(seconds, Math.max(1, Math.floor(requestTimeoutMs / 1000))) : seconds;
+}

package/src/rest/ViewOperationsHandler.ts

@@ -1,7 +1,8 @@
 import { 
-    LogError, Metadata, RunView, RunViewParams, 
-    RunViewResult, UserInfo 
+    BaseEntity, LogError, Metadata, RunView, RunViewParams, 
+    RunViewResult, UserInfo, type IRunViewProvider 
 } from '@memberjunction/core';
+import { ClientClauseScreen } from '@memberjunction/generic-database-provider';
 
 /**
  * View Operations Implementation for REST endpoints
@@ -32,11 +33,11 @@ export class ViewOperationsHandler {
                 };
             }
             
-            // Sanitize and validate parameters
-            this.sanitizeRunViewParams(params);
+            // Sanitize and validate parameters against the provider that runs the view
+            const runView = new RunView();
+            this.sanitizeRunViewParams(params, md, runView.ProviderToUse, user);
             
             // Execute the view
-            const runView = new RunView();
             const result = await runView.RunView(params, user);
             
             return { success: true, result };
@@ -51,8 +52,9 @@ export class ViewOperationsHandler {
      */
     static async runViews(paramsArray: RunViewParams[], user: UserInfo): Promise<{ success: boolean, results?: RunViewResult[], error?: string }> {
         try {
-            // Validate and sanitize each set of parameters
+            // Validate and sanitize each set of parameters against the provider that runs the views
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
+            const runView = new RunView();
             for (const params of paramsArray) {
                 // Validate entity exists
                 const entity = md.Entities.find(e => e.Name === params.EntityName);
@@ -73,11 +75,10 @@ export class ViewOperationsHandler {
                 }
                 
                 // Sanitize parameters
-                this.sanitizeRunViewParams(params);
+                this.sanitizeRunViewParams(params, md, runView.ProviderToUse, user);
             }
             
             // Execute the views
-            const runView = new RunView();
             const results = await runView.RunViews(paramsArray, user);
             
             return { success: true, results };
@@ -104,11 +105,11 @@ export class ViewOperationsHandler {
                 throw new Error(`User ${user.Name} does not have permission to read ${params.EntityName} records`);
             }
             
-            // Sanitize and validate parameters
-            this.sanitizeRunViewParams(params);
+            // Sanitize and validate parameters against the provider that runs the view
+            const runView = new RunView();
+            this.sanitizeRunViewParams(params, md, runView.ProviderToUse, user);
             
             // Execute the view
-            const runView = new RunView();
             return await runView.RunView(params, user);
         } catch (error) {
             LogError(error);
@@ -173,35 +174,53 @@ export class ViewOperationsHandler {
     }
     
     /**
-     * Sanitize and validate RunViewParams
+     * Sanitize and validate RunViewParams. Client filter and sort text passes the same clause
+     * screen as the GraphQL RunView resolvers, parsed in the dialect of `provider`, the provider
+     * that runs the view.
      */
-    private static sanitizeRunViewParams(params: RunViewParams): void {
+    private static sanitizeRunViewParams(params: RunViewParams, md: Metadata, provider: IRunViewProvider, user: UserInfo): void {
         // Ensure EntityName is provided
         if (!params.EntityName) {
             throw new Error('EntityName is required');
         }
+
+        // A loaded view entity cannot arrive over JSON; the provider would trust a plain object's
+        // fields (its ID is spliced into view SQL). REST callers name a saved view by ViewID or ViewName.
+        if (params.ViewEntity != null && !(params.ViewEntity instanceof BaseEntity)) {
+            throw new Error('ViewEntity is not accepted over REST; use ViewID or ViewName');
+        }
         
         // Convert string arrays if they came in as comma-separated strings
         if (params.Fields && typeof params.Fields === 'string') {
             params.Fields = (params.Fields as string).split(',');
         }
         
-        // Sanitize numeric values
+        // Sanitize numeric values: base-10, integral, and clamped to a sane range so a
+        // negative/garbage value can never reach the SQL layer.
         if (params.MaxRows !== undefined) {
-            params.MaxRows = typeof params.MaxRows === 'string' 
-                ? parseInt(params.MaxRows as string) 
+            const parsed = typeof params.MaxRows === 'string'
+                ? parseInt(params.MaxRows as string, 10)
                 : params.MaxRows;
+            params.MaxRows = Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed as number)) : undefined;
         }
         
         if (params.StartRow !== undefined) {
-            params.StartRow = typeof params.StartRow === 'string' 
-                ? parseInt(params.StartRow as string) 
+            const parsed = typeof params.StartRow === 'string'
+                ? parseInt(params.StartRow as string, 10)
                 : params.StartRow;
+            params.StartRow = Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed as number)) : undefined;
         }
         
         // Default ResultType if not provided
         if (!params.ResultType) {
             params.ResultType = 'simple';
         }
+
+        ClientClauseScreen.ScreenViewClauses(
+            { ExtraFilter: params.ExtraFilter, OrderBy: params.OrderBy, OverrideExcludeFilter: params.OverrideExcludeFilter },
+            md.Entities,
+            ClientClauseScreen.DialectFor(provider),
+            user,
+        );
     }
 }

package/src/services/TaskOrchestrator.ts

@@ -4,7 +4,7 @@ import { AgentRunner } from '@memberjunction/ai-agents';
 import { ChatMessageRole } from '@memberjunction/ai';
 import { PubSubEngine } from 'type-graphql';
 import { UserPayload } from '../types.js';
-import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
+import { publishStatusUpdate } from '../generic/PushStatusResolver.js';
 import { MJAIAgentEntityExtended } from '@memberjunction/ai-core-plus';
 
 /**
@@ -226,7 +226,10 @@ export class TaskOrchestrator {
             return;
         }
 
-        const payload = {
+        LogStatus(`📡 Publishing task progress: ${taskName} - ${message} (${percentComplete}%) to session ${this.userPayload.sessionId}`);
+        publishStatusUpdate(this.pubSub, {
+            sessionId: this.userPayload.sessionId,
+            ownerUserId: this.userPayload.userRecord.ID,
             message: JSON.stringify({
                 resolver: 'TaskOrchestrator',
                 type: 'TaskProgress',
@@ -238,12 +241,8 @@ export class TaskOrchestrator {
                     timestamp: new Date(),
                     conversationDetailId: this.conversationDetailId
                 }
-            }),
-            sessionId: this.userPayload.sessionId
-        };
-
-        LogStatus(`📡 Publishing task progress: ${taskName} - ${message} (${percentComplete}%) to session ${this.userPayload.sessionId}`);
-        this.pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, payload);
+            })
+        });
 
         LogStatus(`[Task: ${taskName}] ${message} (${percentComplete}%)`);
     }
@@ -257,7 +256,10 @@ export class TaskOrchestrator {
             return;
         }
 
-        const payload = {
+        LogStatus(`📡 Publishing agent progress: ${taskName} → ${agentStep} to session ${this.userPayload.sessionId}`);
+        publishStatusUpdate(this.pubSub, {
+            sessionId: this.userPayload.sessionId,
+            ownerUserId: this.userPayload.userRecord.ID,
             message: JSON.stringify({
                 resolver: 'TaskOrchestrator',
                 type: 'AgentProgress',
@@ -269,12 +271,8 @@ export class TaskOrchestrator {
                     timestamp: new Date(),
                     conversationDetailId: this.conversationDetailId
                 }
-            }),
-            sessionId: this.userPayload.sessionId
-        };
-
-        LogStatus(`📡 Publishing agent progress: ${taskName} → ${agentStep} to session ${this.userPayload.sessionId}`);
-        this.pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, payload);
+            })
+        });
 
         LogStatus(`[Task: ${taskName}] → ${agentStep}: ${agentMessage}`);
     }
@@ -851,8 +849,10 @@ export class TaskOrchestrator {
 
             // Publish real-time event if pubSub available
             if (this.pubSub && this.userPayload) {
-                this.pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
-                    userPayload: JSON.stringify(this.userPayload),
+                // NOTE (B49): normalized from a malformed no-sessionId payload
+                publishStatusUpdate(this.pubSub, {
+                    sessionId: this.userPayload.sessionId,
+                    ownerUserId: this.userPayload.userRecord.ID,
                     message: JSON.stringify({
                         type: 'notification',
                         notificationId: notification.ID,