@memberjunction/server 6.2.0-edge.5 → 6.2.0-edge.7

package/src/rest/OAuthCallbackHandler.ts

@@ -28,6 +28,15 @@ const ENTITY_MCP_SERVERS = 'MJ: MCP Servers';
 /** Entity name for OAuth Authorization States */
 const ENTITY_OAUTH_AUTHORIZATION_STATES = 'MJ: O Auth Authorization States';
 
+const UUID_SHAPE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+
+function sqlUuid(value: string, argName: string): string {
+    if (typeof value !== 'string' || !UUID_SHAPE.test(value)) {
+        throw new Error(`${argName} must be a UUID`);
+    }
+    return value;
+}
+
 /**
  * Configuration for OAuth callback handler
  */
@@ -693,12 +702,11 @@ export class OAuthCallbackHandler {
             const rv = new RunView();
 
             // Get connection to get server ID.
-            // connectionId is caller-supplied (POST /oauth/initiate body). MJ ExtraFilter is a raw
-            // SQL fragment, so single quotes MUST be doubled to prevent injection — matching the
-            // escaping used for stateParameter in loadAuthorizationState().
+            // connectionId is caller-supplied (POST /oauth/initiate body); enforce strict UUID shape
+            // (matching MCPResolver.getServerOAuthConfig) before interpolating into ExtraFilter.
             const connResult = await rv.RunView<{ MCPServerID: string }>({
                 EntityName: ENTITY_MCP_SERVER_CONNECTIONS,
-                ExtraFilter: `ID='${connectionId.replace(/'/g, "''")}'`,
+                ExtraFilter: `ID='${sqlUuid(connectionId, 'connectionId')}'`,
                 Fields: ['MCPServerID'],
                 ResultType: 'simple'
             }, contextUser);
@@ -719,7 +727,7 @@ export class OAuthCallbackHandler {
                 OAuthRequirePKCE: boolean | null;
             }>({
                 EntityName: ENTITY_MCP_SERVERS,
-                ExtraFilter: `ID='${serverId}'`,
+                ExtraFilter: `ID='${sqlUuid(serverId, 'serverId')}'`,
                 Fields: [
                     'OAuthIssuerURL', 'OAuthScopes', 'OAuthMetadataCacheTTLMinutes',
                     'OAuthClientID', 'OAuthClientSecretEncrypted', 'OAuthRequirePKCE'

package/src/rest/RESTEndpointHandler.ts

@@ -2,7 +2,7 @@ import express from 'express';
 import {
     BaseEntity, CompositeKey, EntityDeleteOptions, EntityInfo,
     EntityPermissionType, EntitySaveOptions, LogError, Metadata,
-    RunView, RunViewParams, UserInfo
+    RunView, RunViewParams, StripServerOnlyRunViewParams, UserInfo
 } from '@memberjunction/core';
 import { EntityCRUDHandler } from './EntityCRUDHandler.js';
 import { ViewOperationsHandler } from './ViewOperationsHandler.js';
@@ -499,10 +499,11 @@ export class RESTEndpointHandler {
             
             const user = req['mjUser'];
             
-            // Create RunViewParams from the request body
+            // Create RunViewParams from the request body, without the fields only server code sets;
+            // the time zone comes from the x-mj-timezone header, as on the GraphQL path
             const params: RunViewParams = {
-                EntityName: entityName,
-                ...viewParams
+                ...StripServerOnlyRunViewParams({ ...viewParams, EntityName: entityName }),
+                TimeZone: req.userPayload?.TimeZone
             };
             
             const result = await ViewOperationsHandler.runView(params, user);
@@ -533,7 +534,9 @@ export class RESTEndpointHandler {
             
             // Filter out any views for entities that aren't allowed
             // using our enhanced entity filtering with wildcards and schema support
-            const filteredParams = params.filter(p => this.isEntityAllowed(p.EntityName));
+            const filteredParams = params
+                .filter(p => this.isEntityAllowed(p.EntityName))
+                .map(p => ({ ...StripServerOnlyRunViewParams(p), TimeZone: req.userPayload?.TimeZone }));
             
             // If all requested entities were filtered out, return an error
             if (filteredParams.length === 0 && params.length > 0) {

package/src/rest/RealtimeRecordingHandler.ts

@@ -34,7 +34,7 @@ import {
     LoadOwnedRealtimeSession, RealtimeSessionNotFoundError, RealtimeSessionOwnershipError,
 } from '../realtimeSessions/ownedRealtimeSession.js';
 import type { IRecordingAssemblyScheduler } from '../realtimeSessions/RecordingAssemblyScheduler.js';
-import { AuthorizeSessionAccess, LoadSessionConversationExternalID } from '../realtimeSessions/sessionAccess.js';
+import { AuthorizeLoadedSession } from '../realtimeSessions/sessionAccess.js';
 
 /** Where {@link CreateRealtimeRecordingRouter} is mounted (under the reserved `/realtime` root). */
 export const REALTIME_RECORDING_MOUNT_PATH = '/realtime/recording';
@@ -76,8 +76,8 @@ export interface RealtimeRecordingRouterDeps {
     /** The authenticated caller, or null (answered 401). */
     ResolveCaller(req: Request): RealtimeRecordingCaller | null;
     LoadOwnedSession: typeof LoadOwnedRealtimeSession;
-    /** The session conversation's per-session scope id, for the anonymous-guest half of the access decision. */
-    LoadConversationExternalID: typeof LoadSessionConversationExternalID;
+    /** The per-session scope rule of the access decision, applied to the session {@link LoadOwnedSession} returned. */
+    AuthorizeSession: typeof AuthorizeLoadedSession;
     /** The ledger for one request; `contextUser` is the caller (used for logging by the procs). */
     CreateLedger(provider: DatabaseProviderBase, contextUser: UserInfo): IRealtimeRecordingLedger;
     Scheduler: IRecordingAssemblyScheduler;
@@ -258,16 +258,15 @@ async function handleTerminal(deps: RealtimeRecordingRouterDeps, req: Request, r
 
 /**
  * Loads the session through the shared ownership gate, then applies the per-session scope rule of
- * {@link AuthorizeSessionAccess}. The gate alone checks `UserID`, which every anonymous widget guest shares
- * (they all authenticate as the one Anonymous user); without the scope rule one guest could write shards to
- * another guest's recording, and a different-bytes shard would mark it Failed. The owner half of the
- * decision repeats the gate's check on purpose: the decision is one rule, applied whole. Named users carry
- * no scope and are unaffected.
+ * {@link AuthorizeLoadedSession}. The production gate (`LoadOwnedRealtimeSession`) already applies the same
+ * rule, so this is a deliberate second check at the HTTP boundary: `LoadOwnedSession` is an injected dependency,
+ * and without the scope rule one anonymous guest could write shards to another guest's recording (every guest
+ * shares the one Anonymous user), and a different-bytes shard would mark it Failed. It costs one extra
+ * conversation read per request. Named users without a scope are unaffected.
  */
 async function loadAuthorizedSession(deps: RealtimeRecordingRouterDeps, sessionID: string, caller: RealtimeRecordingCaller): Promise<MJAIAgentSessionEntity> {
     const session = await deps.LoadOwnedSession(sessionID, caller.ContextUser, caller.Provider);
-    const externalID = await deps.LoadConversationExternalID(session, caller.ContextUser, caller.Provider);
-    const decision = AuthorizeSessionAccess({ SessionUserID: session.UserID, ConversationExternalID: externalID }, caller.ContextUser);
+    const decision = await deps.AuthorizeSession(session, caller.ContextUser, caller.Provider);
     if (decision.Allowed === false) {
         LogError(`RealtimeRecordingHandler: refused user ${caller.ContextUser.ID} on session ${sessionID}: ${decision.Reason}`);
         throw new RecordingRequestError(403, 'Not authorized for this realtime session');

package/src/rest/ViewOperationsHandler.ts

@@ -1,8 +1,10 @@
 import { 
-    BaseEntity, LogError, Metadata, RunView, RunViewParams, 
+    BaseEntity, EntityInfo, LogError, Metadata, RunView, RunViewParams, 
     RunViewResult, UserInfo, type IRunViewProvider 
 } from '@memberjunction/core';
+import { EscapeSQLString } from '@memberjunction/global';
 import { ClientClauseScreen } from '@memberjunction/generic-database-provider';
+import { ProjectRowsForCaller } from '../generic/fieldSecurityTransport.js';
 
 /**
  * View Operations Implementation for REST endpoints
@@ -40,7 +42,7 @@ export class ViewOperationsHandler {
             // Execute the view
             const result = await runView.RunView(params, user);
             
-            return { success: true, result };
+            return { success: true, result: this.projectResult(result, entity, user, md) };
         } catch (error) {
             LogError(error);
             return { success: false, error: (error as Error)?.message || 'Unknown error' };
@@ -60,6 +62,7 @@ export class ViewOperationsHandler {
             // 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();
+            const entities: EntityInfo[] = [];
             for (const params of paramsArray) {
                 // Validate entity exists
                 const entity = md.Entities.find(e => e.Name === params.EntityName);
@@ -81,12 +84,14 @@ export class ViewOperationsHandler {
                 
                 // Sanitize parameters
                 this.sanitizeRunViewParams(params, md, runView.ProviderToUse, user);
+                entities.push(entity);
             }
             
             // Execute the views
             const results = await runView.RunViews(paramsArray, user);
             
-            return { success: true, results };
+            const projected = results?.map((r, i) => this.projectResult(r, entities[i], user, md));
+            return { success: true, results: projected?.some((r, i) => r !== results[i]) ? projected : results };
         } catch (error) {
             LogError(error);
             return { success: false, error: (error as Error)?.message || 'Unknown error' };
@@ -120,7 +125,7 @@ export class ViewOperationsHandler {
             this.sanitizeRunViewParams(params, md, runView.ProviderToUse, user);
             
             // Execute the view
-            return await runView.RunView(params, user);
+            return this.projectResult(await runView.RunView(params, user), entity, user, md);
         } catch (error) {
             LogError(error);
             throw error;
@@ -159,7 +164,7 @@ export class ViewOperationsHandler {
             // Run a view to get the available views
             const params: RunViewParams = {
                 EntityName: 'MJ: User Views',
-                ExtraFilter: `Entity = '${entityName}'`
+                ExtraFilter: `Entity = '${EscapeSQLString(entity.Name)}'`
             };
             
             const runView = new RunView();
@@ -193,6 +198,19 @@ export class ViewOperationsHandler {
         return this.GetEntityViews(entityName, user);
     }
     
+    /**
+     * The result with its rows reduced to what `user` may READ. The provider already narrows the
+     * rows it reads for a restricted caller; this is the backstop for any that arrive wider. The
+     * same result object comes back when no row needed changing.
+     */
+    private static projectResult(result: RunViewResult, entity: EntityInfo, user: UserInfo, md: Metadata): RunViewResult {
+        if (!result?.Results?.length) {
+            return result;
+        }
+        const rows = ProjectRowsForCaller(entity, result.Results as Record<string, unknown>[], user, md);
+        return rows === result.Results ? result : { ...result, Results: rows };
+    }
+
     /**
      * 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
@@ -231,8 +249,9 @@ export class ViewOperationsHandler {
             params.StartRow = Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed as number)) : undefined;
         }
         
-        // Default ResultType if not provided
-        if (!params.ResultType) {
+        // Plain rows only on the wire. An entity object serializes its internal state rather than
+        // its projected field values, so a caller may not ask for one; a count carries no row.
+        if (params.ResultType !== 'count_only') {
             params.ResultType = 'simple';
         }
 

package/src/rest/setupRESTEndpoints.ts

@@ -53,10 +53,12 @@ export interface RESTApiOptions {
 }
 
 /**
- * Default REST API configuration
+ * Default REST API configuration. Disabled by default (matching the documented default and
+ * MJServer's own config default): mounting a full-entity REST API must be an explicit decision,
+ * never a side effect of calling SetupRESTEndpoints with no options.
  */
 export const DEFAULT_REST_API_OPTIONS: RESTApiOptions = {
-    enabled: true,
+    enabled: false,
 };
 
 /**
@@ -95,6 +97,13 @@ export function SetupRESTEndpoints(
     if (authMiddleware) {
         app.use(basePath, BodyParser.json({ limit: '50mb' }), authMiddleware, restHandler.getRouter());
     } else {
+        // MJServer itself is safe here (its unified auth middleware runs globally before this
+        // mount), but a third-party caller passing no authMiddleware may be mounting a fully
+        // UNauthenticated entity CRUD API — say so loudly.
+        LogStatusEx({
+            message: `REST API mounted at ${basePath} WITHOUT a route-level auth middleware. ` +
+                `Ensure an authentication middleware runs globally before this mount, or pass one to SetupRESTEndpoints.`,
+        });
         app.use(basePath, BodyParser.json({ limit: '50mb' }), restHandler.getRouter());
     }
 

package/src/serverRoleConfigUnits.ts

@@ -0,0 +1,48 @@
+/**
+ * Supported MJServer horizontal scaling roles (`MJ_SERVER_ROLE`).
+ * - `'all'` (default): Monolithic mode — serves HTTP/GraphQL/WebSocket traffic AND runs all background worker loops.
+ * - `'api'`: Stateless API/WebSocket edge — serves HTTP/GraphQL/WebSocket traffic ONLY; skips background schedulers,
+ *   queue dispatchers, and janitors so event-loop responsiveness is isolated from heavy background jobs.
+ * - `'worker'`: Background worker replica — runs `ScheduledJobsService`, `IntegrationSyncWorkerService`,
+ *   `StartTaskGraphDispatcher`, `StartWorkQueueHost`, `SessionJanitor`, and orphan reconcilers while keeping
+ *   only lightweight healthcheck/metrics HTTP endpoints active.
+ */
+export type ServerRole = 'all' | 'api' | 'worker';
+
+const VALID_SERVER_ROLES: ReadonlySet<string> = new Set<ServerRole>(['all', 'api', 'worker']);
+
+/**
+ * Resolves the server role from `MJ_SERVER_ROLE` or `mj.config.cjs`'s `serverRole`.
+ * Defaults to `'all'` when unset or blank. Throws on unrecognized values so deployment typos
+ * fail fast at startup instead of silently running the wrong workload profile.
+ */
+export function ResolveServerRole(rawValue?: string | null): ServerRole {
+    const trimmed = rawValue?.trim().toLowerCase();
+    if (!trimmed) {
+        return 'all';
+    }
+    if (VALID_SERVER_ROLES.has(trimmed)) {
+        return trimmed as ServerRole;
+    }
+    throw new Error(
+        `Invalid MJ_SERVER_ROLE "${rawValue}". Expected one of: 'all', 'api', 'worker'.`
+    );
+}
+
+/**
+ * Returns `true` when this server instance should start background worker loops
+ * (`ScheduledJobsService`, `IntegrationSyncWorkerService`, `StartTaskGraphDispatcher`,
+ * `StartWorkQueueHost`, `SessionJanitor`, `StartBridgeOrphanReconciliation`, and
+ * `OrphanDetailReconciler`).
+ */
+export function ShouldRunBackgroundWorkers(role: ServerRole): boolean {
+    return role === 'all' || role === 'worker';
+}
+
+/**
+ * Returns `true` when this server instance is designated to serve interactive
+ * API / GraphQL / WebSocket client traffic.
+ */
+export function ShouldServeInteractiveTraffic(role: ServerRole): boolean {
+    return role === 'all' || role === 'api';
+}

package/src/services/DurableEntityActionTaskSubmitter.ts

@@ -15,7 +15,7 @@ import type {
     DurableEntityActionSubmission,
     DurableEntityActionSubmitter,
 } from '@memberjunction/actions-base';
-import { LogError } from '@memberjunction/core';
+import { type IEntityDataProvider, type IMetadataProvider, LogError } from '@memberjunction/core';
 import { TaskNode, type TaskGraphSpec } from '@memberjunction/ai-core-plus';
 import { MJEnvironmentEntityExtended } from '@memberjunction/core-entities';
 import { TaskGraphService, type ProviderFactory } from '@memberjunction/task-graph';
@@ -59,7 +59,9 @@ export class DurableEntityActionTaskSubmitter implements DurableEntityActionSubm
                 durable: true,
             };
 
-            const provider = await this.providerFactory.CreateProvider();
+            const provider: IMetadataProvider = isMetadataProvider(request.Provider)
+                ? request.Provider
+                : await this.providerFactory.CreateProvider();
             const result = await new TaskGraphService().Submit(spec, {
                 EnvironmentID: this.environmentID,
                 ContextUser: request.ContextUser,
@@ -76,3 +78,9 @@ export class DurableEntityActionTaskSubmitter implements DurableEntityActionSubm
         }
     }
 }
+
+function isMetadataProvider(
+    provider: IMetadataProvider | IEntityDataProvider | undefined,
+): provider is IMetadataProvider {
+    return !!provider && 'GetEntityObject' in provider && typeof provider.GetEntityObject === 'function';
+}

package/src/services/TaskGraphActionRunner.ts

@@ -11,6 +11,7 @@
  */
 import { ActionEngineServer } from '@memberjunction/actions';
 import { ActionParam } from '@memberjunction/actions-base';
+import { BuildActionOutputObject } from '@memberjunction/ai-core-plus';
 import { LogError } from '@memberjunction/core';
 import { UUIDsEqual } from '@memberjunction/global';
 import type { TaskActionRunner, TaskActionRunParams, TaskActionRunResult } from '@memberjunction/task-graph';
@@ -97,29 +98,7 @@ export class TaskGraphActionRunner implements TaskActionRunner {
      * produced.
      */
     private buildOutput(actionParams: ActionParam[], resultMessage?: string | null): Record<string, unknown> {
-        const output: Record<string, unknown> = {};
-        if (typeof resultMessage === 'string') {
-            const trimmed = resultMessage.trim();
-            if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
-                try {
-                    const parsed: unknown = JSON.parse(trimmed);
-                    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                        Object.assign(output, parsed as Record<string, unknown>);
-                    }
-                } catch {
-                    // Non-JSON prose message; ignore.
-                }
-            }
-        }
-        for (const p of actionParams ?? []) {
-            if (p.Type === 'Output' || p.Type === 'Both') output[p.Name] = p.Value;
-        }
-        if (typeof output.handle === 'string' && output.Handle === undefined) {
-            output.Handle = output.handle;
-        } else if (typeof output.Handle === 'string' && output.handle === undefined) {
-            output.handle = output.Handle;
-        }
-        return output;
+        return BuildActionOutputObject(actionParams, resultMessage);
     }
 
     /**

package/src/services/TaskGraphAgentRunner.ts

@@ -43,6 +43,25 @@ export class TaskGraphAgentRunner implements TaskAgentRunner {
                     };
                 }
             }
+
+            let configurationId: string | undefined;
+            const requestedPreset = params.ConfigurationPresetName?.trim();
+            if (requestedPreset) {
+                const matched = AIEngine.Instance.FindActiveAgentConfigurationPreset(agent.ID, requestedPreset);
+                if (!matched) {
+                    const presets = AIEngine.Instance.GetAgentConfigurationPresets(agent.ID, true);
+                    const available = presets.map((p) => p.Name).join(', ') || 'none';
+                    return {
+                        Success: false,
+                        ErrorMessage: `Agent '${agent.Name || params.AgentID}' has no active preset '${requestedPreset}'. Available: ${available}.`,
+                    };
+                }
+                configurationId = matched.AIConfigurationID ?? undefined;
+            } else {
+                configurationId = parentRun?.ConfigurationID ?? undefined;
+            }
+
+            const parentAgentHierarchy = this.buildParentAgentHierarchy(parentRun, params);
             const taskContext = await this.resolveTaskContext(params);
             const conversationDetailId =
                 parentRun?.ConversationDetailID ?? taskContext.conversationDetailId ?? undefined;
@@ -66,6 +85,8 @@ export class TaskGraphAgentRunner implements TaskAgentRunner {
                 // rather than starting the chain over. Without it MAX_REINVOKE_DEPTH never fires.
                 continuationDepth: params.ContinuationDepth ?? 0,
                 parentRun,
+                parentAgentHierarchy,
+                configurationId,
                 // The bridge from the agent's own progress stream up to graph-level observers: the
                 // dispatcher turns these into rate-limited `NodeProgress` frames, which is how a
                 // running Agent step shows "what it is doing right now" on the workflow canvas.
@@ -221,6 +242,28 @@ export class TaskGraphAgentRunner implements TaskAgentRunner {
         }
     }
 
+    /**
+     * Reads the root-first ancestor agent name hierarchy carried on the task from when its graph was
+     * submitted (`params.ParentAgentHierarchy`), falling back to the submitting run's own agent name
+     * when no hierarchy was persisted on the parent task.
+     */
+    private buildParentAgentHierarchy(
+        parentRun: MJAIAgentRunEntityExtended | undefined,
+        params: TaskAgentRunParams,
+    ): string[] | undefined {
+        if (Array.isArray(params.ParentAgentHierarchy)) {
+            const carried = params.ParentAgentHierarchy
+                .filter((name): name is string => typeof name === 'string')
+                .map((name) => name.trim())
+                .filter((name) => name.length > 0);
+            if (carried.length > 0) {
+                return carried;
+            }
+        }
+        const submittingAgentName = parentRun?.Agent?.trim();
+        return submittingAgentName ? [submittingAgentName] : undefined;
+    }
+
     /**
      * Builds the agent's instruction from the task's name/description, its structured input payload,
      * and its dependencies' outputs.

package/src/services/TaskGraphContinuationDeliverer.ts

@@ -13,9 +13,9 @@
  * @module @memberjunction/server
  */
 import { LogError, LogStatus, RunView, type IMetadataProvider, type UserInfo } from '@memberjunction/core';
-import { UUIDsEqual } from '@memberjunction/global';
+import { MJAIAgentRunEntity, MJConversationDetailEntity, MJConversationDetailEntityExtended } from '@memberjunction/core-entities';
 import { UserCache } from '@memberjunction/generic-database-provider';
-import { MJAIAgentRunEntity, MJConversationDetailEntity } from '@memberjunction/core-entities';
+import { UUIDsEqual } from '@memberjunction/global';
 import { MJAIAgentEntityExtended } from '@memberjunction/ai-core-plus';
 import { AgentRunner } from '@memberjunction/ai-agents';
 import { ChatMessageRole } from '@memberjunction/ai';
@@ -68,7 +68,12 @@ export class TaskGraphContinuationDeliverer implements TaskContinuationDeliverer
             }
 
             const provider = await this.providerFactory.CreateProvider();
-            const origin = await this.resolveOrigin(params.ConversationDetailID, provider);
+            // Written as the person who submitted the graph, marked as the server's: the conversation detail gate lets
+            // only a marked server write create or update an agent's reply, and only in a conversation its user owns or
+            // holds an Edit grant on. Not as the conversation's owner: `TaskGraph.Submit` takes any conversation detail
+            // ID, so writing as the owner would let anyone who can submit a graph post into a conversation they can't reach.
+            const writer = this.resolveSubmitter(params.SubmittedByUserID);
+            const origin = await this.resolveOrigin(params.ConversationDetailID, provider, writer.ID);
             if (!origin) {
                 LogError(
                     `[TaskGraphContinuationDeliverer] Conversation detail ${params.ConversationDetailID} could not be loaded — ` +
@@ -77,7 +82,6 @@ export class TaskGraphContinuationDeliverer implements TaskContinuationDeliverer
                 return;
             }
 
-            const actingUser = this.resolveActingUser(origin.OwnerUserID);
             const enrichedParams = await this.enrichTasksWithOutputs(params, provider);
             const renderedOutcome = this.renderMessage(enrichedParams);
 
@@ -105,8 +109,9 @@ export class TaskGraphContinuationDeliverer implements TaskContinuationDeliverer
                 return;
             }
 
-            const detail = await provider.GetEntityObject<MJConversationDetailEntity>('MJ: Conversation Details', actingUser);
+            const detail = await provider.GetEntityObject<MJConversationDetailEntityExtended>('MJ: Conversation Details', writer);
             detail.NewRecord();
+            detail.MarkServerAuthoredReply();
             detail.ConversationID = origin.ConversationID;
             detail.BranchID = origin.BranchID;
             detail.ParentID = params.ConversationDetailID;
@@ -191,7 +196,7 @@ export class TaskGraphContinuationDeliverer implements TaskContinuationDeliverer
 
             // Run on the fork of the message that started the graph, as PostMessage posts into it:
             // RunAgent derives the conversation from the detail, but not the fork.
-            const runUserId = targetRun.UserID || priorRun.UserID;
+            const runUserId = targetRun.UserID || priorRun.UserID || params.SubmittedByUserID;
             const origin = params.ConversationDetailID
                 ? await this.resolveOrigin(params.ConversationDetailID, provider, runUserId)
                 : null;
@@ -205,15 +210,16 @@ export class TaskGraphContinuationDeliverer implements TaskContinuationDeliverer
             // - When intervening messages were sent while the workflow ran (origin.IsLatest === false),
             //   create a bottom continuation message linked via ParentID = params.ConversationDetailID
             //   and update the originating message's stale "I'll follow up..." copy.
-            let replyDetail: MJConversationDetailEntity | null = null;
+            let replyDetail: MJConversationDetailEntityExtended | null = null;
             let replySaved = false;
             if (origin?.ConversationID) {
                 if (origin.IsLatest) {
                     replyDetail = origin.OriginDetail;
                     replySaved = true;
                 } else {
-                    replyDetail = await provider.GetEntityObject<MJConversationDetailEntity>('MJ: Conversation Details', actingUser);
+                    replyDetail = await provider.GetEntityObject<MJConversationDetailEntityExtended>('MJ: Conversation Details', actingUser);
                     replyDetail.NewRecord();
+                    replyDetail.MarkServerAuthoredReply();
                     replyDetail.ConversationID = origin.ConversationID;
                     replyDetail.BranchID = origin.BranchID;
                     replyDetail.ParentID = params.ConversationDetailID;
@@ -272,7 +278,12 @@ export class TaskGraphContinuationDeliverer implements TaskContinuationDeliverer
                 if (result?.automaticCommands && result.automaticCommands.length > 0) {
                     replyDetail.AutomaticCommands = JSON.stringify(result.automaticCommands);
                 }
-                await replyDetail.Save();
+                if (!(await replyDetail.Save())) {
+                    LogError(
+                        `[TaskGraphContinuationDeliverer] Could not save synthesized reply for "${params.WorkflowName}": ` +
+                        `${replyDetail.LatestResult?.CompleteMessage ?? 'unknown error'}`
+                    );
+                }
 
                 if (!origin?.IsLatest && origin?.OriginDetail) {
                     await this.markOriginDetailCompleted(origin.OriginDetail, params.WorkflowName);
@@ -335,6 +346,18 @@ export class TaskGraphContinuationDeliverer implements TaskContinuationDeliverer
         }
     }
 
+    /**
+     * The person who submitted the graph; the deliverer's own user when the graph records no submitter or they are not
+     * in the user cache (the gate then decides, and refuses a conversation that user cannot write to).
+     */
+    private resolveSubmitter(submittedByUserID: string | null): UserInfo {
+        if (!submittedByUserID) {
+            return this.contextUser;
+        }
+        const users = UserCache.Instance?.Users ?? UserCache.Users ?? [];
+        return users.find((u) => UUIDsEqual(u.ID, submittedByUserID)) ?? this.contextUser;
+    }
+
     /**
      * Broadcasts a completion event on `PUSH_STATUS_UPDATES_TOPIC` so open conversation tabs
      * immediately reload both the originating workflow message and the newly posted continuation reply.
@@ -405,11 +428,11 @@ export class TaskGraphContinuationDeliverer implements TaskContinuationDeliverer
         ConversationID: string;
         BranchID: string | null;
         OwnerUserID: string;
-        OriginDetail: MJConversationDetailEntity;
+        OriginDetail: MJConversationDetailEntityExtended;
         IsLatest: boolean;
     } | null> {
         const initialUser = this.resolveActingUser(fallbackOwnerUserId);
-        let detail = await provider.GetEntityObject<MJConversationDetailEntity>('MJ: Conversation Details', initialUser);
+        let detail = await provider.GetEntityObject<MJConversationDetailEntityExtended>('MJ: Conversation Details', initialUser);
         if (!(await detail.Load(conversationDetailID))) {
             return null;
         }
@@ -418,16 +441,20 @@ export class TaskGraphContinuationDeliverer implements TaskContinuationDeliverer
             ownerUserId = await this.lookupConversationOwnerId(detail.ConversationID, provider);
         }
         const resolvedOwnerUserId = ownerUserId || this.contextUser.ID;
-        const actingUser = this.resolveActingUser(resolvedOwnerUserId);
-        // `MJConversationDetailEntityExtended.Save()` refuses writes when the entity's context user
-        // is not the conversation owner (`this.contextUser` is the server system user). Re-bind
-        // `OriginDetail` to `actingUser` whenever `ownerUserId` was discovered after loading `detail`.
-        if (!UUIDsEqual(actingUser.ID, initialUser.ID)) {
-            const writableDetail = await provider.GetEntityObject<MJConversationDetailEntity>('MJ: Conversation Details', actingUser);
-            if (await writableDetail.Load(conversationDetailID)) {
-                detail = writableDetail;
+        if (!fallbackOwnerUserId && !UUIDsEqual(resolvedOwnerUserId, initialUser.ID)) {
+            const ownerUser = this.resolveActingUser(resolvedOwnerUserId);
+            if (!UUIDsEqual(ownerUser.ID, initialUser.ID)) {
+                const reloaded = await provider.GetEntityObject<MJConversationDetailEntityExtended>('MJ: Conversation Details', ownerUser);
+                if (await reloaded.Load(conversationDetailID)) {
+                    detail = reloaded;
+                }
             }
         }
+        // Mark the originating detail as server-authored when it is the workflow status or planning AI/error reply.
+        const role = detail.Role?.trim().toLowerCase();
+        if (!role || role === 'ai' || role === 'error') {
+            detail.MarkServerAuthoredReply();
+        }
         const branchId = detail.BranchID ?? null;
         const isLatest = detail.ConversationID
             ? await this.isLatestConversationMessage(detail.ConversationID, branchId, conversationDetailID, provider)
@@ -464,6 +491,7 @@ export class TaskGraphContinuationDeliverer implements TaskContinuationDeliverer
                     Fields: ['ID'],
                     OrderBy: '__mj_CreatedAt DESC',
                     MaxRows: 1,
+                    SkipTotalRowCount: true,
                     ResultType: 'simple',
                     BypassCache: true,
                 },
@@ -497,7 +525,12 @@ export class TaskGraphContinuationDeliverer implements TaskContinuationDeliverer
                     ? `${cleaned}\n\n${completionNote}`
                     : completionNote;
                 originDetail.Status = 'Complete';
-                await originDetail.Save();
+                if (!(await originDetail.Save())) {
+                    LogError(
+                        `[TaskGraphContinuationDeliverer] Could not update originating detail for "${workflowName}": ` +
+                        `${originDetail.LatestResult?.CompleteMessage ?? 'unknown error'}`
+                    );
+                }
             }
         } catch {
             // Non-fatal if origin detail note update fails.