@acorex-platform/framework-server 0.0.37 → 0.0.46

package/workflow/src/lib/runtime/workflow-engine.service.js

@@ -16,6 +16,7 @@ const workflow_expression_scope_service_1 = require("./workflow-expression-scope
 const workflow_execution_store_service_1 = require("./workflow-execution-store.service");
 const entity_workflow_info_sync_1 = require("./entity-workflow-info.sync");
 const sync_task_current_assignee_util_1 = require("./sync-task-current-assignee.util");
+const workflow_trigger_guard_1 = require("../middlewares/workflow-trigger-guard");
 const core_1 = require("@acorex-platform/framework-server/core");
 /** Task context key for composed human-task titles (workflow-management). */
 const AXP_WORKFLOW_TASK_CONTEXT_TITLE_PARTS_KEY = '_taskTitleParts';
@@ -64,6 +65,21 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
         }
         return { id: userId, title: userId, name: userId };
     }
+    /**
+     * Tenant/app stamp for engine upserts. `insertOneAsEngine` skips visibility
+     * create-stamp, so instances would otherwise be invisible to tenant queries.
+     */
+    getSessionScopeInfo() {
+        const tenantId = this.sessionService?.tenantId?.trim();
+        const applicationId = this.sessionService?.applicationId?.trim();
+        if (!tenantId && !applicationId) {
+            return undefined;
+        }
+        return {
+            ...(tenantId ? { tenantId } : {}),
+            ...(applicationId ? { applicationId } : {}),
+        };
+    }
     //#endregion
     //#region ----   Definition Loading   ----
     /**
@@ -316,176 +332,244 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
             entityRefId: entityRefId || null,
             entityRefType: entityRefType || null,
         };
-        await this.store.addInstance(instance);
-        console.log(`[BackendWorkflowEngineService] 💾 Stored workflow instance:`, {
-            id: instance.id,
-            definitionId: instance.definitionId,
-            name: instance.name,
-            correlationId: instance.correlationId,
-            entityRefId: instance.entityRefId,
-            entityRefType: instance.entityRefType,
-            status: instance.status,
-            subStatus: instance.subStatus,
-        });
-        // 🎯 Also store in entity service for entity-based access
-        await this.saveInstanceToEntityService(instance);
-        // Convert to instance state for response (async - needs bookmark lookup)
-        let state = await this.instanceToInstanceState(instance);
-        // 🎯 KEY LOGIC: Execute all backend activities until we reach a frontend activity
-        let currentActivity = firstActivity;
-        let executionCount = 0;
-        const maxExecutions = 500; // Prevent infinite loops
-        // Only last activity output is kept; each step overwrites it. Expression scope uses outputs = lastActivityOutput.
-        let lastActivityOutput = state.lastActivityOutput;
-        while (currentActivity && executionCount < maxExecutions) {
-            executionCount++;
-            const activityType = currentActivity.name;
-            if (request.workflowId === 'documentReview') {
-                console.log('[WFT-ENG] documentReview step', executionCount, 'activityId=', currentActivity.id, 'type=', activityType);
-            }
-            // Determine execution mode (async)
-            const executionMode = await this.determineExecutionMode(activityType, currentActivity);
-            // Get activity definition to retrieve taskType (taskType === 'human-task' → suspend for cartable)
-            const activityDef = await this.activityDefinitionService.getActivityByName(activityType);
-            let taskType = currentActivity.metadata?.['taskType'] ??
-                activityDef?.taskType ??
-                'ui-activity';
-            // Defensive: human-task and cartable must suspend for task board
-            if (this.isTaskBoardSuspendGraphActivity(activityType)) {
-                if (activityDef?.taskType === 'human-task') {
-                    taskType = 'human-task';
-                }
-                if (executionMode === 'backend') {
-                    console.warn(`[BackendWorkflowEngineService] ⚠️ ${activityType} had executionMode=backend (definition or cache). Forcing frontend so workflow suspends at this step.`, {
-                        activityId: currentActivity.id,
-                        definitionExecutionMode: activityDef?.executionMode,
-                        definitionTaskType: activityDef?.taskType,
-                    });
-                }
-            }
-            const effectiveExecutionMode = taskType === 'human-task' && executionMode === 'backend'
-                ? 'frontend'
-                : this.isTaskBoardSuspendGraphActivity(activityType) &&
-                    (activityDef?.taskType === 'human-task' ||
-                        taskType === 'human-task')
-                    ? executionMode === 'backend'
+        let stored = false;
+        try {
+            return await (0, workflow_trigger_guard_1.runInsideWorkflowEngine)(() => this.store.runWithoutPersist(async () => {
+                await this.store.addInstance(instance);
+                stored = true;
+                console.log(`[BackendWorkflowEngineService] 💾 Stored workflow instance:`, {
+                    id: instance.id,
+                    definitionId: instance.definitionId,
+                    name: instance.name,
+                    correlationId: instance.correlationId,
+                    entityRefId: instance.entityRefId,
+                    entityRefType: instance.entityRefType,
+                    status: instance.status,
+                    subStatus: instance.subStatus,
+                });
+                // Instance row is inserted once after the step loop, not on every activity.
+                // Convert to instance state for response (async - needs bookmark lookup)
+                let state = await this.instanceToInstanceState(instance);
+                // 🎯 KEY LOGIC: Execute all backend activities until we reach a frontend activity
+                let currentActivity = firstActivity;
+                let executionCount = 0;
+                const maxExecutions = 500; // Prevent infinite loops
+                // Only last activity output is kept; each step overwrites it. Expression scope uses outputs = lastActivityOutput.
+                let lastActivityOutput = state.lastActivityOutput;
+                while (currentActivity && executionCount < maxExecutions) {
+                    executionCount++;
+                    const activityType = currentActivity.name;
+                    if (request.workflowId === 'documentReview') {
+                        console.log('[WFT-ENG] documentReview step', executionCount, 'activityId=', currentActivity.id, 'type=', activityType);
+                    }
+                    // Determine execution mode (async)
+                    const executionMode = await this.determineExecutionMode(activityType, currentActivity);
+                    // Get activity definition to retrieve taskType (taskType === 'human-task' → suspend for cartable)
+                    const activityDef = await this.activityDefinitionService.getActivityByName(activityType);
+                    let taskType = currentActivity.metadata?.['taskType'] ??
+                        activityDef?.taskType ??
+                        'ui-activity';
+                    // Defensive: human-task and cartable must suspend for task board
+                    if (this.isTaskBoardSuspendGraphActivity(activityType)) {
+                        if (activityDef?.taskType === 'human-task') {
+                            taskType = 'human-task';
+                        }
+                        if (executionMode === 'backend') {
+                            console.warn(`[BackendWorkflowEngineService] ⚠️ ${activityType} had executionMode=backend (definition or cache). Forcing frontend so workflow suspends at this step.`, {
+                                activityId: currentActivity.id,
+                                definitionExecutionMode: activityDef?.executionMode,
+                                definitionTaskType: activityDef?.taskType,
+                            });
+                        }
+                    }
+                    const effectiveExecutionMode = taskType === 'human-task' && executionMode === 'backend'
                         ? 'frontend'
-                        : executionMode
-                    : executionMode;
-            // If frontend activity → stop and return as pendingTask
-            if (effectiveExecutionMode === 'frontend' ||
-                effectiveExecutionMode === 'both') {
-                const pendingTask = await this.createTaskFromActivity(currentActivity, state);
-                // Use local taskType (may be forced to human-task for workflow-activity:human-task) so bookmark and UI see correct type
-                const resolvedTaskTypeForBookmark = taskType === 'human-task' || pendingTask.taskType === 'human-task'
-                    ? 'human-task'
-                    : pendingTask.taskType;
-                // Extract assignment and task metadata from activity inputs (for human-task activities)
-                let bookmarkPayload = {
-                    activityType,
-                    activityName: currentActivity.name,
-                    taskToken: pendingTask.taskToken, // Store taskToken for resume
-                    taskType: resolvedTaskTypeForBookmark,
-                };
-                // For human-task activities, extract assignment and task metadata from inputs
-                if (resolvedTaskTypeForBookmark === 'human-task' && pendingTask.input) {
-                    const inputs = pendingTask.input;
-                    // Assignment metadata (normalize to array so task board filter works; expression may return single id)
-                    bookmarkPayload['assignedUserIds'] = this.normalizeUserIds(inputs['assignedUserIds']);
-                    bookmarkPayload['candidateUserIds'] = this.normalizeUserIds(inputs['candidateUserIds']);
-                    bookmarkPayload['candidateRoleIds'] = this.normalizeUserIds(inputs['candidateRoleIds']);
-                    // Task metadata
-                    bookmarkPayload['title'] = this.resolveHumanTaskBookmarkTitle(inputs, activityDef, currentActivity);
-                    bookmarkPayload['description'] = inputs['description'] || null;
-                    bookmarkPayload['priority'] = inputs['priority'] || 'Normal';
-                    bookmarkPayload['dueDate'] = inputs['dueDate'] || null;
-                    // UI configuration
-                    bookmarkPayload['layout'] = inputs['layout'] || null;
-                    bookmarkPayload['actions'] = inputs['actions'] || null;
-                    bookmarkPayload['context'] = inputs['context'] || {};
-                }
-                if (activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.cartable) {
-                    bookmarkPayload['assignedUserIds'] = [];
-                }
-                if (resolvedTaskTypeForBookmark === 'human-task') {
-                    const htInputs = pendingTask.input;
-                    this.logHumanTaskBookmarkAssignmentTrace({
-                        phase: 'engine-start',
+                        : this.isTaskBoardSuspendGraphActivity(activityType) &&
+                            (activityDef?.taskType === 'human-task' ||
+                                taskType === 'human-task')
+                            ? executionMode === 'backend'
+                                ? 'frontend'
+                                : executionMode
+                            : executionMode;
+                    // If frontend activity → stop and return as pendingTask
+                    if (effectiveExecutionMode === 'frontend' ||
+                        effectiveExecutionMode === 'both') {
+                        const pendingTask = await this.createTaskFromActivity(currentActivity, state);
+                        // Use local taskType (may be forced to human-task for workflow-activity:human-task) so bookmark and UI see correct type
+                        const resolvedTaskTypeForBookmark = taskType === 'human-task' || pendingTask.taskType === 'human-task'
+                            ? 'human-task'
+                            : pendingTask.taskType;
+                        // Extract assignment and task metadata from activity inputs (for human-task activities)
+                        let bookmarkPayload = {
+                            activityType,
+                            activityName: currentActivity.name,
+                            taskToken: pendingTask.taskToken, // Store taskToken for resume
+                            taskType: resolvedTaskTypeForBookmark,
+                        };
+                        // For human-task activities, extract assignment and task metadata from inputs
+                        if (resolvedTaskTypeForBookmark === 'human-task' && pendingTask.input) {
+                            const inputs = pendingTask.input;
+                            // Assignment metadata (normalize to array so task board filter works; expression may return single id)
+                            bookmarkPayload['assignedUserIds'] = this.normalizeUserIds(inputs['assignedUserIds']);
+                            bookmarkPayload['candidateUserIds'] = this.normalizeUserIds(inputs['candidateUserIds']);
+                            bookmarkPayload['candidateRoleIds'] = this.normalizeUserIds(inputs['candidateRoleIds']);
+                            // Task metadata
+                            bookmarkPayload['title'] = this.resolveHumanTaskBookmarkTitle(inputs, activityDef, currentActivity);
+                            bookmarkPayload['description'] = inputs['description'] || null;
+                            bookmarkPayload['priority'] = inputs['priority'] || 'Normal';
+                            bookmarkPayload['dueDate'] = inputs['dueDate'] || null;
+                            // UI configuration
+                            bookmarkPayload['layout'] = inputs['layout'] || null;
+                            bookmarkPayload['actions'] = inputs['actions'] || null;
+                            bookmarkPayload['context'] = inputs['context'] || {};
+                        }
+                        if (activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.cartable) {
+                            bookmarkPayload['assignedUserIds'] = [];
+                        }
+                        if (resolvedTaskTypeForBookmark === 'human-task') {
+                            const htInputs = pendingTask.input;
+                            this.logHumanTaskBookmarkAssignmentTrace({
+                                phase: 'engine-start',
+                                instanceId,
+                                workflowDefinitionName: workflow.name,
+                                activityId: currentActivity.id,
+                                activityType,
+                                rawAssignedUserIds: htInputs?.['assignedUserIds'],
+                                normalizedAssignedUserIds: bookmarkPayload['assignedUserIds'],
+                                variables: state.variables,
+                            });
+                        }
+                        const bookmarkId = await this.createBookmark(instanceId, currentActivity.id, 'user-task', bookmarkPayload);
+                        const isTaskBoardSuspend = this.isTaskBoardSuspendGraphActivity(activityType);
+                        if (isTaskBoardSuspend) {
+                            console.log('[WFT-ENG] task-board bookmark created instanceId=', instanceId, 'activityId=', currentActivity.id, 'bookmarkId=', bookmarkId, 'type=', activityType);
+                        }
+                        const newStatus = isTaskBoardSuspend ? 'suspended' : 'running';
+                        state = {
+                            ...state,
+                            lastActivityOutput,
+                            status: newStatus,
+                            currentStepId: currentActivity.id,
+                        };
+                        await this.updateInstanceFromState(instanceId, state);
+                        return {
+                            instanceId: instanceId,
+                            state,
+                            pendingTask,
+                            lastActivityOutput,
+                        };
+                    }
+                    const parallelWrites = await this.runIndependentEntityWriteBatch({
+                        workflow,
+                        connections,
+                        graph,
                         instanceId,
-                        workflowDefinitionName: workflow.name,
-                        activityId: currentActivity.id,
-                        activityType,
-                        rawAssignedUserIds: htInputs?.['assignedUserIds'],
-                        normalizedAssignedUserIds: bookmarkPayload['assignedUserIds'],
-                        variables: state.variables,
+                        activity: currentActivity,
+                        state,
+                        lastActivityOutput,
                     });
+                    if (parallelWrites) {
+                        state = parallelWrites.state;
+                        lastActivityOutput = parallelWrites.lastActivityOutput;
+                        executionCount += parallelWrites.executedCount - 1;
+                        if (!parallelWrites.nextActivity) {
+                            return {
+                                instanceId,
+                                state,
+                                pendingTask: null,
+                                lastActivityOutput,
+                            };
+                        }
+                        currentActivity = parallelWrites.nextActivity;
+                        continue;
+                    }
+                    // Backend activity → execute it
+                    const lastOutputBeforeBackend = lastActivityOutput;
+                    const executionResult = await this.executeBackendActivityLocally(currentActivity, state, lastActivityOutput);
+                    lastActivityOutput = executionResult.output;
+                    await this.maybeLinkCreatedEntityRecord(instanceId, currentActivity, state, lastOutputBeforeBackend, executionResult.output);
+                    // set-variable writes workflow variables directly into output map (no outputToVariables).
+                    const isSetVariableRun = currentActivity.name === 'workflow-activity:set-variable';
+                    const variableUpdates = isSetVariableRun
+                        ? executionResult.output
+                        : this.getVariableUpdatesFromOutput(workflow, currentActivity.id, executionResult.output);
+                    const outcome = Object.keys(executionResult.outcomes)[0] || 'Done';
+                    const sessionUser = this.getSessionUser();
+                    const backendStepAudit = {
+                        [`${currentActivity.id}_outcome`]: outcome,
+                        [`${currentActivity.id}_activityOutput`]: executionResult.output,
+                    };
+                    if (sessionUser?.id) {
+                        backendStepAudit[`${currentActivity.id}_completedByUserId`] =
+                            sessionUser.id;
+                        backendStepAudit[`${currentActivity.id}_completedByLabel`] =
+                            sessionUser.title || sessionUser.name || sessionUser.id;
+                    }
+                    else {
+                        backendStepAudit[`${currentActivity.id}_completedByLabel`] = 'System';
+                    }
+                    state = {
+                        ...state,
+                        variables: {
+                            ...state.variables,
+                            ...variableUpdates,
+                            ...backendStepAudit,
+                        },
+                        lastActivityOutput,
+                        currentStepId: currentActivity.id,
+                        lastUpdated: new Date(),
+                    };
+                    await this.updateInstanceFromState(instanceId, state);
+                    // Find next activity based on outcome
+                    const nextConnection = this.findWorkflowConnection(connections, currentActivity.id, outcome);
+                    if (!nextConnection) {
+                        // No next activity → workflow completed
+                        state = {
+                            ...state,
+                            status: 'completed',
+                            currentStepId: undefined,
+                            output: state.variables,
+                        };
+                        await this.updateInstanceFromState(instanceId, state);
+                        return {
+                            instanceId: instanceId,
+                            state,
+                            pendingTask: null,
+                            lastActivityOutput,
+                        };
+                    }
+                    // Find next activity
+                    const nextActivity = this.findActivityInGraph(graph, nextConnection.target.activtyName);
+                    if (!nextActivity) {
+                        console.error(`[BackendWorkflowEngineService] ❌ Next activity '${nextConnection.target.activtyName}' not found in graph`);
+                        state = {
+                            ...state,
+                            status: 'error',
+                            currentStepId: undefined,
+                        };
+                        await this.updateInstanceFromState(instanceId, state);
+                        throw new Error(`Next activity '${nextConnection.target.activtyName}' not found in workflow graph`);
+                    }
+                    currentActivity = nextActivity;
                 }
-                const bookmarkId = await this.createBookmark(instanceId, currentActivity.id, 'user-task', bookmarkPayload);
-                const isTaskBoardSuspend = this.isTaskBoardSuspendGraphActivity(activityType);
-                if (isTaskBoardSuspend) {
-                    console.log('[WFT-ENG] task-board bookmark created instanceId=', instanceId, 'activityId=', currentActivity.id, 'bookmarkId=', bookmarkId, 'type=', activityType);
+                // If we exit loop due to max executions, mark as error
+                if (executionCount >= maxExecutions) {
+                    console.error(`[BackendWorkflowEngineService] ❌ Maximum execution count (${maxExecutions}) reached - possible infinite loop`);
+                    state = {
+                        ...state,
+                        status: 'error',
+                        currentStepId: undefined,
+                    };
+                    await this.updateInstanceFromState(instanceId, state);
+                    throw new Error(`Workflow execution exceeded maximum steps (${maxExecutions}) - possible infinite loop`);
                 }
-                const newStatus = isTaskBoardSuspend ? 'suspended' : 'running';
-                state = {
-                    ...state,
-                    lastActivityOutput,
-                    status: newStatus,
-                    currentStepId: currentActivity.id,
-                };
-                await this.updateInstanceFromState(instanceId, state);
-                return {
-                    instanceId: instanceId,
-                    state,
-                    pendingTask,
-                    lastActivityOutput,
-                };
-            }
-            // Backend activity → execute it
-            const lastOutputBeforeBackend = lastActivityOutput;
-            const executionResult = await this.executeBackendActivityLocally(currentActivity, state, lastActivityOutput);
-            lastActivityOutput = executionResult.output;
-            await this.maybeLinkCreatedEntityRecord(instanceId, currentActivity, state, lastOutputBeforeBackend, executionResult.output);
-            // set-variable writes workflow variables directly into output map (no outputToVariables).
-            const isSetVariableRun = currentActivity.name === 'workflow-activity:set-variable';
-            const variableUpdates = isSetVariableRun
-                ? executionResult.output
-                : this.getVariableUpdatesFromOutput(workflow, currentActivity.id, executionResult.output);
-            const outcome = Object.keys(executionResult.outcomes)[0] || 'Done';
-            const sessionUser = this.getSessionUser();
-            const backendStepAudit = {
-                [`${currentActivity.id}_outcome`]: outcome,
-                [`${currentActivity.id}_activityOutput`]: executionResult.output,
-            };
-            if (sessionUser?.id) {
-                backendStepAudit[`${currentActivity.id}_completedByUserId`] =
-                    sessionUser.id;
-                backendStepAudit[`${currentActivity.id}_completedByLabel`] =
-                    sessionUser.title || sessionUser.name || sessionUser.id;
-            }
-            else {
-                backendStepAudit[`${currentActivity.id}_completedByLabel`] = 'System';
-            }
-            state = {
-                ...state,
-                variables: {
-                    ...state.variables,
-                    ...variableUpdates,
-                    ...backendStepAudit,
-                },
-                lastActivityOutput,
-                currentStepId: currentActivity.id,
-                lastUpdated: new Date(),
-            };
-            await this.updateInstanceFromState(instanceId, state);
-            // Find next activity based on outcome
-            const nextConnection = this.findWorkflowConnection(connections, currentActivity.id, outcome);
-            if (!nextConnection) {
-                // No next activity → workflow completed
+                // If we exit loop without frontend activity, workflow is complete
                 state = {
                     ...state,
                     status: 'completed',
                     currentStepId: undefined,
                     output: state.variables,
+                    lastActivityOutput,
                 };
                 await this.updateInstanceFromState(instanceId, state);
                 return {
@@ -494,47 +578,16 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
                     pendingTask: null,
                     lastActivityOutput,
                 };
-            }
-            // Find next activity
-            const nextActivity = this.findActivityInGraph(graph, nextConnection.target.activtyName);
-            if (!nextActivity) {
-                console.error(`[BackendWorkflowEngineService] ❌ Next activity '${nextConnection.target.activtyName}' not found in graph`);
-                state = {
-                    ...state,
-                    status: 'error',
-                    currentStepId: undefined,
-                };
-                await this.updateInstanceFromState(instanceId, state);
-                throw new Error(`Next activity '${nextConnection.target.activtyName}' not found in workflow graph`);
-            }
-            currentActivity = nextActivity;
+            }));
         }
-        // If we exit loop due to max executions, mark as error
-        if (executionCount >= maxExecutions) {
-            console.error(`[BackendWorkflowEngineService] ❌ Maximum execution count (${maxExecutions}) reached - possible infinite loop`);
-            state = {
-                ...state,
-                status: 'error',
-                currentStepId: undefined,
-            };
-            await this.updateInstanceFromState(instanceId, state);
-            throw new Error(`Workflow execution exceeded maximum steps (${maxExecutions}) - possible infinite loop`);
+        finally {
+            if (stored) {
+                const current = await this.store.getInstance(instanceId);
+                if (current) {
+                    await this.writeInstanceProjection(current, workflow, true);
+                }
+            }
         }
-        // If we exit loop without frontend activity, workflow is complete
-        state = {
-            ...state,
-            status: 'completed',
-            currentStepId: undefined,
-            output: state.variables,
-            lastActivityOutput,
-        };
-        await this.updateInstanceFromState(instanceId, state);
-        return {
-            instanceId: instanceId,
-            state,
-            pendingTask: null,
-            lastActivityOutput,
-        };
     }
     /**
      * Terminates a non-finished workflow instance (e.g. superseded lifecycle run).
@@ -798,286 +851,357 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
      * 7. Returns either pendingTask (with new secure token) or completed status
      */
     async resume(request) {
-        console.log(`[BackendWorkflowEngineService] 🔄 Resuming workflow: ${request.instanceId}`, {
-            stepId: request.stepId,
-            outcome: request.outcome,
-        });
-        // Get current state
-        let state = await this.getState({
-            instanceId: request.instanceId,
-        });
-        if (!state) {
-            throw new Error(`Workflow instance not found: ${request.instanceId}`);
-        }
-        if (state.status !== 'suspended') {
-            throw new Error(`Cannot resume workflow with status: ${state.status}. Expected: suspended`);
-        }
-        // Validate task token (secure validation). If token missing/expired, allow resume when instance is suspended and bookmark for this step exists (task board tasks may wait days).
-        const tokenValid = request.taskToken &&
-            this.validateTaskToken(request.taskToken, request.instanceId, request.stepId);
-        if (!tokenValid) {
-            const allowedByBookmark = await this.canResumeByBookmark(request.instanceId, request.stepId);
-            if (!allowedByBookmark) {
-                throw new Error(request.taskToken
-                    ? 'Invalid or expired task token'
-                    : 'Missing taskToken for resume operation');
-            }
-            console.log(`[BackendWorkflowEngineService] ✅ Resume allowed by bookmark (token expired/missing): ${request.instanceId}:${request.stepId}`);
-        }
-        // Verify stepId matches current step
-        if (state.currentStepId !== request.stepId) {
-            throw new Error(`Step mismatch: expected '${state.currentStepId}', got '${request.stepId}'`);
-        }
-        // Enforce claim / assignee for task-board bookmarks
-        const resumeBookmarks = await this.store.getBookmarksByInstanceAndActivity(request.instanceId, request.stepId, true);
-        const resumePayloadSource = resumeBookmarks[0];
-        const resumePayload = resumePayloadSource
-            ? this.parseBookmarkPayloadJson(resumePayloadSource.payloadJson)
-            : null;
-        if (resumePayload) {
-            const payloadActivityType = String(resumePayload['activityType'] ?? '');
-            const assigned = this.normalizeUserIds(resumePayload['assignedUserIds']) ?? [];
-            const candidates = this.normalizeUserIds(resumePayload['candidateUserIds']) ?? [];
-            const isCartablePayload = payloadActivityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.cartable;
-            const isPooledHumanPayload = payloadActivityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.humanTask &&
-                assigned.length === 0 &&
-                candidates.length > 0;
-            if (isCartablePayload || isPooledHumanPayload) {
-                if (assigned.length === 0) {
-                    throw new workflow_engine_errors_1.AXPWorkflowEngineError('Claim the task before completing it', workflow_engine_errors_1.AXP_WORKFLOW_ERROR_CODES.CLAIM_REQUIRED);
+        let dirty = false;
+        let workflowForFlush = null;
+        try {
+            return await (0, workflow_trigger_guard_1.runInsideWorkflowEngine)(() => this.store.runWithoutPersist(async () => {
+                console.log(`[BackendWorkflowEngineService] 🔄 Resuming workflow: ${request.instanceId}`, {
+                    stepId: request.stepId,
+                    outcome: request.outcome,
+                });
+                // Get current state
+                let state = await this.getState({
+                    instanceId: request.instanceId,
+                });
+                if (!state) {
+                    throw new Error(`Workflow instance not found: ${request.instanceId}`);
                 }
-            }
-            if (assigned.length > 0) {
-                const uid = this.getSessionUser()?.id;
-                if (uid && !assigned.includes(String(uid))) {
-                    throw new workflow_engine_errors_1.AXPWorkflowEngineError('Only the assigned user can complete this task', workflow_engine_errors_1.AXP_WORKFLOW_ERROR_CODES.TASK_NOT_ASSIGNEE, { assignedUserIds: assigned });
+                if (state.status !== 'suspended') {
+                    throw new Error(`Cannot resume workflow with status: ${state.status}. Expected: suspended`);
                 }
-            }
-        }
-        // Mark bookmark as consumed
-        await this.consumeBookmark(request.instanceId, request.stepId);
-        // Remove task token after validation (prevent replay); no-op if token was already expired/missing
-        if (request.taskToken) {
-            this.removeTaskToken(request.taskToken);
-        }
-        // Load workflow definition using definition loader (queries by name field)
-        const workflow = await this.getDefinition(state.workflowId);
-        if (!workflow) {
-            console.error(`[BackendWorkflowRuntime] ❌ Workflow definition not found: ${state.workflowId}`);
-            throw new Error(`Workflow definition not found: ${state.workflowId}`);
-        }
-        const connections = workflow.graph.connections || [];
-        // Resolve allowed outcomes from workflow definition (e.g. human-task from instance inputs.actions)
-        const allowedOutcomes = await this.getActivityAllowedOutcomes(workflow, request.stepId);
-        const outcome = this.normalizeOutcome(request.outcome ?? 'Done', allowedOutcomes, request.stepId);
-        // Apply frontend output: last activity output for expressions (outputs.*); outcome/output/completer go into variables for audit UI
-        const userInput = request.userInput || {};
-        const lastActivityOutput = userInput;
-        const variableUpdatesResume = this.getVariableUpdatesFromOutput(workflow, request.stepId, userInput);
-        const sessionUser = this.getSessionUser();
-        const completerId = sessionUser?.id;
-        const completerLabel = sessionUser?.title ?? sessionUser?.name ?? completerId;
-        const resumeVariablePatch = {
-            ...variableUpdatesResume,
-            [`${request.stepId}_outcome`]: outcome,
-            [`${request.stepId}_activityOutput`]: userInput,
-        };
-        if (completerId) {
-            resumeVariablePatch[`${request.stepId}_completedByUserId`] = completerId;
-        }
-        if (completerLabel) {
-            resumeVariablePatch[`${request.stepId}_completedByLabel`] =
-                completerLabel;
-        }
-        else {
-            resumeVariablePatch[`${request.stepId}_completedByLabel`] = completerId
-                ? String(completerId)
-                : 'System';
-        }
-        state = {
-            ...state,
-            variables: {
-                ...state.variables,
-                ...resumeVariablePatch,
-            },
-            lastActivityOutput,
-            lastUpdated: new Date(),
-        };
-        // Find next activity based on outcome from frontend (use normalized outcome)
-        const nextConnection = this.findWorkflowConnection(connections, request.stepId, outcome);
-        if (!nextConnection) {
-            // No next activity → workflow completed
-            console.log('[AXCWorkflowExecutionService] ✅ No next activity found - workflow completed');
-            state = {
-                ...state,
-                status: 'completed',
-                currentStepId: undefined,
-                output: state.variables,
-                lastActivityOutput,
-            };
-            console.log('[AXCWorkflowExecutionService] 📝 Updating instance to completed state');
-            await this.updateInstanceFromState(request.instanceId, state);
-            return {
-                output: { outcome, userInput: request.userInput },
-                outcomes: { [outcome]: true },
-                nextTask: null,
-                state,
-            };
-        }
-        // 🎯 KEY LOGIC: Execute all backend activities until we reach next frontend activity
-        let currentActivity = this.findActivityInGraph(workflow.graph, nextConnection.target.activtyName);
-        let lastActivityOutputResume = lastActivityOutput;
-        let executionCount = 0;
-        const maxExecutions = 500;
-        if (!currentActivity) {
-            console.error(`[BackendWorkflowEngineService] ❌ Next activity '${nextConnection.target.activtyName}' not found in graph`);
-            state = {
-                ...state,
-                status: 'error',
-                currentStepId: undefined,
-            };
-            await this.updateInstanceFromState(request.instanceId, state);
-            throw new Error(`Next activity '${nextConnection.target.activtyName}' not found in workflow graph`);
-        }
-        while (currentActivity && executionCount < maxExecutions) {
-            executionCount++;
-            // Map activity name (registry key) to activity type
-            const activityType = currentActivity.name;
-            // Determine execution mode (async)
-            const executionMode = await this.determineExecutionMode(activityType, currentActivity);
-            // Get activity definition to retrieve taskType (taskType === 'human-task' → suspend for cartable)
-            const activityDef = await this.activityDefinitionService.getActivityByName(activityType);
-            let taskType = currentActivity.metadata?.['taskType'] ??
-                activityDef?.taskType ??
-                'ui-activity';
-            // Defensive: human-task and cartable must suspend (same as run())
-            if (this.isTaskBoardSuspendGraphActivity(activityType)) {
-                if (activityDef?.taskType === 'human-task')
-                    taskType = 'human-task';
-            }
-            const effectiveExecutionModeResume = taskType === 'human-task' && executionMode === 'backend'
-                ? 'frontend'
-                : this.isTaskBoardSuspendGraphActivity(activityType) &&
-                    (activityDef?.taskType === 'human-task' ||
-                        taskType === 'human-task')
-                    ? executionMode === 'backend'
-                        ? 'frontend'
-                        : executionMode
-                    : executionMode;
-            // If frontend activity → stop and return as pendingTask
-            if (effectiveExecutionModeResume === 'frontend' ||
-                effectiveExecutionModeResume === 'both') {
-                const pendingTask = await this.createTaskFromActivity(currentActivity, state);
-                // Extract assignment and task metadata from activity inputs (for human-task activities)
-                const resolvedTaskType = taskType === 'human-task' || pendingTask.taskType === 'human-task'
-                    ? 'human-task'
-                    : pendingTask.taskType;
-                let bookmarkPayload = {
-                    activityType,
-                    activityName: currentActivity.name,
-                    taskToken: pendingTask.taskToken, // Store taskToken for resume
-                    taskType: resolvedTaskType, // Add taskType to payload
+                // Validate task token (secure validation). If token missing/expired, allow resume when instance is suspended and bookmark for this step exists (task board tasks may wait days).
+                const tokenValid = request.taskToken &&
+                    this.validateTaskToken(request.taskToken, request.instanceId, request.stepId);
+                if (!tokenValid) {
+                    const allowedByBookmark = await this.canResumeByBookmark(request.instanceId, request.stepId);
+                    if (!allowedByBookmark) {
+                        throw new Error(request.taskToken
+                            ? 'Invalid or expired task token'
+                            : 'Missing taskToken for resume operation');
+                    }
+                    console.log(`[BackendWorkflowEngineService] ✅ Resume allowed by bookmark (token expired/missing): ${request.instanceId}:${request.stepId}`);
+                }
+                // Verify stepId matches current step
+                if (state.currentStepId !== request.stepId) {
+                    throw new Error(`Step mismatch: expected '${state.currentStepId}', got '${request.stepId}'`);
+                }
+                // Enforce claim / assignee for task-board bookmarks
+                const resumeBookmarks = await this.store.getBookmarksByInstanceAndActivity(request.instanceId, request.stepId, true);
+                const resumePayloadSource = resumeBookmarks[0];
+                const resumePayload = resumePayloadSource
+                    ? this.parseBookmarkPayloadJson(resumePayloadSource.payloadJson)
+                    : null;
+                if (resumePayload) {
+                    const payloadActivityType = String(resumePayload['activityType'] ?? '');
+                    const assigned = this.normalizeUserIds(resumePayload['assignedUserIds']) ?? [];
+                    const candidates = this.normalizeUserIds(resumePayload['candidateUserIds']) ?? [];
+                    const isCartablePayload = payloadActivityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.cartable;
+                    const isPooledHumanPayload = payloadActivityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.humanTask &&
+                        assigned.length === 0 &&
+                        candidates.length > 0;
+                    if (isCartablePayload || isPooledHumanPayload) {
+                        if (assigned.length === 0) {
+                            throw new workflow_engine_errors_1.AXPWorkflowEngineError('Claim the task before completing it', workflow_engine_errors_1.AXP_WORKFLOW_ERROR_CODES.CLAIM_REQUIRED);
+                        }
+                    }
+                    if (assigned.length > 0) {
+                        const uid = this.getSessionUser()?.id;
+                        if (uid && !assigned.includes(String(uid))) {
+                            throw new workflow_engine_errors_1.AXPWorkflowEngineError('Only the assigned user can complete this task', workflow_engine_errors_1.AXP_WORKFLOW_ERROR_CODES.TASK_NOT_ASSIGNEE, { assignedUserIds: assigned });
+                        }
+                    }
+                }
+                // Mark bookmark as consumed
+                dirty = true;
+                await this.consumeBookmark(request.instanceId, request.stepId);
+                // Remove task token after validation (prevent replay); no-op if token was already expired/missing
+                if (request.taskToken) {
+                    this.removeTaskToken(request.taskToken);
+                }
+                // Load workflow definition using definition loader (queries by name field)
+                const workflow = await this.getDefinition(state.workflowId);
+                workflowForFlush = workflow;
+                if (!workflow) {
+                    console.error(`[BackendWorkflowRuntime] ❌ Workflow definition not found: ${state.workflowId}`);
+                    throw new Error(`Workflow definition not found: ${state.workflowId}`);
+                }
+                const connections = workflow.graph.connections || [];
+                // Resolve allowed outcomes from workflow definition (e.g. human-task from instance inputs.actions)
+                const allowedOutcomes = await this.getActivityAllowedOutcomes(workflow, request.stepId);
+                const outcome = this.normalizeOutcome(request.outcome ?? 'Done', allowedOutcomes, request.stepId);
+                // Apply frontend output: last activity output for expressions (outputs.*); outcome/output/completer go into variables for audit UI
+                const userInput = request.userInput || {};
+                const lastActivityOutput = userInput;
+                const variableUpdatesResume = this.getVariableUpdatesFromOutput(workflow, request.stepId, userInput);
+                const sessionUser = this.getSessionUser();
+                const completerId = sessionUser?.id;
+                const completerLabel = sessionUser?.title ?? sessionUser?.name ?? completerId;
+                const resumeVariablePatch = {
+                    ...variableUpdatesResume,
+                    [`${request.stepId}_outcome`]: outcome,
+                    [`${request.stepId}_activityOutput`]: userInput,
                 };
-                // For human-task activities, extract assignment and task metadata from inputs
-                if (resolvedTaskType === 'human-task' && pendingTask.input) {
-                    const inputs = pendingTask.input;
-                    // Assignment metadata (normalize to array; expression may return single id e.g. {{ variables.managerId }})
-                    bookmarkPayload['assignedUserIds'] = this.normalizeUserIds(inputs['assignedUserIds']);
-                    bookmarkPayload['candidateUserIds'] = this.normalizeUserIds(inputs['candidateUserIds']);
-                    bookmarkPayload['candidateRoleIds'] = this.normalizeUserIds(inputs['candidateRoleIds']);
-                    // Task metadata
-                    bookmarkPayload['title'] = this.resolveHumanTaskBookmarkTitle(inputs, activityDef, currentActivity);
-                    bookmarkPayload['description'] = inputs['description'] || null;
-                    bookmarkPayload['priority'] = inputs['priority'] || 'Normal';
-                    bookmarkPayload['dueDate'] = inputs['dueDate'] || null;
-                    // UI configuration
-                    bookmarkPayload['layout'] = inputs['layout'] || null;
-                    bookmarkPayload['actions'] = inputs['actions'] || null;
-                    bookmarkPayload['context'] = inputs['context'] || {};
+                if (completerId) {
+                    resumeVariablePatch[`${request.stepId}_completedByUserId`] = completerId;
                 }
-                if (activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.cartable) {
-                    bookmarkPayload['assignedUserIds'] = [];
+                if (completerLabel) {
+                    resumeVariablePatch[`${request.stepId}_completedByLabel`] =
+                        completerLabel;
                 }
-                if (resolvedTaskType === 'human-task') {
-                    const htInputs = pendingTask.input;
-                    this.logHumanTaskBookmarkAssignmentTrace({
-                        phase: 'engine-resume',
-                        instanceId: request.instanceId,
-                        workflowDefinitionName: workflow.name,
-                        activityId: currentActivity.id,
-                        activityType,
-                        rawAssignedUserIds: htInputs?.['assignedUserIds'],
-                        normalizedAssignedUserIds: bookmarkPayload['assignedUserIds'],
-                        variables: state.variables,
-                    });
+                else {
+                    resumeVariablePatch[`${request.stepId}_completedByLabel`] = completerId
+                        ? String(completerId)
+                        : 'System';
                 }
-                // Create bookmark for frontend activity
-                // Store all metadata in bookmark payload (replaces Work Item)
-                await this.createBookmark(request.instanceId, currentActivity.id, 'user-task', bookmarkPayload);
-                // Note: Work Item creation removed - all metadata stored in bookmark payload
-                // Set status: task-board activities → suspended, else running (form/popup)
-                const isTaskBoardSuspendResume = this.isTaskBoardSuspendGraphActivity(activityType);
                 state = {
                     ...state,
-                    lastActivityOutput: lastActivityOutputResume,
-                    status: isTaskBoardSuspendResume ? 'suspended' : 'running',
-                    currentStepId: currentActivity.id,
-                };
-                await this.updateInstanceFromState(request.instanceId, state);
-                console.log(`[BackendWorkflowEngineService] ✅ Workflow suspended at frontend activity: ${activityType} (taskType: ${taskType}, status: ${state.status})`);
-                return {
-                    output: { outcome, userInput: request.userInput },
-                    outcomes: { [outcome]: true },
-                    nextTask: pendingTask,
-                    state,
+                    variables: {
+                        ...state.variables,
+                        ...resumeVariablePatch,
+                    },
+                    lastActivityOutput,
+                    lastUpdated: new Date(),
                 };
-            }
-            // Backend activity → execute it
-            console.log(`[BackendWorkflowEngineService] ⚙️ Executing backend activity '${currentActivity.name || currentActivity.id}' (${activityType})`);
-            const lastOutputBeforeBackendResume = lastActivityOutputResume;
-            const executionResult = await this.executeBackendActivityLocally(currentActivity, state, lastActivityOutputResume);
-            lastActivityOutputResume = executionResult.output;
-            await this.maybeLinkCreatedEntityRecord(request.instanceId, currentActivity, state, lastOutputBeforeBackendResume, executionResult.output);
-            const isSetVariable = currentActivity.name === 'workflow-activity:set-variable';
-            const variableUpdatesResumeLoop = isSetVariable
-                ? executionResult.output
-                : this.getVariableUpdatesFromOutput(workflow, currentActivity.id, executionResult.output);
-            const backendOutcome = Object.keys(executionResult.outcomes)[0] || 'Done';
-            const sessionUserResume = this.getSessionUser();
-            const backendAuditResume = {
-                [`${currentActivity.id}_outcome`]: backendOutcome,
-                [`${currentActivity.id}_activityOutput`]: executionResult.output,
-            };
-            if (sessionUserResume?.id) {
-                backendAuditResume[`${currentActivity.id}_completedByUserId`] =
-                    sessionUserResume.id;
-                backendAuditResume[`${currentActivity.id}_completedByLabel`] =
-                    sessionUserResume.title ||
-                        sessionUserResume.name ||
-                        sessionUserResume.id;
-            }
-            else {
-                backendAuditResume[`${currentActivity.id}_completedByLabel`] = 'System';
-            }
-            state = {
-                ...state,
-                variables: {
-                    ...state.variables,
-                    ...(typeof variableUpdatesResumeLoop === 'object' &&
-                        variableUpdatesResumeLoop !== null
-                        ? variableUpdatesResumeLoop
-                        : {}),
-                    ...backendAuditResume,
-                },
-                lastActivityOutput: lastActivityOutputResume,
-                currentStepId: currentActivity.id,
-                lastUpdated: new Date(),
-            };
-            await this.updateInstanceFromState(request.instanceId, state);
-            // Find next activity based on outcome (backend execution result)
-            const nextConn = this.findWorkflowConnection(connections, currentActivity.id, backendOutcome);
-            if (!nextConn) {
-                // No next activity → workflow completed
+                // Find next activity based on outcome from frontend (use normalized outcome)
+                const nextConnection = this.findWorkflowConnection(connections, request.stepId, outcome);
+                if (!nextConnection) {
+                    // No next activity → workflow completed
+                    console.log('[AXCWorkflowExecutionService] ✅ No next activity found - workflow completed');
+                    state = {
+                        ...state,
+                        status: 'completed',
+                        currentStepId: undefined,
+                        output: state.variables,
+                        lastActivityOutput,
+                    };
+                    console.log('[AXCWorkflowExecutionService] 📝 Updating instance to completed state');
+                    await this.updateInstanceFromState(request.instanceId, state);
+                    return {
+                        output: { outcome, userInput: request.userInput },
+                        outcomes: { [outcome]: true },
+                        nextTask: null,
+                        state,
+                    };
+                }
+                // 🎯 KEY LOGIC: Execute all backend activities until we reach next frontend activity
+                let currentActivity = this.findActivityInGraph(workflow.graph, nextConnection.target.activtyName);
+                let lastActivityOutputResume = lastActivityOutput;
+                let executionCount = 0;
+                const maxExecutions = 500;
+                if (!currentActivity) {
+                    console.error(`[BackendWorkflowEngineService] ❌ Next activity '${nextConnection.target.activtyName}' not found in graph`);
+                    state = {
+                        ...state,
+                        status: 'error',
+                        currentStepId: undefined,
+                    };
+                    await this.updateInstanceFromState(request.instanceId, state);
+                    throw new Error(`Next activity '${nextConnection.target.activtyName}' not found in workflow graph`);
+                }
+                while (currentActivity && executionCount < maxExecutions) {
+                    executionCount++;
+                    // Map activity name (registry key) to activity type
+                    const activityType = currentActivity.name;
+                    // Determine execution mode (async)
+                    const executionMode = await this.determineExecutionMode(activityType, currentActivity);
+                    // Get activity definition to retrieve taskType (taskType === 'human-task' → suspend for cartable)
+                    const activityDef = await this.activityDefinitionService.getActivityByName(activityType);
+                    let taskType = currentActivity.metadata?.['taskType'] ??
+                        activityDef?.taskType ??
+                        'ui-activity';
+                    // Defensive: human-task and cartable must suspend (same as run())
+                    if (this.isTaskBoardSuspendGraphActivity(activityType)) {
+                        if (activityDef?.taskType === 'human-task')
+                            taskType = 'human-task';
+                    }
+                    const effectiveExecutionModeResume = taskType === 'human-task' && executionMode === 'backend'
+                        ? 'frontend'
+                        : this.isTaskBoardSuspendGraphActivity(activityType) &&
+                            (activityDef?.taskType === 'human-task' ||
+                                taskType === 'human-task')
+                            ? executionMode === 'backend'
+                                ? 'frontend'
+                                : executionMode
+                            : executionMode;
+                    // If frontend activity → stop and return as pendingTask
+                    if (effectiveExecutionModeResume === 'frontend' ||
+                        effectiveExecutionModeResume === 'both') {
+                        const pendingTask = await this.createTaskFromActivity(currentActivity, state);
+                        // Extract assignment and task metadata from activity inputs (for human-task activities)
+                        const resolvedTaskType = taskType === 'human-task' || pendingTask.taskType === 'human-task'
+                            ? 'human-task'
+                            : pendingTask.taskType;
+                        let bookmarkPayload = {
+                            activityType,
+                            activityName: currentActivity.name,
+                            taskToken: pendingTask.taskToken, // Store taskToken for resume
+                            taskType: resolvedTaskType, // Add taskType to payload
+                        };
+                        // For human-task activities, extract assignment and task metadata from inputs
+                        if (resolvedTaskType === 'human-task' && pendingTask.input) {
+                            const inputs = pendingTask.input;
+                            // Assignment metadata (normalize to array; expression may return single id e.g. {{ variables.managerId }})
+                            bookmarkPayload['assignedUserIds'] = this.normalizeUserIds(inputs['assignedUserIds']);
+                            bookmarkPayload['candidateUserIds'] = this.normalizeUserIds(inputs['candidateUserIds']);
+                            bookmarkPayload['candidateRoleIds'] = this.normalizeUserIds(inputs['candidateRoleIds']);
+                            // Task metadata
+                            bookmarkPayload['title'] = this.resolveHumanTaskBookmarkTitle(inputs, activityDef, currentActivity);
+                            bookmarkPayload['description'] = inputs['description'] || null;
+                            bookmarkPayload['priority'] = inputs['priority'] || 'Normal';
+                            bookmarkPayload['dueDate'] = inputs['dueDate'] || null;
+                            // UI configuration
+                            bookmarkPayload['layout'] = inputs['layout'] || null;
+                            bookmarkPayload['actions'] = inputs['actions'] || null;
+                            bookmarkPayload['context'] = inputs['context'] || {};
+                        }
+                        if (activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.cartable) {
+                            bookmarkPayload['assignedUserIds'] = [];
+                        }
+                        if (resolvedTaskType === 'human-task') {
+                            const htInputs = pendingTask.input;
+                            this.logHumanTaskBookmarkAssignmentTrace({
+                                phase: 'engine-resume',
+                                instanceId: request.instanceId,
+                                workflowDefinitionName: workflow.name,
+                                activityId: currentActivity.id,
+                                activityType,
+                                rawAssignedUserIds: htInputs?.['assignedUserIds'],
+                                normalizedAssignedUserIds: bookmarkPayload['assignedUserIds'],
+                                variables: state.variables,
+                            });
+                        }
+                        // Create bookmark for frontend activity
+                        // Store all metadata in bookmark payload (replaces Work Item)
+                        await this.createBookmark(request.instanceId, currentActivity.id, 'user-task', bookmarkPayload);
+                        // Note: Work Item creation removed - all metadata stored in bookmark payload
+                        // Set status: task-board activities → suspended, else running (form/popup)
+                        const isTaskBoardSuspendResume = this.isTaskBoardSuspendGraphActivity(activityType);
+                        state = {
+                            ...state,
+                            lastActivityOutput: lastActivityOutputResume,
+                            status: isTaskBoardSuspendResume ? 'suspended' : 'running',
+                            currentStepId: currentActivity.id,
+                        };
+                        await this.updateInstanceFromState(request.instanceId, state);
+                        console.log(`[BackendWorkflowEngineService] ✅ Workflow suspended at frontend activity: ${activityType} (taskType: ${taskType}, status: ${state.status})`);
+                        return {
+                            output: { outcome, userInput: request.userInput },
+                            outcomes: { [outcome]: true },
+                            nextTask: pendingTask,
+                            state,
+                        };
+                    }
+                    const parallelWrites = await this.runIndependentEntityWriteBatch({
+                        workflow,
+                        connections,
+                        graph: workflow.graph,
+                        instanceId: request.instanceId,
+                        activity: currentActivity,
+                        state,
+                        lastActivityOutput: lastActivityOutputResume,
+                    });
+                    if (parallelWrites) {
+                        state = parallelWrites.state;
+                        lastActivityOutputResume = parallelWrites.lastActivityOutput;
+                        executionCount += parallelWrites.executedCount - 1;
+                        if (!parallelWrites.nextActivity) {
+                            return {
+                                output: state.variables,
+                                outcomes: { Done: true },
+                                nextTask: null,
+                                state,
+                            };
+                        }
+                        currentActivity = parallelWrites.nextActivity;
+                        continue;
+                    }
+                    // Backend activity → execute it
+                    console.log(`[BackendWorkflowEngineService] ⚙️ Executing backend activity '${currentActivity.name || currentActivity.id}' (${activityType})`);
+                    const lastOutputBeforeBackendResume = lastActivityOutputResume;
+                    const executionResult = await this.executeBackendActivityLocally(currentActivity, state, lastActivityOutputResume);
+                    lastActivityOutputResume = executionResult.output;
+                    await this.maybeLinkCreatedEntityRecord(request.instanceId, currentActivity, state, lastOutputBeforeBackendResume, executionResult.output);
+                    const isSetVariable = currentActivity.name === 'workflow-activity:set-variable';
+                    const variableUpdatesResumeLoop = isSetVariable
+                        ? executionResult.output
+                        : this.getVariableUpdatesFromOutput(workflow, currentActivity.id, executionResult.output);
+                    const backendOutcome = Object.keys(executionResult.outcomes)[0] || 'Done';
+                    const sessionUserResume = this.getSessionUser();
+                    const backendAuditResume = {
+                        [`${currentActivity.id}_outcome`]: backendOutcome,
+                        [`${currentActivity.id}_activityOutput`]: executionResult.output,
+                    };
+                    if (sessionUserResume?.id) {
+                        backendAuditResume[`${currentActivity.id}_completedByUserId`] =
+                            sessionUserResume.id;
+                        backendAuditResume[`${currentActivity.id}_completedByLabel`] =
+                            sessionUserResume.title ||
+                                sessionUserResume.name ||
+                                sessionUserResume.id;
+                    }
+                    else {
+                        backendAuditResume[`${currentActivity.id}_completedByLabel`] = 'System';
+                    }
+                    state = {
+                        ...state,
+                        variables: {
+                            ...state.variables,
+                            ...(typeof variableUpdatesResumeLoop === 'object' &&
+                                variableUpdatesResumeLoop !== null
+                                ? variableUpdatesResumeLoop
+                                : {}),
+                            ...backendAuditResume,
+                        },
+                        lastActivityOutput: lastActivityOutputResume,
+                        currentStepId: currentActivity.id,
+                        lastUpdated: new Date(),
+                    };
+                    await this.updateInstanceFromState(request.instanceId, state);
+                    // Find next activity based on outcome (backend execution result)
+                    const nextConn = this.findWorkflowConnection(connections, currentActivity.id, backendOutcome);
+                    if (!nextConn) {
+                        // No next activity → workflow completed
+                        state = {
+                            ...state,
+                            status: 'completed',
+                            currentStepId: undefined,
+                            output: state.variables,
+                            lastActivityOutput: lastActivityOutputResume,
+                        };
+                        await this.updateInstanceFromState(request.instanceId, state);
+                        return {
+                            output: state.variables,
+                            outcomes: { Done: true },
+                            nextTask: null,
+                            state,
+                        };
+                    }
+                    // Find next activity
+                    const nextActivity = this.findActivityInGraph(workflow.graph, nextConn.target.activtyName);
+                    if (!nextActivity) {
+                        console.error(`[BackendWorkflowEngineService] ❌ Next activity '${nextConn.target.activtyName}' not found in graph`);
+                        state = {
+                            ...state,
+                            status: 'error',
+                            currentStepId: undefined,
+                        };
+                        await this.updateInstanceFromState(request.instanceId, state);
+                        throw new Error(`Next activity '${nextConn.target.activtyName}' not found in workflow graph`);
+                    }
+                    currentActivity = nextActivity;
+                }
+                // If we exit loop due to max executions, mark as error
+                if (executionCount >= maxExecutions) {
+                    console.error(`[BackendWorkflowEngineService] ❌ Maximum execution count (${maxExecutions}) reached - possible infinite loop`);
+                    state = {
+                        ...state,
+                        status: 'error',
+                        currentStepId: undefined,
+                    };
+                    await this.updateInstanceFromState(request.instanceId, state);
+                    throw new Error(`Workflow execution exceeded maximum steps (${maxExecutions}) - possible infinite loop`);
+                }
+                // If we exit loop, workflow is complete
                 state = {
                     ...state,
                     status: 'completed',
@@ -1092,47 +1216,16 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
                     nextTask: null,
                     state,
                 };
-            }
-            // Find next activity
-            const nextActivity = this.findActivityInGraph(workflow.graph, nextConn.target.activtyName);
-            if (!nextActivity) {
-                console.error(`[BackendWorkflowEngineService] ❌ Next activity '${nextConn.target.activtyName}' not found in graph`);
-                state = {
-                    ...state,
-                    status: 'error',
-                    currentStepId: undefined,
-                };
-                await this.updateInstanceFromState(request.instanceId, state);
-                throw new Error(`Next activity '${nextConn.target.activtyName}' not found in workflow graph`);
-            }
-            currentActivity = nextActivity;
+            }));
         }
-        // If we exit loop due to max executions, mark as error
-        if (executionCount >= maxExecutions) {
-            console.error(`[BackendWorkflowEngineService] ❌ Maximum execution count (${maxExecutions}) reached - possible infinite loop`);
-            state = {
-                ...state,
-                status: 'error',
-                currentStepId: undefined,
-            };
-            await this.updateInstanceFromState(request.instanceId, state);
-            throw new Error(`Workflow execution exceeded maximum steps (${maxExecutions}) - possible infinite loop`);
+        finally {
+            if (dirty) {
+                const current = await this.store.getInstance(request.instanceId);
+                if (current) {
+                    await this.writeInstanceProjection(current, workflowForFlush, false);
+                }
+            }
         }
-        // If we exit loop, workflow is complete
-        state = {
-            ...state,
-            status: 'completed',
-            currentStepId: undefined,
-            output: state.variables,
-            lastActivityOutput: lastActivityOutputResume,
-        };
-        await this.updateInstanceFromState(request.instanceId, state);
-        return {
-            output: state.variables,
-            outcomes: { Done: true },
-            nextTask: null,
-            state,
-        };
     }
     /**
      * Get current workflow execution state.
@@ -2110,10 +2203,21 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
             .map((value) => value.replace(/([a-z])([A-Z])/g, '$1 $2').trim());
         return fallbackTokens.length > 0 ? fallbackTokens.join(' - ') : 'Unknown';
     }
+    /**
+     * One entity write for a finished start/resume/front-complete run.
+     * New runs insert; later steps update. Skips a second store persist.
+     */
+    async writeInstanceProjection(instance, definition, insert) {
+        if (insert) {
+            await this.saveInstanceToEntityService(instance, definition);
+            return;
+        }
+        await this.updateInstanceInEntityService(instance, definition);
+    }
     /**
      * Save workflow instance to entity service for entity-based access.
      */
-    async saveInstanceToEntityService(instance) {
+    async saveInstanceToEntityService(instance, predefined) {
         try {
             // Get active bookmarks for this instance to include in entity model
             const activeBookmarks = await this.getActiveBookmarks(instance.id);
@@ -2132,12 +2236,13 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
                     createdAt: b.createdAt,
                 })),
             };
-            const definition = await this.getDefinition(instance.definitionId);
+            const definition = predefined ?? (await this.getDefinition(instance.definitionId));
             const overview = this.computeOverviewDisplayFields(instance, definition);
             const runtimeDetails = this.computeRuntimeDetails(instance, definition, activeBookmarks);
             const workflowVariablesTable = this.computeWorkflowVariablesTable(instance, definition);
             const assignUserFields = await this.resolveAssignUserLookupFields(this.resolvePrimaryAssignUserId(instance, activeBookmarks));
             await this.syncLinkedTaskAssignee(instance, assignUserFields);
+            const scopeInfo = this.getSessionScopeInfo();
             const entityModel = {
                 id: instance.id,
                 definitionId: instance.definitionId,
@@ -2163,11 +2268,12 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
                 totalSteps: overview.totalSteps,
                 progressPercentage: overview.progressPercentage,
                 workflowVariablesTable,
+                ...(scopeInfo ? { scopeInfo } : {}),
             };
             const entityName = 'WorkflowManagement.WorkflowInstance';
             // Check if instance already exists
             try {
-                const existing = await this.entityStorageService.getOne(entityName, entityModel.id);
+                const existing = await this.entityStorageService.getOneAsEngine(entityName, entityModel.id);
                 if (existing) {
                     // Already exists - don't insert again, will be updated later
                     console.log('[AXCWorkflowExecutionService] ℹ️ Instance already exists in entity service, will be updated later', {
@@ -2180,7 +2286,7 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
                 // Instance doesn't exist - proceed with insert
             }
             // Insert new instance
-            await this.entityStorageService.insertOne(entityName, entityModel);
+            await this.entityStorageService.insertOneAsEngine(entityName, entityModel);
             console.log('[AXCWorkflowExecutionService] ✅ Inserted new instance in entity service', {
                 instanceId: instance.id,
                 status: instance.status,
@@ -2196,7 +2302,7 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
      * Update workflow instance in entity service.
      * Uses upsert pattern: try update first, if fails then insert.
      */
-    async updateInstanceInEntityService(instance) {
+    async updateInstanceInEntityService(instance, predefined) {
         try {
             // Get active bookmarks for this instance to include in entity model
             const activeBookmarks = await this.getActiveBookmarks(instance.id);
@@ -2215,12 +2321,13 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
                     createdAt: b.createdAt,
                 })),
             };
-            const definition = await this.getDefinition(instance.definitionId);
+            const definition = predefined ?? (await this.getDefinition(instance.definitionId));
             const overview = this.computeOverviewDisplayFields(instance, definition);
             const runtimeDetails = this.computeRuntimeDetails(instance, definition, activeBookmarks);
             const workflowVariablesTable = this.computeWorkflowVariablesTable(instance, definition);
             const assignUserFields = await this.resolveAssignUserLookupFields(this.resolvePrimaryAssignUserId(instance, activeBookmarks));
             await this.syncLinkedTaskAssignee(instance, assignUserFields);
+            const scopeInfo = this.getSessionScopeInfo();
             const entityModel = {
                 id: instance.id,
                 definitionId: instance.definitionId,
@@ -2246,11 +2353,12 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
                 totalSteps: overview.totalSteps,
                 progressPercentage: overview.progressPercentage,
                 workflowVariablesTable,
+                ...(scopeInfo ? { scopeInfo } : {}),
             };
             const entityName = 'WorkflowManagement.WorkflowInstance';
             // Try update first (upsert pattern)
             try {
-                await this.entityStorageService.updateOne(entityName, entityModel.id, entityModel);
+                await this.entityStorageService.updateOneAsEngine(entityName, entityModel.id, entityModel);
                 console.log('[AXCWorkflowExecutionService] ✅ Updated instance in entity service', {
                     instanceId: instance.id,
                     status: instance.status,
@@ -2267,7 +2375,7 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
             }
             // Try insert
             try {
-                await this.entityStorageService.insertOne(entityName, entityModel);
+                await this.entityStorageService.insertOneAsEngine(entityName, entityModel);
                 console.log('[AXCWorkflowExecutionService] ✅ Inserted instance in entity service', {
                     instanceId: instance.id,
                     status: instance.status,
@@ -2278,7 +2386,7 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
                 // Insert might fail if instance was created between update and insert
                 // Try update again as fallback
                 try {
-                    await this.entityStorageService.updateOne(entityName, entityModel.id, entityModel);
+                    await this.entityStorageService.updateOneAsEngine(entityName, entityModel.id, entityModel);
                     console.log('[AXCWorkflowExecutionService] ✅ Updated instance in entity service (after insert failed)', {
                         instanceId: instance.id,
                         status: instance.status,
@@ -2357,6 +2465,128 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
             correlationId: correlationId != null ? String(correlationId) : null,
         });
     }
+    /**
+     * Runs a Done-chain of entity creates and updates that do not read each other's new ids.
+     * Returns null when this step must stay on the one-activity path.
+     */
+    async runIndependentEntityWriteBatch(args) {
+        const batch = this.collectIndependentEntityWriteBatch(args.connections, args.graph, args.activity);
+        if (batch.length < 2) {
+            return null;
+        }
+        const results = await Promise.all(batch.map((activity) => this.executeBackendActivityLocally(activity, args.state, args.lastActivityOutput)));
+        let state = args.state;
+        let lastActivityOutput = args.lastActivityOutput;
+        let routeActivity = batch[batch.length - 1];
+        let routeOutcome = 'Done';
+        let executedCount = 0;
+        for (let index = 0; index < batch.length; index++) {
+            const activity = batch[index];
+            const executionResult = results[index];
+            executedCount++;
+            lastActivityOutput = executionResult.output;
+            await this.maybeLinkCreatedEntityRecord(args.instanceId, activity, state, args.lastActivityOutput, executionResult.output);
+            const variableUpdates = activity.name === 'workflow-activity:set-variable'
+                ? executionResult.output
+                : this.getVariableUpdatesFromOutput(args.workflow, activity.id, executionResult.output);
+            const outcome = Object.keys(executionResult.outcomes ?? {})[0] || 'Done';
+            const sessionUser = this.getSessionUser();
+            const audit = {
+                [`${activity.id}_outcome`]: outcome,
+                [`${activity.id}_activityOutput`]: executionResult.output,
+            };
+            if (sessionUser?.id) {
+                audit[`${activity.id}_completedByUserId`] = sessionUser.id;
+                audit[`${activity.id}_completedByLabel`] =
+                    sessionUser.title || sessionUser.name || sessionUser.id;
+            }
+            else {
+                audit[`${activity.id}_completedByLabel`] = 'System';
+            }
+            state = {
+                ...state,
+                variables: {
+                    ...state.variables,
+                    ...(variableUpdates && typeof variableUpdates === 'object' ? variableUpdates : {}),
+                    ...audit,
+                },
+                lastActivityOutput,
+                currentStepId: activity.id,
+                lastUpdated: new Date(),
+            };
+            routeActivity = activity;
+            routeOutcome = outcome;
+            if (outcome.toLowerCase() !== 'done') {
+                break;
+            }
+        }
+        await this.updateInstanceFromState(args.instanceId, state);
+        const nextConn = this.findWorkflowConnection(args.connections, routeActivity.id, routeOutcome);
+        if (!nextConn) {
+            state = {
+                ...state,
+                status: 'completed',
+                currentStepId: undefined,
+                output: state.variables,
+                lastActivityOutput,
+            };
+            await this.updateInstanceFromState(args.instanceId, state);
+            return { state, lastActivityOutput, nextActivity: null, executedCount };
+        }
+        const nextActivity = this.findActivityInGraph(args.graph, nextConn.target.activtyName);
+        if (!nextActivity) {
+            state = { ...state, status: 'error', currentStepId: undefined };
+            await this.updateInstanceFromState(args.instanceId, state);
+            throw new Error(`Next activity '${nextConn.target.activtyName}' not found in workflow graph`);
+        }
+        return { state, lastActivityOutput, nextActivity, executedCount };
+    }
+    collectIndependentEntityWriteBatch(connections, graph, start) {
+        if (!BackendWorkflowEngineService_1.ENTITY_WRITE_ACTIVITY_NAMES.has(start.name)) {
+            return [start];
+        }
+        const batch = [start];
+        const produced = new Set(this.outputVariableNames(start));
+        let cursor = start;
+        while (batch.length < 8) {
+            const conn = this.findWorkflowConnection(connections, cursor.id, 'Done');
+            if (!conn) {
+                break;
+            }
+            const next = this.findActivityInGraph(graph, conn.target.activtyName);
+            if (!next || !BackendWorkflowEngineService_1.ENTITY_WRITE_ACTIVITY_NAMES.has(next.name)) {
+                break;
+            }
+            if (this.activityReadsVariables(next, produced)) {
+                break;
+            }
+            batch.push(next);
+            for (const name of this.outputVariableNames(next)) {
+                produced.add(name);
+            }
+            cursor = next;
+        }
+        return batch;
+    }
+    outputVariableNames(activity) {
+        const mapping = activity.outputToVariables;
+        if (!mapping || typeof mapping !== 'object') {
+            return [];
+        }
+        return Object.keys(mapping);
+    }
+    activityReadsVariables(activity, names) {
+        if (names.size === 0) {
+            return false;
+        }
+        const blob = JSON.stringify(activity.inputs ?? {});
+        for (const name of names) {
+            if (new RegExp(`variables\\.${name}(?![A-Za-z0-9_])`).test(blob)) {
+                return true;
+            }
+        }
+        return false;
+    }
     /**
      * Execute backend activities locally via {@link WorkflowActivityRegistryService}.
      *
@@ -2696,9 +2926,12 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
                 }
             });
         }
-        // Save to IndexedDB
-        await this.updateInstance(instance);
-        // 🎯 Also update in entity service
+        // Save runtime state in memory. Entity row is written once per start/resume
+        // unless persistence is not deferred (cancel and other direct updates).
+        await this.store.updateInstance(instance, { persist: false });
+        if (this.store.isPersistenceDeferred()) {
+            return instance;
+        }
         await this.updateInstanceInEntityService(instance);
         return instance;
     }
@@ -2732,332 +2965,370 @@ let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class Backen
      * @returns Response with nextTask (if frontend activity) or completion status
      */
     async frontActivtyComplete(request) {
+        let dirty = false;
+        let workflowForFlush = null;
         try {
-            // Get current workflow instance state
-            let state = await this.getState({ instanceId: request.instanceId });
-            if (!state) {
-                console.error('[BackendWorkflowEngineService] ❌ Workflow instance not found:', request.instanceId);
-                throw new Error(`Workflow instance not found: ${request.instanceId}`);
-            }
-            // Check if workflow is suspended
-            // If suspended, check if the activity being completed is a ui-activity (not human-task)
-            // If it's a ui-activity, we can continue execution (workflow manager is handling it)
-            // If it's a human-task, use resume() instead
-            if (state.status === 'suspended') {
-                // Find the activity being completed to check its taskType
-                const workflow = await this.getDefinition(state.workflowId);
-                if (!workflow) {
-                    console.error('[BackendWorkflowEngineService] ❌ Workflow definition not found:', state.workflowId);
-                    throw new Error(`Workflow definition not found: ${state.workflowId}`);
+            return await (0, workflow_trigger_guard_1.runInsideWorkflowEngine)(() => this.store.runWithoutPersist(async () => {
+                // Get current workflow instance state
+                let state = await this.getState({ instanceId: request.instanceId });
+                if (!state) {
+                    console.error('[BackendWorkflowEngineService] ❌ Workflow instance not found:', request.instanceId);
+                    throw new Error(`Workflow instance not found: ${request.instanceId}`);
                 }
-                const activity = this.findActivityInGraph(workflow.graph, request.activityNode);
-                if (activity) {
-                    const activityType = activity.name;
-                    const activityDef = await this.activityDefinitionService.getActivityByName(activityType);
-                    const taskType = activityDef?.taskType || 'ui-activity';
-                    // If it's a ui-activity, allow continuation (workflow manager is handling it)
-                    if (taskType === 'ui-activity') {
-                        // Change status to running to allow continuation
+                // Check if workflow is suspended
+                // If suspended, check if the activity being completed is a ui-activity (not human-task)
+                // If it's a ui-activity, we can continue execution (workflow manager is handling it)
+                // If it's a human-task, use resume() instead
+                if (state.status === 'suspended') {
+                    // Find the activity being completed to check its taskType
+                    const workflow = await this.getDefinition(state.workflowId);
+                    if (!workflow) {
+                        console.error('[BackendWorkflowEngineService] ❌ Workflow definition not found:', state.workflowId);
+                        throw new Error(`Workflow definition not found: ${state.workflowId}`);
+                    }
+                    const activity = this.findActivityInGraph(workflow.graph, request.activityNode);
+                    if (activity) {
+                        const activityType = activity.name;
+                        const activityDef = await this.activityDefinitionService.getActivityByName(activityType);
+                        const taskType = activityDef?.taskType || 'ui-activity';
+                        // If it's a ui-activity, allow continuation (workflow manager is handling it)
+                        if (taskType === 'ui-activity') {
+                            // Change status to running to allow continuation
+                            state = {
+                                ...state,
+                                status: 'running',
+                            };
+                        }
+                        else {
+                            // It's a human-task, must use resume()
+                            console.warn('[BackendWorkflowEngineService] ⚠️ Workflow is suspended. Use resume() method instead.');
+                            throw new Error('Workflow is suspended. Use resume() method for suspended workflows.');
+                        }
+                    }
+                    else {
+                        // Activity not found, but allow continuation (might be edge case)
                         state = {
                             ...state,
                             status: 'running',
                         };
                     }
-                    else {
-                        // It's a human-task, must use resume()
-                        console.warn('[BackendWorkflowEngineService] ⚠️ Workflow is suspended. Use resume() method instead.');
-                        throw new Error('Workflow is suspended. Use resume() method for suspended workflows.');
-                    }
-                }
-                else {
-                    // Activity not found, but allow continuation (might be edge case)
-                    state = {
-                        ...state,
-                        status: 'running',
-                    };
-                }
-            }
-            // Load workflow definition
-            const workflow = await this.getDefinition(state.workflowId);
-            if (!workflow) {
-                console.error('[BackendWorkflowEngineService] ❌ Workflow definition not found:', state.workflowId);
-                throw new Error(`Workflow definition not found: ${state.workflowId}`);
-            }
-            const connections = workflow.graph.connections || [];
-            // Consume bookmark for the activity being completed so only the next step has an active bookmark
-            await this.consumeBookmark(request.instanceId, request.activityNode);
-            const output = (request.output || {});
-            const completedActivity = this.findActivityInGraph(workflow.graph, request.activityNode);
-            // Resolve allowed outcomes from workflow definition and normalize outcome
-            const allowedOutcomes = await this.getActivityAllowedOutcomes(workflow, request.activityNode);
-            const coercedOutcome = this.coerceCreateEntityFormOutcome(completedActivity, request.outcome ?? 'Done', output);
-            const outcome = this.normalizeOutcome(coercedOutcome, allowedOutcomes, request.activityNode);
-            // Apply frontend output: only last activity output is kept (overwritten each step)
-            let lastActivityOutput = output;
-            // Apply outputToVariables for the completed frontend activity (e.g. leaveRequestForm → leaveRequestId: 'id')
-            const variableUpdatesFromOutput = this.getVariableUpdatesFromOutput(workflow, request.activityNode, output);
-            const formResultPromotions = this.buildPersistedEntityFormVariablePromotions(output, completedActivity?.name, outcome);
-            const sessionUserFrontComplete = this.getSessionUser();
-            const frontCompleteAudit = {
-                [`${request.activityNode}_outcome`]: outcome,
-                [`${request.activityNode}_activityOutput`]: output,
-            };
-            if (sessionUserFrontComplete?.id) {
-                frontCompleteAudit[`${request.activityNode}_completedByUserId`] =
-                    sessionUserFrontComplete.id;
-                frontCompleteAudit[`${request.activityNode}_completedByLabel`] =
-                    sessionUserFrontComplete.title ||
-                        sessionUserFrontComplete.name ||
-                        sessionUserFrontComplete.id;
-            }
-            else {
-                frontCompleteAudit[`${request.activityNode}_completedByLabel`] =
-                    'System';
-            }
-            state = {
-                ...state,
-                variables: {
-                    ...state.variables,
-                    ...output, // Merge frontend output into variables
-                    ...formResultPromotions, // Promote capture-form fields (e.g. effectiveDate) onto variables
-                    ...variableUpdatesFromOutput, // Map output paths to variable names (e.g. id → leaveRequestId)
-                    ...frontCompleteAudit,
-                },
-                lastActivityOutput,
-                lastUpdated: new Date(),
-            };
-            // Find next activity based on outcome from frontend (use normalized outcome)
-            const nextConnection = this.findWorkflowConnection(connections, request.activityNode, outcome);
-            if (!nextConnection) {
-                // No next activity → workflow completed
-                state = {
-                    ...state,
-                    status: 'completed',
-                    currentStepId: undefined,
-                    output: state.variables,
-                };
-                await this.updateInstanceFromState(request.instanceId, state);
-                return {
-                    output: { outcome, userInput: request.output },
-                    outcomes: { [outcome]: true },
-                    nextTask: null,
-                    state,
-                };
-            }
-            // 🎯 KEY LOGIC: Execute all backend activities until we reach next frontend activity
-            let currentActivity = this.findActivityInGraph(workflow.graph, nextConnection.target.activtyName);
-            let executionCount = 0;
-            const maxExecutions = 500;
-            if (!currentActivity) {
-                console.error(`[BackendWorkflowEngineService] ❌ Next activity '${nextConnection.target.activtyName}' not found in graph`);
-                state = {
-                    ...state,
-                    status: 'error',
-                    currentStepId: undefined,
-                };
-                await this.updateInstanceFromState(request.instanceId, state);
-                throw new Error(`Next activity '${nextConnection.target.activtyName}' not found in workflow graph`);
-            }
-            // Only lastActivityOutput is persisted; used as scope.outputs for expressions.
-            while (currentActivity && executionCount < maxExecutions) {
-                executionCount++;
-                // Map activity name (registry key) to activity type
-                const activityType = currentActivity.name;
-                // Determine execution mode (async)
-                const executionMode = await this.determineExecutionMode(activityType, currentActivity);
-                // Get activity definition to retrieve taskType (taskType === 'human-task' → suspend for cartable)
-                const activityDef = await this.activityDefinitionService.getActivityByName(activityType);
-                let taskTypeComplete = currentActivity.metadata?.['taskType'] ??
-                    activityDef?.taskType ??
-                    'ui-activity';
-                // Defensive: human-task and cartable must suspend (same as run())
-                if (this.isTaskBoardSuspendGraphActivity(activityType)) {
-                    if (activityDef?.taskType === 'human-task')
-                        taskTypeComplete = 'human-task';
                 }
-                const effectiveExecutionModeComplete = taskTypeComplete === 'human-task' && executionMode === 'backend'
-                    ? 'frontend'
-                    : this.isTaskBoardSuspendGraphActivity(activityType) &&
-                        (activityDef?.taskType === 'human-task' ||
-                            taskTypeComplete === 'human-task')
-                        ? executionMode === 'backend'
-                            ? 'frontend'
-                            : executionMode
-                        : executionMode;
-                // If frontend activity → stop and return as nextTask
-                if (effectiveExecutionModeComplete === 'frontend' ||
-                    effectiveExecutionModeComplete === 'both') {
-                    const pendingTask = await this.createTaskFromActivity(currentActivity, state);
-                    const resolvedTaskTypeComplete = taskTypeComplete === 'human-task' ||
-                        pendingTask.taskType === 'human-task'
-                        ? 'human-task'
-                        : pendingTask.taskType;
-                    // Extract assignment and task metadata from activity inputs (for human-task activities)
-                    let bookmarkPayload = {
-                        activityType,
-                        activityName: currentActivity.name,
-                        taskToken: pendingTask.taskToken, // Store taskToken for resume
-                        taskType: resolvedTaskTypeComplete,
-                    };
-                    // For human-task activities, extract assignment and task metadata from inputs
-                    if (resolvedTaskTypeComplete === 'human-task' && pendingTask.input) {
-                        const inputs = pendingTask.input;
-                        // Assignment metadata (normalize to array; expression may return single id)
-                        bookmarkPayload['assignedUserIds'] = this.normalizeUserIds(inputs['assignedUserIds']);
-                        bookmarkPayload['candidateUserIds'] = this.normalizeUserIds(inputs['candidateUserIds']);
-                        bookmarkPayload['candidateRoleIds'] = this.normalizeUserIds(inputs['candidateRoleIds']);
-                        // Task metadata
-                        bookmarkPayload['title'] = this.resolveHumanTaskBookmarkTitle(inputs, activityDef, currentActivity);
-                        bookmarkPayload['description'] = inputs['description'] || null;
-                        bookmarkPayload['priority'] = inputs['priority'] || 'Normal';
-                        bookmarkPayload['dueDate'] = inputs['dueDate'] || null;
-                        // UI configuration
-                        bookmarkPayload['layout'] = inputs['layout'] || null;
-                        bookmarkPayload['actions'] = inputs['actions'] || null;
-                        bookmarkPayload['context'] = inputs['context'] || {};
-                    }
-                    if (activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.cartable) {
-                        bookmarkPayload['assignedUserIds'] = [];
-                    }
-                    if (resolvedTaskTypeComplete === 'human-task') {
-                        const htInputs = pendingTask.input;
-                        this.logHumanTaskBookmarkAssignmentTrace({
-                            phase: 'engine-frontActivityComplete',
-                            instanceId: request.instanceId,
-                            workflowDefinitionName: workflow.name,
-                            activityId: currentActivity.id,
-                            activityType,
-                            rawAssignedUserIds: htInputs?.['assignedUserIds'],
-                            normalizedAssignedUserIds: bookmarkPayload['assignedUserIds'],
-                            variables: state.variables,
-                        });
-                    }
-                    // Create bookmark for frontend activity
-                    // Store all metadata in bookmark payload (replaces Work Item)
-                    const bookmarkId = await this.createBookmark(request.instanceId, currentActivity.id, 'user-task', bookmarkPayload);
-                    // Update state: task-board activities → suspended, else running (form/popup)
-                    const isHumanTaskComplete = this.isTaskBoardSuspendGraphActivity(activityType);
-                    state = {
-                        ...state,
-                        lastActivityOutput,
-                        status: isHumanTaskComplete ? 'suspended' : 'running',
-                        currentStepId: currentActivity.id,
-                    };
-                    await this.updateInstanceFromState(request.instanceId, state);
-                    return {
-                        output: { outcome, userInput: request.output },
-                        outcomes: { [outcome]: true },
-                        nextTask: pendingTask,
-                        state,
-                    };
+                // Load workflow definition
+                const workflow = await this.getDefinition(state.workflowId);
+                workflowForFlush = workflow;
+                if (!workflow) {
+                    console.error('[BackendWorkflowEngineService] ❌ Workflow definition not found:', state.workflowId);
+                    throw new Error(`Workflow definition not found: ${state.workflowId}`);
                 }
-                // Backend activity → execute it
-                const lastOutputBeforeBackendComplete = lastActivityOutput;
-                const executionResult = await this.executeBackendActivityLocally(currentActivity, state, lastActivityOutput);
-                lastActivityOutput = executionResult.output;
-                await this.maybeLinkCreatedEntityRecord(request.instanceId, currentActivity, state, lastOutputBeforeBackendComplete, executionResult.output);
-                // set-variable activity writes variables directly in output; it has no outputToVariables
-                const isSetVariableComplete = currentActivity.name === 'workflow-activity:set-variable';
-                const variableUpdatesComplete = isSetVariableComplete
-                    ? executionResult.output
-                    : this.getVariableUpdatesFromOutput(workflow, currentActivity.id, executionResult.output);
-                const backendOutcome = Object.keys(executionResult.outcomes)[0] || 'Done';
-                const sessionUserComplete = this.getSessionUser();
-                const backendAuditComplete = {
-                    [`${currentActivity.id}_outcome`]: backendOutcome,
-                    [`${currentActivity.id}_activityOutput`]: executionResult.output,
+                const connections = workflow.graph.connections || [];
+                // Consume bookmark for the activity being completed so only the next step has an active bookmark
+                dirty = true;
+                await this.consumeBookmark(request.instanceId, request.activityNode);
+                const output = (request.output || {});
+                const completedActivity = this.findActivityInGraph(workflow.graph, request.activityNode);
+                // Resolve allowed outcomes from workflow definition and normalize outcome
+                const allowedOutcomes = await this.getActivityAllowedOutcomes(workflow, request.activityNode);
+                const coercedOutcome = this.coerceCreateEntityFormOutcome(completedActivity, request.outcome ?? 'Done', output);
+                const outcome = this.normalizeOutcome(coercedOutcome, allowedOutcomes, request.activityNode);
+                // Apply frontend output: only last activity output is kept (overwritten each step)
+                let lastActivityOutput = output;
+                // Apply outputToVariables for the completed frontend activity (e.g. leaveRequestForm → leaveRequestId: 'id')
+                const variableUpdatesFromOutput = this.getVariableUpdatesFromOutput(workflow, request.activityNode, output);
+                const formResultPromotions = this.buildPersistedEntityFormVariablePromotions(output, completedActivity?.name, outcome);
+                const sessionUserFrontComplete = this.getSessionUser();
+                const frontCompleteAudit = {
+                    [`${request.activityNode}_outcome`]: outcome,
+                    [`${request.activityNode}_activityOutput`]: output,
                 };
-                if (sessionUserComplete?.id) {
-                    backendAuditComplete[`${currentActivity.id}_completedByUserId`] =
-                        sessionUserComplete.id;
-                    backendAuditComplete[`${currentActivity.id}_completedByLabel`] =
-                        sessionUserComplete.title ||
-                            sessionUserComplete.name ||
-                            sessionUserComplete.id;
+                if (sessionUserFrontComplete?.id) {
+                    frontCompleteAudit[`${request.activityNode}_completedByUserId`] =
+                        sessionUserFrontComplete.id;
+                    frontCompleteAudit[`${request.activityNode}_completedByLabel`] =
+                        sessionUserFrontComplete.title ||
+                            sessionUserFrontComplete.name ||
+                            sessionUserFrontComplete.id;
                 }
                 else {
-                    backendAuditComplete[`${currentActivity.id}_completedByLabel`] =
+                    frontCompleteAudit[`${request.activityNode}_completedByLabel`] =
                         'System';
                 }
                 state = {
                     ...state,
                     variables: {
                         ...state.variables,
-                        ...(typeof variableUpdatesComplete === 'object' &&
-                            variableUpdatesComplete !== null
-                            ? variableUpdatesComplete
-                            : {}),
-                        ...backendAuditComplete,
+                        ...output, // Merge frontend output into variables
+                        ...formResultPromotions, // Promote capture-form fields (e.g. effectiveDate) onto variables
+                        ...variableUpdatesFromOutput, // Map output paths to variable names (e.g. id → leaveRequestId)
+                        ...frontCompleteAudit,
                     },
                     lastActivityOutput,
-                    currentStepId: currentActivity.id,
                     lastUpdated: new Date(),
                 };
-                await this.updateInstanceFromState(request.instanceId, state);
-                // Find next activity based on outcome (backend execution result)
-                const nextConn = this.findWorkflowConnection(connections, currentActivity.id, backendOutcome);
-                if (!nextConn) {
+                // Find next activity based on outcome from frontend (use normalized outcome)
+                const nextConnection = this.findWorkflowConnection(connections, request.activityNode, outcome);
+                if (!nextConnection) {
                     // No next activity → workflow completed
                     state = {
                         ...state,
                         status: 'completed',
                         currentStepId: undefined,
                         output: state.variables,
-                        lastActivityOutput,
                     };
                     await this.updateInstanceFromState(request.instanceId, state);
                     return {
-                        output: state.variables,
-                        outcomes: { Done: true },
+                        output: { outcome, userInput: request.output },
+                        outcomes: { [outcome]: true },
                         nextTask: null,
                         state,
                     };
                 }
-                // Find next activity
-                const nextActivity = this.findActivityInGraph(workflow.graph, nextConn.target.activtyName);
-                if (!nextActivity) {
-                    console.error(`[BackendWorkflowEngineService] ❌ Next activity '${nextConn.target.activtyName}' not found in graph`);
+                // 🎯 KEY LOGIC: Execute all backend activities until we reach next frontend activity
+                let currentActivity = this.findActivityInGraph(workflow.graph, nextConnection.target.activtyName);
+                let executionCount = 0;
+                const maxExecutions = 500;
+                if (!currentActivity) {
+                    console.error(`[BackendWorkflowEngineService] ❌ Next activity '${nextConnection.target.activtyName}' not found in graph`);
                     state = {
                         ...state,
                         status: 'error',
                         currentStepId: undefined,
                     };
                     await this.updateInstanceFromState(request.instanceId, state);
-                    throw new Error(`Next activity '${nextConn.target.activtyName}' not found in workflow graph`);
+                    throw new Error(`Next activity '${nextConnection.target.activtyName}' not found in workflow graph`);
                 }
-                currentActivity = nextActivity;
-            }
-            // If we exit loop due to max executions, mark as error
-            if (executionCount >= maxExecutions) {
-                console.error(`[BackendWorkflowEngineService] ❌ Maximum execution count (${maxExecutions}) reached - possible infinite loop`);
+                // Only lastActivityOutput is persisted; used as scope.outputs for expressions.
+                while (currentActivity && executionCount < maxExecutions) {
+                    executionCount++;
+                    // Map activity name (registry key) to activity type
+                    const activityType = currentActivity.name;
+                    // Determine execution mode (async)
+                    const executionMode = await this.determineExecutionMode(activityType, currentActivity);
+                    // Get activity definition to retrieve taskType (taskType === 'human-task' → suspend for cartable)
+                    const activityDef = await this.activityDefinitionService.getActivityByName(activityType);
+                    let taskTypeComplete = currentActivity.metadata?.['taskType'] ??
+                        activityDef?.taskType ??
+                        'ui-activity';
+                    // Defensive: human-task and cartable must suspend (same as run())
+                    if (this.isTaskBoardSuspendGraphActivity(activityType)) {
+                        if (activityDef?.taskType === 'human-task')
+                            taskTypeComplete = 'human-task';
+                    }
+                    const effectiveExecutionModeComplete = taskTypeComplete === 'human-task' && executionMode === 'backend'
+                        ? 'frontend'
+                        : this.isTaskBoardSuspendGraphActivity(activityType) &&
+                            (activityDef?.taskType === 'human-task' ||
+                                taskTypeComplete === 'human-task')
+                            ? executionMode === 'backend'
+                                ? 'frontend'
+                                : executionMode
+                            : executionMode;
+                    // If frontend activity → stop and return as nextTask
+                    if (effectiveExecutionModeComplete === 'frontend' ||
+                        effectiveExecutionModeComplete === 'both') {
+                        const pendingTask = await this.createTaskFromActivity(currentActivity, state);
+                        const resolvedTaskTypeComplete = taskTypeComplete === 'human-task' ||
+                            pendingTask.taskType === 'human-task'
+                            ? 'human-task'
+                            : pendingTask.taskType;
+                        // Extract assignment and task metadata from activity inputs (for human-task activities)
+                        let bookmarkPayload = {
+                            activityType,
+                            activityName: currentActivity.name,
+                            taskToken: pendingTask.taskToken, // Store taskToken for resume
+                            taskType: resolvedTaskTypeComplete,
+                        };
+                        // For human-task activities, extract assignment and task metadata from inputs
+                        if (resolvedTaskTypeComplete === 'human-task' && pendingTask.input) {
+                            const inputs = pendingTask.input;
+                            // Assignment metadata (normalize to array; expression may return single id)
+                            bookmarkPayload['assignedUserIds'] = this.normalizeUserIds(inputs['assignedUserIds']);
+                            bookmarkPayload['candidateUserIds'] = this.normalizeUserIds(inputs['candidateUserIds']);
+                            bookmarkPayload['candidateRoleIds'] = this.normalizeUserIds(inputs['candidateRoleIds']);
+                            // Task metadata
+                            bookmarkPayload['title'] = this.resolveHumanTaskBookmarkTitle(inputs, activityDef, currentActivity);
+                            bookmarkPayload['description'] = inputs['description'] || null;
+                            bookmarkPayload['priority'] = inputs['priority'] || 'Normal';
+                            bookmarkPayload['dueDate'] = inputs['dueDate'] || null;
+                            // UI configuration
+                            bookmarkPayload['layout'] = inputs['layout'] || null;
+                            bookmarkPayload['actions'] = inputs['actions'] || null;
+                            bookmarkPayload['context'] = inputs['context'] || {};
+                        }
+                        if (activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.cartable) {
+                            bookmarkPayload['assignedUserIds'] = [];
+                        }
+                        if (resolvedTaskTypeComplete === 'human-task') {
+                            const htInputs = pendingTask.input;
+                            this.logHumanTaskBookmarkAssignmentTrace({
+                                phase: 'engine-frontActivityComplete',
+                                instanceId: request.instanceId,
+                                workflowDefinitionName: workflow.name,
+                                activityId: currentActivity.id,
+                                activityType,
+                                rawAssignedUserIds: htInputs?.['assignedUserIds'],
+                                normalizedAssignedUserIds: bookmarkPayload['assignedUserIds'],
+                                variables: state.variables,
+                            });
+                        }
+                        // Create bookmark for frontend activity
+                        // Store all metadata in bookmark payload (replaces Work Item)
+                        const bookmarkId = await this.createBookmark(request.instanceId, currentActivity.id, 'user-task', bookmarkPayload);
+                        // Update state: task-board activities → suspended, else running (form/popup)
+                        const isHumanTaskComplete = this.isTaskBoardSuspendGraphActivity(activityType);
+                        state = {
+                            ...state,
+                            lastActivityOutput,
+                            status: isHumanTaskComplete ? 'suspended' : 'running',
+                            currentStepId: currentActivity.id,
+                        };
+                        await this.updateInstanceFromState(request.instanceId, state);
+                        return {
+                            output: { outcome, userInput: request.output },
+                            outcomes: { [outcome]: true },
+                            nextTask: pendingTask,
+                            state,
+                        };
+                    }
+                    const parallelWrites = await this.runIndependentEntityWriteBatch({
+                        workflow,
+                        connections,
+                        graph: workflow.graph,
+                        instanceId: request.instanceId,
+                        activity: currentActivity,
+                        state,
+                        lastActivityOutput,
+                    });
+                    if (parallelWrites) {
+                        state = parallelWrites.state;
+                        lastActivityOutput = parallelWrites.lastActivityOutput;
+                        executionCount += parallelWrites.executedCount - 1;
+                        if (!parallelWrites.nextActivity) {
+                            return {
+                                output: state.variables,
+                                outcomes: { Done: true },
+                                nextTask: null,
+                                state,
+                            };
+                        }
+                        currentActivity = parallelWrites.nextActivity;
+                        continue;
+                    }
+                    // Backend activity → execute it
+                    const lastOutputBeforeBackendComplete = lastActivityOutput;
+                    const executionResult = await this.executeBackendActivityLocally(currentActivity, state, lastActivityOutput);
+                    lastActivityOutput = executionResult.output;
+                    await this.maybeLinkCreatedEntityRecord(request.instanceId, currentActivity, state, lastOutputBeforeBackendComplete, executionResult.output);
+                    // set-variable activity writes variables directly in output; it has no outputToVariables
+                    const isSetVariableComplete = currentActivity.name === 'workflow-activity:set-variable';
+                    const variableUpdatesComplete = isSetVariableComplete
+                        ? executionResult.output
+                        : this.getVariableUpdatesFromOutput(workflow, currentActivity.id, executionResult.output);
+                    const backendOutcome = Object.keys(executionResult.outcomes)[0] || 'Done';
+                    const sessionUserComplete = this.getSessionUser();
+                    const backendAuditComplete = {
+                        [`${currentActivity.id}_outcome`]: backendOutcome,
+                        [`${currentActivity.id}_activityOutput`]: executionResult.output,
+                    };
+                    if (sessionUserComplete?.id) {
+                        backendAuditComplete[`${currentActivity.id}_completedByUserId`] =
+                            sessionUserComplete.id;
+                        backendAuditComplete[`${currentActivity.id}_completedByLabel`] =
+                            sessionUserComplete.title ||
+                                sessionUserComplete.name ||
+                                sessionUserComplete.id;
+                    }
+                    else {
+                        backendAuditComplete[`${currentActivity.id}_completedByLabel`] =
+                            'System';
+                    }
+                    state = {
+                        ...state,
+                        variables: {
+                            ...state.variables,
+                            ...(typeof variableUpdatesComplete === 'object' &&
+                                variableUpdatesComplete !== null
+                                ? variableUpdatesComplete
+                                : {}),
+                            ...backendAuditComplete,
+                        },
+                        lastActivityOutput,
+                        currentStepId: currentActivity.id,
+                        lastUpdated: new Date(),
+                    };
+                    await this.updateInstanceFromState(request.instanceId, state);
+                    // Find next activity based on outcome (backend execution result)
+                    const nextConn = this.findWorkflowConnection(connections, currentActivity.id, backendOutcome);
+                    if (!nextConn) {
+                        // No next activity → workflow completed
+                        state = {
+                            ...state,
+                            status: 'completed',
+                            currentStepId: undefined,
+                            output: state.variables,
+                            lastActivityOutput,
+                        };
+                        await this.updateInstanceFromState(request.instanceId, state);
+                        return {
+                            output: state.variables,
+                            outcomes: { Done: true },
+                            nextTask: null,
+                            state,
+                        };
+                    }
+                    // Find next activity
+                    const nextActivity = this.findActivityInGraph(workflow.graph, nextConn.target.activtyName);
+                    if (!nextActivity) {
+                        console.error(`[BackendWorkflowEngineService] ❌ Next activity '${nextConn.target.activtyName}' not found in graph`);
+                        state = {
+                            ...state,
+                            status: 'error',
+                            currentStepId: undefined,
+                        };
+                        await this.updateInstanceFromState(request.instanceId, state);
+                        throw new Error(`Next activity '${nextConn.target.activtyName}' not found in workflow graph`);
+                    }
+                    currentActivity = nextActivity;
+                }
+                // If we exit loop due to max executions, mark as error
+                if (executionCount >= maxExecutions) {
+                    console.error(`[BackendWorkflowEngineService] ❌ Maximum execution count (${maxExecutions}) reached - possible infinite loop`);
+                    state = {
+                        ...state,
+                        status: 'error',
+                        currentStepId: undefined,
+                    };
+                    await this.updateInstanceFromState(request.instanceId, state);
+                    throw new Error(`Workflow execution exceeded maximum steps (${maxExecutions}) - possible infinite loop`);
+                }
+                // If we exit loop, workflow is complete
                 state = {
                     ...state,
-                    status: 'error',
+                    status: 'completed',
                     currentStepId: undefined,
+                    output: state.variables,
+                    lastActivityOutput,
                 };
                 await this.updateInstanceFromState(request.instanceId, state);
-                throw new Error(`Workflow execution exceeded maximum steps (${maxExecutions}) - possible infinite loop`);
-            }
-            // If we exit loop, workflow is complete
-            state = {
-                ...state,
-                status: 'completed',
-                currentStepId: undefined,
-                output: state.variables,
-                lastActivityOutput,
-            };
-            await this.updateInstanceFromState(request.instanceId, state);
-            return {
-                output: state.variables,
-                outcomes: { Done: true },
-                nextTask: null,
-                state,
-            };
+                return {
+                    output: state.variables,
+                    outcomes: { Done: true },
+                    nextTask: null,
+                    state,
+                };
+            }));
         }
         catch (error) {
             console.error('[BackendWorkflowEngineService] ❌ Error completing front activity:', error);
             throw error; // Re-throw to let caller handle
         }
+        finally {
+            if (dirty) {
+                const current = await this.store.getInstance(request.instanceId);
+                if (current) {
+                    await this.writeInstanceProjection(current, workflowForFlush, false);
+                }
+            }
+        }
     }
     //#endregion
     //#region ----   Stale suspension cleanup (app startup)   ----
@@ -3139,6 +3410,10 @@ exports.BackendWorkflowEngineService = BackendWorkflowEngineService;
  * Default outcome used when the requested outcome is not in the allowed list (standard scenario).
  */
 BackendWorkflowEngineService.DEFAULT_UNMATCHED_OUTCOME = 'Done';
+BackendWorkflowEngineService.ENTITY_WRITE_ACTIVITY_NAMES = new Set([
+    'workflow-activity:entity-create',
+    'workflow-activity:entity-update',
+]);
 exports.BackendWorkflowEngineService = BackendWorkflowEngineService = BackendWorkflowEngineService_1 = tslib_1.__decorate([
     (0, common_1.Injectable)(),
     tslib_1.__metadata("design:paramtypes", [workflow_execution_store_service_1.WorkflowExecutionStoreService,