@acorex-platform/framework-server 0.0.10

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

@@ -0,0 +1,2922 @@
+"use strict";
+var BackendWorkflowEngineService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackendWorkflowEngineService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@acorex-platform/framework-server/core");
+const workflow_request_session_adapter_1 = require("../activities/workflow-request-session.adapter");
+const multilanguage_util_1 = require("../utils/multilanguage.util");
+const uuid_util_1 = require("../utils/uuid.util");
+const workflow_management_const_1 = require("./workflow-management.const");
+const workflow_engine_errors_1 = require("./workflow-engine.errors");
+const workflow_activity_definition_service_1 = require("./workflow-activity-definition.service");
+const workflow_activity_registry_1 = require("../activities/workflow-activity.registry");
+const workflow_expression_evaluator_service_1 = require("./workflow-expression-evaluator.service");
+const workflow_expression_scope_service_1 = require("./workflow-expression-scope.service");
+const workflow_execution_store_service_1 = require("./workflow-execution-store.service");
+const entity_workflow_info_sync_1 = require("./entity-workflow-info.sync");
+/** Task context key for composed human-task titles (workflow-management). */
+const AXP_WORKFLOW_TASK_CONTEXT_TITLE_PARTS_KEY = '_taskTitleParts';
+/**
+ * Backend workflow runtime engine (ported from mock connectivity).
+ * Persists instances/bookmarks via {@link WorkflowExecutionStoreService}.
+ */
+let BackendWorkflowEngineService = BackendWorkflowEngineService_1 = class BackendWorkflowEngineService {
+    //#region ----   Services & Dependencies   ----
+    constructor(store, entityStorageService, activityDefinitionService, expressionScopeService, expressionEvaluator, sessionService, activityRegistry) {
+        this.store = store;
+        this.entityStorageService = entityStorageService;
+        this.activityDefinitionService = activityDefinitionService;
+        this.expressionScopeService = expressionScopeService;
+        this.expressionEvaluator = expressionEvaluator;
+        this.sessionService = sessionService;
+        this.activityRegistry = activityRegistry;
+        //#endregion
+        //#region ----   Task Token Management   ----
+        /**
+         * Secure task token storage.
+         * Key: token (UUID)
+         * Value: { instanceId, activityId, expiresAt }
+         */
+        this.taskTokens = new Map();
+        /**
+         * Token expiration time: 30 minutes.
+         * Tasks in task board (human-task) may wait days; resume is allowed via bookmark fallback when token is expired.
+         */
+        this.TOKEN_EXPIRATION_MS = 30 * 60 * 1000;
+        //#region ----   Execution Mode Detection   ----
+        /**
+         * Cache for activity definitions to avoid repeated queries.
+         */
+        this.activityDefinitionCache = new Map();
+        /**
+         * Cache TTL: 5 minutes
+         */
+        this.CACHE_TTL_MS = 5 * 60 * 1000;
+    }
+    /** Minimal session user shape used by workflow runtime. */
+    getSessionUser() {
+        const userId = this.sessionService?.userId;
+        if (!userId) {
+            return null;
+        }
+        return { id: userId, title: userId, name: userId };
+    }
+    //#endregion
+    //#region ----   Definition Loading   ----
+    /**
+     * Load workflow definition by name from entity storage.
+     */
+    async getDefinition(workflowId) {
+        console.log(`[BackendWorkflowRuntime] 🔍 Loading workflow definition: ${workflowId}`);
+        // Query entity storage by name field (not id)
+        console.log(`[BackendWorkflowRuntime] 🔄 Fallback: Querying entity storage by name field: ${workflowId}`);
+        try {
+            const result = await this.entityStorageService.query('WorkflowManagement.WorkflowDefinition', {
+                skip: 0,
+                take: 1,
+                filter: {
+                    field: 'name',
+                    operator: { type: 'equal' },
+                    value: workflowId,
+                },
+            });
+            if (result.items && result.items.length > 0) {
+                const entity = result.items[0];
+                console.log(`[BackendWorkflowRuntime] ✅ Found definition via entity storage: ${workflowId}`);
+                return entity;
+            }
+        }
+        catch (error) {
+            console.error(`[BackendWorkflowRuntime] ❌ Error querying entity storage:`, error);
+        }
+        console.error(`[BackendWorkflowRuntime] ❌ Workflow definition not found: ${workflowId}`);
+        return null;
+    }
+    /**
+     * Generate secure, non-guessable task token (UUID).
+     */
+    generateTaskToken(instanceId, activityId) {
+        const token = (0, uuid_util_1.generateUuid)();
+        const expiresAt = new Date(Date.now() + this.TOKEN_EXPIRATION_MS);
+        this.taskTokens.set(token, {
+            instanceId,
+            activityId,
+            expiresAt,
+        });
+        // Cleanup expired tokens periodically (lightweight)
+        this.cleanupExpiredTokens();
+        console.log(`[BackendWorkflowEngineService] 🔐 Generated task token for ${instanceId}:${activityId}`);
+        return token;
+    }
+    /**
+     * Validate task token.
+     * Returns true if token exists, not expired, and matches instanceId + activityId.
+     */
+    validateTaskToken(token, instanceId, activityId) {
+        const tokenInfo = this.taskTokens.get(token);
+        if (!tokenInfo) {
+            console.warn(`[BackendWorkflowEngineService] ❌ Task token not found: ${token}`);
+            return false;
+        }
+        if (tokenInfo.expiresAt < new Date()) {
+            console.warn(`[BackendWorkflowEngineService] ❌ Task token expired: ${token}`);
+            this.taskTokens.delete(token);
+            return false;
+        }
+        if (tokenInfo.instanceId !== instanceId || tokenInfo.activityId !== activityId) {
+            console.warn(`[BackendWorkflowEngineService] ❌ Task token mismatch: expected ${instanceId}:${activityId}, got ${tokenInfo.instanceId}:${tokenInfo.activityId}`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Allow resume when token is missing/expired but instance is suspended and has an active bookmark for this step.
+     * Used for task board tasks that may wait days (token is in-memory and expires after 30 min).
+     */
+    async canResumeByBookmark(instanceId, stepId) {
+        const instance = await this.getInstance(instanceId);
+        if (!instance || instance.subStatus !== 'Suspended') {
+            return false;
+        }
+        const bookmarks = await this.getActiveBookmarks(instanceId);
+        return bookmarks.some((b) => b.activityId === stepId);
+    }
+    /**
+     * Remove task token after completion to prevent replay.
+     */
+    removeTaskToken(token) {
+        this.taskTokens.delete(token);
+        console.log(`[BackendWorkflowEngineService] 🗑️ Removed task token: ${token}`);
+    }
+    /**
+     * Cleanup expired tokens (lightweight).
+     */
+    cleanupExpiredTokens() {
+        const now = new Date();
+        let cleaned = 0;
+        for (const [token, info] of this.taskTokens.entries()) {
+            if (info.expiresAt < now) {
+                this.taskTokens.delete(token);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            console.log(`[BackendWorkflowEngineService] 🧹 Cleaned up ${cleaned} expired task tokens`);
+        }
+    }
+    //#endregion
+    /**
+     * Start a new workflow instance.
+     * Creates a workflow instance and stores it in IndexedDB.
+     */
+    async start(request) {
+        console.log(`[BackendWorkflowEngineService] 🚀 Starting workflow: ${request.workflowId}`);
+        // Load workflow definition using definition loader (queries by name field)
+        // This ensures consistency with Workflow Management UI which also uses name field
+        const workflow = await this.getDefinition(request.workflowId);
+        if (!workflow) {
+            console.error(`[BackendWorkflowEngineService] ❌ Workflow definition not found: ${request.workflowId}`);
+            throw new Error(`Workflow definition not found: ${request.workflowId}`);
+        }
+        // Validate workflow structure
+        const graph = workflow.graph;
+        if (!graph) {
+            throw new Error(`Workflow definition has no graph: ${request.workflowId}`);
+        }
+        const activities = graph.activities || [];
+        const connections = graph.connections || [];
+        if (activities.length === 0) {
+            throw new Error(`Workflow definition has no activities: ${request.workflowId}`);
+        }
+        // Validate startActivityId exists
+        if (graph.startActivityId) {
+            const startActivity = activities.find((a) => a.id === graph.startActivityId);
+            if (!startActivity) {
+                throw new Error(`Start activity '${graph.startActivityId}' not found in workflow: ${request.workflowId}`);
+            }
+        }
+        // Validate connections are structurally valid (no circular references in simple check)
+        const activityIds = new Set(activities.map((a) => a.id));
+        for (const conn of connections) {
+            if (!activityIds.has(conn.source.activtyName) || !activityIds.has(conn.target.activtyName)) {
+                console.warn(`[BackendWorkflowEngineService] ⚠️ Connection references non-existent activity: ${conn.source.activtyName} -> ${conn.target.activtyName}`);
+            }
+        }
+        const instanceId = (0, uuid_util_1.generateUuid)();
+        const now = new Date().toISOString();
+        // Build connection map: target -> source[]
+        const incomingConnections = new Map();
+        connections.forEach((conn) => {
+            const targetId = conn.target.activtyName;
+            if (!incomingConnections.has(targetId)) {
+                incomingConnections.set(targetId, []);
+            }
+            incomingConnections.get(targetId).push(conn.source.activtyName);
+        });
+        // Find root activity (use startActivityId or activity with no incoming connections, or first activity)
+        let firstActivity = null;
+        if (graph.startActivityId) {
+            firstActivity = activities.find((a) => a.id === graph.startActivityId) || null;
+        }
+        if (!firstActivity) {
+            for (const activity of activities) {
+                if (!incomingConnections.has(activity.id)) {
+                    firstActivity = activity;
+                    break;
+                }
+            }
+        }
+        // If no root found, use first activity
+        if (!firstActivity && activities.length > 0) {
+            firstActivity = activities[0];
+        }
+        const firstStepId = firstActivity?.id || 'root';
+        // Extract correlationId from input if provided (remove it from input to avoid pollution)
+        const correlationId = request.input?.['correlationId'] || null;
+        const entityRefId = request.input?.['refId'] || null;
+        const entityRefType = request.input?.['refType'] || null;
+        const workflowInput = { ...request.input };
+        if (correlationId && workflowInput['correlationId']) {
+            delete workflowInput['correlationId'];
+        }
+        // Remove refId and refType from workflow input (they're stored in instance metadata)
+        if (entityRefId && workflowInput['refId']) {
+            delete workflowInput['refId'];
+        }
+        if (entityRefType && workflowInput['refType']) {
+            delete workflowInput['refType'];
+        }
+        // Create workflow state (totalSteps for overview progress display)
+        const totalSteps = activities.length;
+        const workflowState = {
+            id: `state-${instanceId}`,
+            definitionId: workflow.name, // Use name as definitionId (backward compatibility)
+            //definitionVersion: workflow.version,
+            definitionVersion: 1,
+            correlationId,
+            status: 'Running',
+            subStatus: 'Executing',
+            bookmarks: [],
+            incidents: [],
+            fault: null,
+            completionCallbacks: [],
+            activityExecutionContexts: firstActivity
+                ? [
+                    {
+                        id: `ctx-${firstStepId}`,
+                        parentContextId: null,
+                        scheduledActivityNodeId: firstStepId,
+                        ownerActivityNodeId: null,
+                        properties: {},
+                        activityState: null,
+                        dynamicVariables: [],
+                        status: 'Running',
+                        isExecuting: false,
+                        faultCount: 0,
+                        startedAt: now,
+                        completedAt: null,
+                        tag: null,
+                    },
+                ]
+                : [],
+            input: { ...workflowInput, _workflowInstanceId: instanceId },
+            output: {},
+            properties: {},
+            createdAt: now,
+            updatedAt: now,
+            finishedAt: null,
+            totalSteps,
+        };
+        // Create workflow instance
+        const instance = {
+            $schema: 'https://elsaworkflows.io/schemas/workflow-instance/v3.0.0/schema.json',
+            id: instanceId,
+            definitionId: workflow.name, // Use name as definitionId (backward compatibility)
+            //definitionVersionId: workflow.id,
+            //version: workflow.version,
+            version: 1,
+            definitionVersionId: '1',
+            parentWorkflowInstanceId: null,
+            workflowState,
+            status: 'Running',
+            subStatus: 'Executing',
+            correlationId,
+            name: (0, multilanguage_util_1.resolveMultiLanguageString)(workflow.title) || workflow.name || null,
+            incidentCount: 0,
+            createdAt: now,
+            updatedAt: now,
+            finishedAt: null,
+            // Store entity reference for work item creation
+            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'
+                        ? '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,
+                };
+            }
+            // Backend activity → execute it
+            const executionResult = await this.executeBackendActivityLocally(currentActivity, state, lastActivityOutput);
+            lastActivityOutput = 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;
+        }
+        // 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`);
+        }
+        // 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).
+     */
+    async cancelInstance(instanceId, reason) {
+        const instance = await this.getInstance(instanceId);
+        if (!instance || instance.status === 'Finished') {
+            return;
+        }
+        const now = new Date().toISOString();
+        instance.status = 'Finished';
+        instance.subStatus = 'Cancelled';
+        instance.updatedAt = now;
+        instance.finishedAt = now;
+        instance.workflowState.status = 'Finished';
+        instance.workflowState.subStatus = 'Cancelled';
+        instance.workflowState.updatedAt = now;
+        instance.workflowState.finishedAt = now;
+        if (reason) {
+            instance.workflowState.properties = {
+                ...(instance.workflowState.properties ?? {}),
+                cancelReason: reason,
+            };
+        }
+        await this.store.updateInstance(instance);
+        await this.updateInstanceInEntityService(instance);
+        console.log(`[BackendWorkflowEngineService] 🛑 Cancelled workflow instance: ${instanceId}`, { reason });
+    }
+    /**
+     * Find activity in Graph by ID.
+     */
+    findActivityInGraph(graph, activityId) {
+        const activities = graph.activities || [];
+        return activities.find((a) => a.id === activityId) || null;
+    }
+    /**
+     * Resolve allowed outcomes for the current activity from the workflow definition.
+     * - First: use outgoing connection ports from the workflow graph (so workflow-defined ports like 'Submitted'/'Cancelled' are accepted).
+     * - For human-task: parse activity instance inputs.actions (prefix/suffix) and use action names as outcomes.
+     * - Otherwise: use activity definition outcomes or ['Done'].
+     */
+    async getActivityAllowedOutcomes(workflow, stepId) {
+        const activityInstance = this.findActivityInGraph(workflow.graph, stepId);
+        if (!activityInstance)
+            return [BackendWorkflowEngineService_1.DEFAULT_UNMATCHED_OUTCOME];
+        // Prefer outcomes from workflow graph: outgoing connection ports for this step (e.g. leaveRequestForm → Submitted, Cancelled)
+        const connections = workflow.graph?.connections ?? [];
+        const outgoingPorts = connections
+            .filter((c) => c.source?.activtyName === stepId)
+            .map((c) => c.source?.port ?? BackendWorkflowEngineService_1.DEFAULT_UNMATCHED_OUTCOME);
+        const uniquePorts = this.normalizeAllowedOutcomeList(outgoingPorts);
+        if (uniquePorts.length > 0)
+            return uniquePorts;
+        const activityDef = await this.activityDefinitionService.getActivityByName(activityInstance.name);
+        const taskType = activityDef?.taskType ?? 'ui-activity';
+        // Resolve outcomes from instance inputs.actions (human-task, show-layout-popup, etc.)
+        if (activityInstance.inputs?.['actions']) {
+            const actions = activityInstance.inputs['actions'];
+            const names = [];
+            try {
+                const parsed = typeof actions === 'string' ? JSON.parse(actions) : actions;
+                const prefix = parsed?.prefix ?? [];
+                const suffix = parsed?.suffix ?? [];
+                for (const item of [...prefix, ...suffix]) {
+                    const name = item?.command?.name ?? item?.name;
+                    if (name && typeof name === 'string' && !names.includes(name))
+                        names.push(name);
+                }
+            }
+            catch {
+                // ignore parse error
+            }
+            if (names.length > 0)
+                return names;
+        }
+        const staticOutcomes = activityDef?.outcomes;
+        if (Array.isArray(staticOutcomes) && staticOutcomes.length > 0) {
+            const normalized = this.normalizeAllowedOutcomeList(staticOutcomes);
+            if (normalized.length > 0) {
+                return normalized;
+            }
+        }
+        return [BackendWorkflowEngineService_1.DEFAULT_UNMATCHED_OUTCOME];
+    }
+    /**
+     * Coerces workflow outcome/port values (string or legacy object shapes) to a plain label.
+     */
+    resolveOutcomeLabel(value) {
+        if (value == null || value === '') {
+            return null;
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            return trimmed.length > 0 ? trimmed : null;
+        }
+        if (typeof value === 'object') {
+            const record = value;
+            for (const key of ['name', 'value', 'outcome', 'port', 'id']) {
+                const resolved = this.resolveOutcomeLabel(record[key]);
+                if (resolved) {
+                    return resolved;
+                }
+            }
+        }
+        return null;
+    }
+    normalizeAllowedOutcomeList(values) {
+        const names = [];
+        for (const value of values) {
+            const label = this.resolveOutcomeLabel(value);
+            if (label && !names.includes(label)) {
+                names.push(label);
+            }
+        }
+        return names;
+    }
+    /**
+     * Normalize outcome: if it is in the allowed list, return as-is; otherwise use standard fallback and log.
+     */
+    normalizeOutcome(requestedOutcome, allowedOutcomes, stepId) {
+        const allowed = this.normalizeAllowedOutcomeList(allowedOutcomes);
+        const requested = this.resolveOutcomeLabel(requestedOutcome) ?? BackendWorkflowEngineService_1.DEFAULT_UNMATCHED_OUTCOME;
+        if (allowed.includes(requested)) {
+            return requested;
+        }
+        const caseInsensitive = allowed.find((allowedOutcome) => allowedOutcome.toLowerCase() === requested.toLowerCase());
+        if (caseInsensitive) {
+            return caseInsensitive;
+        }
+        console.warn(`[BackendWorkflowEngineService] ⚠️ Outcome "${requested}" not in allowed list [${allowed.join(', ')}] for step ${stepId}. Using "${BackendWorkflowEngineService_1.DEFAULT_UNMATCHED_OUTCOME}".`);
+        return BackendWorkflowEngineService_1.DEFAULT_UNMATCHED_OUTCOME;
+    }
+    /**
+     * Maps mistaken `Done` outcomes from `create-entity-form` when `persistInWorkflow` is true
+     * but command metadata was lost on the client (payload still contains `output.result`).
+     */
+    coerceCreateEntityFormOutcome(activity, requestedOutcome, output) {
+        if (!activity || activity.name !== 'workflow-activity:create-entity-form') {
+            return requestedOutcome;
+        }
+        if (requestedOutcome === 'Submitted' || requestedOutcome === 'Cancelled') {
+            return requestedOutcome;
+        }
+        const persistFlag = activity.inputs?.['persistInWorkflow'];
+        const persistInWorkflow = persistFlag === true || persistFlag === 'true';
+        if (!persistInWorkflow) {
+            return requestedOutcome;
+        }
+        if (requestedOutcome === 'Done' && this.extractPersistedEntityFormResult(output)) {
+            return 'Submitted';
+        }
+        return requestedOutcome;
+    }
+    findWorkflowConnection(connections, sourceStepId, outcome) {
+        const normalizedOutcome = this.resolveOutcomeLabel(outcome) ?? BackendWorkflowEngineService_1.DEFAULT_UNMATCHED_OUTCOME;
+        return connections.find((conn) => {
+            if (conn.source.activtyName !== sourceStepId) {
+                return false;
+            }
+            const port = this.resolveOutcomeLabel(conn.source.port);
+            if (!port) {
+                return normalizedOutcome === 'Done';
+            }
+            return port === normalizedOutcome || port.toLowerCase() === normalizedOutcome.toLowerCase();
+        });
+    }
+    /**
+     * Normalize value to a plain object for use as scope.outputs.
+     * Used when building expression scope so that outputs.* (e.g. outputs.result, outputs.action) is available.
+     */
+    ensureOutputsForScope(value) {
+        if (value == null)
+            return {};
+        if (typeof value === 'object' && !Array.isArray(value))
+            return { ...value };
+        return { value };
+    }
+    /**
+     * Extracts persisted create-entity-form payload (`data.result`) from a frontend step output.
+     */
+    extractPersistedEntityFormResult(output) {
+        const result = output['result'];
+        if (result && typeof result === 'object' && !Array.isArray(result)) {
+            return result;
+        }
+        return null;
+    }
+    /**
+     * Coerces date-like workflow values to a {@link Date} (local calendar date when input is `yyyy-mm-dd`).
+     */
+    coerceWorkflowDateValue(value) {
+        if (value == null) {
+            return null;
+        }
+        if (value instanceof Date) {
+            return Number.isNaN(value.getTime()) ? null : value;
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            const dateOnlyMatch = /^(\d{4})-(\d{2})-(\d{2})/.exec(trimmed);
+            if (dateOnlyMatch) {
+                const year = Number(dateOnlyMatch[1]);
+                const month = Number(dateOnlyMatch[2]);
+                const day = Number(dateOnlyMatch[3]);
+                const local = new Date(year, month - 1, day);
+                return Number.isNaN(local.getTime()) ? null : local;
+            }
+            const parsed = new Date(trimmed);
+            return Number.isNaN(parsed.getTime()) ? null : parsed;
+        }
+        return null;
+    }
+    /**
+     * Promotes `create-entity-form` submit payload (`output.result`) onto workflow variables
+     * so downstream steps and human tasks see form values (e.g. effectiveDate), not start inputs.
+     */
+    buildPersistedEntityFormVariablePromotions(output, activityName, outcome) {
+        if (activityName !== 'workflow-activity:create-entity-form' || outcome !== 'Submitted') {
+            return {};
+        }
+        const form = this.extractPersistedEntityFormResult(output);
+        if (!form) {
+            return {};
+        }
+        const promoted = {};
+        for (const [key, value] of Object.entries(form)) {
+            if (value == null || key === 'id') {
+                continue;
+            }
+            if (key === 'effectiveDate') {
+                const coerced = this.coerceWorkflowDateValue(value);
+                if (coerced) {
+                    promoted[key] = coerced;
+                }
+                continue;
+            }
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                promoted[key] = value;
+            }
+        }
+        return promoted;
+    }
+    /**
+     * Resume a suspended workflow instance.
+     *
+     * After frontend completes its task:
+     * 1. Validates taskToken (secure, non-guessable)
+     * 2. Verifies resumed activity matches currentStepId/bookmark
+     * 3. Marks related bookmark as consumed
+     * 4. Applies frontend outputs into workflow state
+     * 5. Traverses to next activity based on outcomes
+     * 6. Executes ALL backend activities until hitting frontend activity or completion
+     * 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);
+                }
+            }
+            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
+        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
+                };
+                // 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,
+                };
+            }
+            // Backend activity → execute it
+            console.log(`[BackendWorkflowEngineService] ⚙️ Executing backend activity '${currentActivity.name || currentActivity.id}' (${activityType})`);
+            const executionResult = await this.executeBackendActivityLocally(currentActivity, state, lastActivityOutputResume);
+            lastActivityOutputResume = 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',
+            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.
+     */
+    async getState(request) {
+        // Get instance from IndexedDB
+        const instance = await this.getInstance(request.instanceId);
+        if (!instance) {
+            throw new Error(`Workflow instance not found: ${request.instanceId}`);
+        }
+        // Convert instance to state (async - needs bookmark lookup)
+        return await this.instanceToInstanceState(instance);
+    }
+    /**
+     * Restores a suspended task-board step when the user declines a pre-interactive continuation prompt.
+     * Re-opens the human-task bookmark on the task board and removes the aborted inline step bookmark.
+     */
+    async revertResumeAfterDeclinedInteractiveContinuation(request) {
+        try {
+            const instance = await this.getInstance(request.instanceId);
+            if (!instance) {
+                return { success: false, error: `Workflow instance not found: ${request.instanceId}` };
+            }
+            if (request.abortedStepId) {
+                const abortedBookmarks = await this.store.getBookmarksByInstanceAndActivity(request.instanceId, request.abortedStepId, false);
+                for (const bookmark of abortedBookmarks) {
+                    if (!bookmark.isConsumed) {
+                        bookmark.isConsumed = true;
+                        await this.store.updateBookmark(bookmark);
+                    }
+                }
+            }
+            const suspendedBookmarks = await this.store.getBookmarksByInstanceAndActivity(request.instanceId, request.suspendedStepId, false);
+            let restoredBookmark = (request.bookmarkId
+                ? suspendedBookmarks.find((bookmark) => bookmark.id === request.bookmarkId)
+                : null) ?? suspendedBookmarks[0];
+            if (!restoredBookmark) {
+                return { success: false, error: 'Suspended step bookmark not found' };
+            }
+            const payload = this.parseBookmarkPayloadJson(restoredBookmark.payloadJson) ?? {};
+            const taskToken = this.generateTaskToken(request.instanceId, request.suspendedStepId);
+            payload['taskToken'] = taskToken;
+            restoredBookmark.payloadJson = JSON.stringify(payload);
+            restoredBookmark.isConsumed = false;
+            await this.store.updateBookmark(restoredBookmark);
+            const state = await this.getState({ instanceId: request.instanceId });
+            const revertedState = {
+                ...state,
+                status: 'suspended',
+                currentStepId: request.suspendedStepId,
+                lastUpdated: new Date(),
+            };
+            await this.updateInstanceFromState(request.instanceId, revertedState);
+            return {
+                success: true,
+                state: revertedState,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to revert workflow resume';
+            return { success: false, error: message };
+        }
+    }
+    /**
+     * Claim a pooled task (cartable or human-task with candidates only): assign current user without resuming.
+     */
+    async claimTask(request) {
+        const rawUserId = this.getSessionUser()?.id;
+        if (rawUserId === undefined || rawUserId === null || rawUserId === '') {
+            return { success: false, error: 'You must be signed in to claim a task' };
+        }
+        const uid = String(rawUserId);
+        const dexieInstance = await this.getInstance(request.instanceId).catch(() => null);
+        if (!dexieInstance) {
+            return this.claimTaskOnWorkflowInstanceEntity(request, uid);
+        }
+        const state = await this.getState({ instanceId: request.instanceId }).catch(() => null);
+        if (!state || state.status !== 'suspended') {
+            return { success: false, error: 'Workflow instance is not suspended or was not found' };
+        }
+        if (state.currentStepId && state.currentStepId !== request.stepId) {
+            return { success: false, error: 'Step does not match the current suspended step' };
+        }
+        const bookmarks = await this.getActiveBookmarks(request.instanceId);
+        const bookmark = bookmarks.find((b) => b.id === request.bookmarkId && b.activityId === request.stepId);
+        if (!bookmark) {
+            return { success: false, error: 'Bookmark not found or already completed' };
+        }
+        const payload = this.parseBookmarkPayloadJson(bookmark.payloadJson);
+        if (!payload) {
+            return { success: false, error: 'Invalid bookmark payload' };
+        }
+        const activityType = String(payload['activityType'] ?? '');
+        const assigned = this.normalizeUserIds(payload['assignedUserIds']) ?? [];
+        const candidates = this.normalizeUserIds(payload['candidateUserIds']) ?? [];
+        if (assigned.length > 0) {
+            return { success: false, error: 'This task is already claimed' };
+        }
+        const isCartable = activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.cartable;
+        const isPooledHuman = activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.humanTask && candidates.length > 0;
+        if (!isCartable && !isPooledHuman) {
+            return { success: false, error: 'This task cannot be claimed' };
+        }
+        if (isCartable && candidates.length === 0) {
+            return { success: false, error: 'Cartable task has no candidate users' };
+        }
+        const candidateSet = new Set(candidates.map((c) => String(c)));
+        if (!candidateSet.has(uid)) {
+            return { success: false, error: 'You are not in the candidate list for this task' };
+        }
+        payload['assignedUserIds'] = [uid];
+        payload['candidateUserIds'] = [];
+        bookmark.payloadJson = JSON.stringify(payload);
+        await this.store.updateBookmark(bookmark);
+        const instance = await this.getInstance(request.instanceId);
+        if (instance) {
+            await this.updateInstanceInEntityService(instance);
+        }
+        return { success: true };
+    }
+    /**
+     * Claim when execution state lives only on `WorkflowManagement.WorkflowInstance` (seeded / entity-only rows).
+     */
+    async claimTaskOnWorkflowInstanceEntity(request, uid) {
+        const entityName = 'WorkflowManagement.WorkflowInstance';
+        let row;
+        try {
+            row = (await this.entityStorageService.getOne(entityName, request.instanceId));
+        }
+        catch {
+            return { success: false, error: 'Workflow instance is not suspended or was not found' };
+        }
+        const subStatus = String(row['subStatus'] ?? '');
+        if (subStatus !== 'Suspended') {
+            return { success: false, error: 'Workflow instance is not suspended or was not found' };
+        }
+        const wi = row['workflowInstance'];
+        const bookmarksUnknown = wi?.['bookmarks'];
+        const bookmarks = Array.isArray(bookmarksUnknown) ? [...bookmarksUnknown] : [];
+        const idx = bookmarks.findIndex((b) => {
+            if (typeof b !== 'object' || b === null) {
+                return false;
+            }
+            const br = b;
+            return br['id'] === request.bookmarkId && br['activityId'] === request.stepId;
+        });
+        if (idx < 0) {
+            return { success: false, error: 'Bookmark not found or already completed' };
+        }
+        const bookmarkRow = bookmarks[idx];
+        const payloadJson = typeof bookmarkRow['payloadJson'] === 'string' ? bookmarkRow['payloadJson'] : null;
+        let payload = payloadJson ? this.parseBookmarkPayloadJson(payloadJson) : null;
+        if (!payload && bookmarkRow['payload'] && typeof bookmarkRow['payload'] === 'object') {
+            payload = { ...bookmarkRow['payload'] };
+        }
+        if (!payload) {
+            return { success: false, error: 'Invalid bookmark payload' };
+        }
+        const activityType = String(payload['activityType'] ?? '');
+        const assigned = this.normalizeUserIds(payload['assignedUserIds']) ?? [];
+        const candidates = this.normalizeUserIds(payload['candidateUserIds']) ?? [];
+        if (assigned.length > 0) {
+            return { success: false, error: 'This task is already claimed' };
+        }
+        const isCartable = activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.cartable;
+        const isPooledHuman = activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.humanTask && candidates.length > 0;
+        if (!isCartable && !isPooledHuman) {
+            return { success: false, error: 'This task cannot be claimed' };
+        }
+        if (isCartable && candidates.length === 0) {
+            return { success: false, error: 'Cartable task has no candidate users' };
+        }
+        const candidateSet = new Set(candidates.map((c) => String(c)));
+        if (!candidateSet.has(uid)) {
+            return { success: false, error: 'You are not in the candidate list for this task' };
+        }
+        payload['assignedUserIds'] = [uid];
+        payload['candidateUserIds'] = [];
+        const nextPayloadJson = JSON.stringify(payload);
+        const nextBookmark = {
+            ...bookmarkRow,
+            payload,
+            payloadJson: nextPayloadJson,
+        };
+        const nextBookmarks = [...bookmarks];
+        nextBookmarks[idx] = nextBookmark;
+        if (!wi) {
+            return { success: false, error: 'Workflow instance is not suspended or was not found' };
+        }
+        const nextWi = {
+            ...wi,
+            bookmarks: nextBookmarks,
+        };
+        try {
+            await this.entityStorageService.updateOne(entityName, request.instanceId, {
+                workflowInstance: nextWi,
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            console.warn('[BackendWorkflowEngineService] claimTask entity update failed', error);
+            return { success: false, error: 'Failed to persist claim' };
+        }
+        return { success: true };
+    }
+    /**
+     * Reassign a human-task bookmark to the current user (permission-gated; does not resume).
+     */
+    async reassignTaskToSelf(request) {
+        const rawUserId = this.getSessionUser()?.id;
+        if (rawUserId === undefined || rawUserId === null || rawUserId === '') {
+            return { success: false, error: 'You must be signed in to reassign a task' };
+        }
+        const uid = String(rawUserId);
+        if (!this.canReassignTaskToSelf()) {
+            return {
+                success: false,
+                error: 'You do not have permission to reassign this task to yourself',
+                errorCode: workflow_engine_errors_1.AXP_WORKFLOW_ERROR_CODES.REASSIGN_NOT_ALLOWED,
+            };
+        }
+        const dexieInstance = await this.getInstance(request.instanceId).catch(() => null);
+        if (!dexieInstance) {
+            return this.reassignTaskOnWorkflowInstanceEntity(request, uid);
+        }
+        const state = await this.getState({ instanceId: request.instanceId }).catch(() => null);
+        if (!state || state.status !== 'suspended') {
+            return { success: false, error: 'Workflow instance is not suspended or was not found' };
+        }
+        if (state.currentStepId && state.currentStepId !== request.stepId) {
+            return { success: false, error: 'Step does not match the current suspended step' };
+        }
+        const bookmarks = await this.getActiveBookmarks(request.instanceId);
+        const bookmark = bookmarks.find((b) => b.id === request.bookmarkId && b.activityId === request.stepId);
+        if (!bookmark) {
+            return { success: false, error: 'Bookmark not found or already completed' };
+        }
+        const payload = this.parseBookmarkPayloadJson(bookmark.payloadJson);
+        if (!payload) {
+            return { success: false, error: 'Invalid bookmark payload' };
+        }
+        const validation = this.validateHumanTaskReassignPayload(payload, uid);
+        if (validation.ok === false) {
+            return {
+                success: false,
+                error: validation.error,
+                errorCode: validation.errorCode,
+            };
+        }
+        const previousAssigned = validation.previousAssigned ?? [];
+        payload['assignedUserIds'] = [uid];
+        bookmark.payloadJson = JSON.stringify(payload);
+        await this.store.updateBookmark(bookmark);
+        const auditPatch = this.buildReassignAuditVariablePatch(request.stepId, previousAssigned, uid, state.variables);
+        const nextState = {
+            ...state,
+            variables: {
+                ...(state.variables || {}),
+                ...auditPatch,
+            },
+            lastUpdated: new Date(),
+        };
+        await this.updateInstanceFromState(request.instanceId, nextState);
+        const instance = await this.getInstance(request.instanceId);
+        if (instance) {
+            await this.updateInstanceInEntityService(instance);
+        }
+        return { success: true };
+    }
+    /**
+     * Reassign when execution state lives only on `WorkflowManagement.WorkflowInstance` (entity-only rows).
+     */
+    async reassignTaskOnWorkflowInstanceEntity(request, uid) {
+        const entityName = 'WorkflowManagement.WorkflowInstance';
+        let row;
+        try {
+            row = (await this.entityStorageService.getOne(entityName, request.instanceId));
+        }
+        catch {
+            return { success: false, error: 'Workflow instance is not suspended or was not found' };
+        }
+        const subStatus = String(row['subStatus'] ?? '');
+        if (subStatus !== 'Suspended') {
+            return { success: false, error: 'Workflow instance is not suspended or was not found' };
+        }
+        const wi = row['workflowInstance'];
+        const bookmarksUnknown = wi?.['bookmarks'];
+        const bookmarks = Array.isArray(bookmarksUnknown) ? [...bookmarksUnknown] : [];
+        const idx = bookmarks.findIndex((b) => {
+            if (typeof b !== 'object' || b === null) {
+                return false;
+            }
+            const br = b;
+            return br['id'] === request.bookmarkId && br['activityId'] === request.stepId;
+        });
+        if (idx < 0) {
+            return { success: false, error: 'Bookmark not found or already completed' };
+        }
+        const bookmarkRow = bookmarks[idx];
+        const payloadJson = typeof bookmarkRow['payloadJson'] === 'string' ? bookmarkRow['payloadJson'] : null;
+        let payload = payloadJson ? this.parseBookmarkPayloadJson(payloadJson) : null;
+        if (!payload && bookmarkRow['payload'] && typeof bookmarkRow['payload'] === 'object') {
+            payload = { ...bookmarkRow['payload'] };
+        }
+        if (!payload) {
+            return { success: false, error: 'Invalid bookmark payload' };
+        }
+        const validation = this.validateHumanTaskReassignPayload(payload, uid);
+        if (validation.ok === false) {
+            return {
+                success: false,
+                error: validation.error,
+                errorCode: validation.errorCode,
+            };
+        }
+        const previousAssigned = validation.previousAssigned ?? [];
+        payload['assignedUserIds'] = [uid];
+        const nextPayloadJson = JSON.stringify(payload);
+        const nextBookmark = {
+            ...bookmarkRow,
+            payload,
+            payloadJson: nextPayloadJson,
+        };
+        const nextBookmarks = [...bookmarks];
+        nextBookmarks[idx] = nextBookmark;
+        if (!wi) {
+            return { success: false, error: 'Workflow instance is not suspended or was not found' };
+        }
+        const workflowState = wi['workflowState'] ?? {};
+        const existingProperties = workflowState['properties'] ?? {};
+        const auditPatch = this.buildReassignAuditVariablePatch(request.stepId, previousAssigned, uid, existingProperties);
+        const properties = {
+            ...existingProperties,
+            ...auditPatch,
+        };
+        const nextWi = {
+            ...wi,
+            bookmarks: nextBookmarks,
+            workflowState: {
+                ...workflowState,
+                properties,
+            },
+        };
+        try {
+            await this.entityStorageService.updateOne(entityName, request.instanceId, {
+                workflowInstance: nextWi,
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            console.warn('[BackendWorkflowEngineService] reassignTaskToSelf entity update failed', error);
+            return { success: false, error: 'Failed to persist reassignment' };
+        }
+        return { success: true };
+    }
+    canReassignTaskToSelf() {
+        return !!this.getSessionUser()?.id;
+    }
+    validateHumanTaskReassignPayload(payload, uid) {
+        const activityType = String(payload['activityType'] ?? '');
+        if (activityType !== workflow_management_const_1.WorkflowManagementRootConfig.activities.humanTask) {
+            return { ok: false, error: 'Only human tasks can be reassigned to yourself' };
+        }
+        const assigned = this.normalizeUserIds(payload['assignedUserIds']) ?? [];
+        if (assigned.length === 0) {
+            return { ok: false, error: 'This task has no assignee to reassign from' };
+        }
+        if (assigned.includes(uid)) {
+            return { ok: false, error: 'You are already assigned to this task' };
+        }
+        // TODO(workflow): Require current user to be in candidateUserIds (or role candidates) before self-reassign.
+        // Permission alone is sufficient for now; tighten assignee pool validation in a follow-up.
+        return { ok: true, previousAssigned: assigned };
+    }
+    buildReassignAuditVariablePatch(stepId, fromUserIds, toUserId, existingVariables) {
+        const at = new Date().toISOString();
+        const entry = {
+            stepId,
+            fromUserIds,
+            toUserId,
+            at,
+        };
+        const priorHistory = existingVariables?.['taskReassignHistory'];
+        const history = Array.isArray(priorHistory) ? [...priorHistory, entry] : [entry];
+        return {
+            [`${stepId}_reassignedToSelf`]: entry,
+            taskReassignHistory: history,
+        };
+    }
+    //#region ----   Task-Based Helper Methods   ----
+    /**
+     * Activities that suspend for the task board (inbox), same completion path as human-task.
+     */
+    isTaskBoardSuspendGraphActivity(activityType) {
+        return activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.humanTask || activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.cartable;
+    }
+    /**
+     * Determine execution mode for an activity (async).
+     *
+     * Priority (highest to lowest):
+     * 1. Activity instance's executionMode (from AXPActivity in workflow definition)
+     * 2. ActivityDefinition's executionMode (from ActivityDefinitionService)
+     * 3. Default: 'frontend'
+     *
+     * @param activityType - Activity type (e.g., 'workflow-activity:show-toast')
+     * @param activity - Activity from workflow definition (AXPActivity)
+     * @returns Promise of execution mode: 'frontend', 'backend', or 'both'
+     */
+    async determineExecutionMode(activityType, activity) {
+        // 1. Check if executionMode is explicitly set in activity instance (highest priority)
+        if (activity?.metadata && activity.metadata['executionMode']) {
+            if (activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.humanTask) {
+                console.log(`[BackendWorkflowEngineService] determineExecutionMode(${activityType}): from instance metadata →`, activity.metadata['executionMode']);
+            }
+            return activity.metadata['executionMode'];
+        }
+        // 2. Check cache
+        const cached = this.activityDefinitionCache.get(activityType);
+        if (cached && Date.now() - cached.cachedAt.getTime() < this.CACHE_TTL_MS) {
+            if (activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.humanTask) {
+                console.log(`[BackendWorkflowEngineService] determineExecutionMode(${activityType}): from cache →`, cached.executionMode);
+            }
+            return cached.executionMode;
+        }
+        // 3. Query ActivityDefinitionService
+        try {
+            const activityDef = await this.activityDefinitionService.getActivityByName(activityType);
+            if (activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.humanTask) {
+                console.log(`[BackendWorkflowEngineService] determineExecutionMode(${activityType}): from definition →`, {
+                    definitionFound: !!activityDef,
+                    executionMode: activityDef?.executionMode,
+                    taskType: activityDef?.taskType,
+                });
+            }
+            if (activityDef?.executionMode) {
+                this.activityDefinitionCache.set(activityType, {
+                    executionMode: activityDef.executionMode,
+                    cachedAt: new Date(),
+                });
+                return activityDef.executionMode;
+            }
+        }
+        catch (error) {
+            console.warn(`[BackendWorkflowEngineService] ⚠️ Could not get activity definition for ${activityType}:`, error);
+        }
+        // 4. Default to frontend
+        const defaultMode = 'frontend';
+        if (activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.humanTask) {
+            console.log(`[BackendWorkflowEngineService] determineExecutionMode(${activityType}): using default →`, defaultMode);
+        }
+        this.activityDefinitionCache.set(activityType, {
+            executionMode: defaultMode,
+            cachedAt: new Date(),
+        });
+        return defaultMode;
+    }
+    //#endregion
+    /**
+     * Create a task from a workflow activity.
+     * Inspired by Temporal's Activity Task and Elsa's Bookmark pattern.
+     * Uses same expression scope (inputs, variables, outputs, context.eval) as backend execution.
+     */
+    async createTaskFromActivity(activity, state) {
+        const rawInputs = activity.inputs || {};
+        const scope = this.expressionScopeService.buildScopeFromState(state, this.ensureOutputsForScope(state.lastActivityOutput));
+        const properties = await this.expressionEvaluator.evaluate(rawInputs, scope);
+        if (rawInputs['persistInWorkflow'] !== undefined && properties['persistInWorkflow'] === undefined) {
+            properties['persistInWorkflow'] = await this.expressionEvaluator.evaluate(rawInputs['persistInWorkflow'], scope);
+        }
+        // Activity name is the registry key (e.g., 'workflow-activity:show-toast')
+        const activityType = activity.name;
+        // Get executionMode from activity descriptor (async)
+        const executionMode = await this.determineExecutionMode(activityType, activity);
+        // Get activity definition for title and taskType (taskType === 'human-task' → suspend for cartable)
+        const activityDef = await this.activityDefinitionService.getActivityByName(activityType);
+        const taskType = activity.metadata?.['taskType'] ?? activityDef?.taskType ?? 'ui-activity';
+        return {
+            taskToken: this.generateTaskToken(state.instanceId, activity.id),
+            activityId: activity.id,
+            activityType,
+            activityName: (0, multilanguage_util_1.resolveMultiLanguageString)(activityDef?.title) || activity.name || undefined,
+            executionMode,
+            taskType: taskType,
+            input: executionMode === 'frontend' || executionMode === 'both' ? properties : undefined,
+            config: executionMode === 'frontend' || executionMode === 'both' ? properties : undefined,
+            continuation: activityDef?.workflowContinuation,
+        };
+    }
+    /**
+     * Build variables table for entity: only variables defined in workflow definition (name, title, value).
+     */
+    computeWorkflowVariablesTable(instance, definition) {
+        const vars = instance.workflowState?.properties ?? {};
+        const out = instance.workflowState?.output ?? {};
+        const getValue = (key) => vars[key] ?? out[key];
+        const formatValue = (v) => {
+            if (v === null || v === undefined)
+                return '';
+            if (typeof v === 'object')
+                return JSON.stringify(v);
+            return String(v);
+        };
+        const defVars = definition?.variables ?? [];
+        return defVars.map((v) => ({
+            name: v.name,
+            title: (0, multilanguage_util_1.resolveMultiLanguageString)(v.title, 'en-US') || v.name,
+            value: formatValue(getValue(v.name)),
+        }));
+    }
+    /**
+     * Compute overview display fields for entity model (statusDisplay, step progress, etc.).
+     */
+    computeOverviewDisplayFields(instance, definition) {
+        const workflowTitle = instance.name || instance.definitionId || instance.id;
+        const statusDisplay = this.getWorkflowStatusDisplay(instance.status, instance.subStatus);
+        const contexts = instance.workflowState?.activityExecutionContexts ?? [];
+        const graph = definition?.graph;
+        const allActivities = graph?.activities ?? [];
+        const allConnections = graph?.connections ?? [];
+        // Fallback to previous linear logic when definition graph is unavailable.
+        if (!graph || allActivities.length === 0) {
+            const completedCount = contexts.filter((ctx) => ctx.status === 'Completed').length;
+            const hasRunning = contexts.some((ctx) => ctx.status === 'Running');
+            const currentStepIndex = hasRunning ? completedCount + 1 : completedCount;
+            const totalSteps = instance.workflowState?.totalSteps ?? (contexts.length > 0 ? contexts.length : 0);
+            const progressPercentage = totalSteps > 0 ? Math.min(100, Math.round((currentStepIndex / totalSteps) * 100)) : 0;
+            return { workflowTitle, statusDisplay, currentStepIndex, totalSteps, progressPercentage };
+        }
+        const completedSet = new Set(contexts
+            .filter((ctx) => ctx.status === 'Completed')
+            .map((ctx) => ctx.scheduledActivityNodeId)
+            .filter((id) => !!id));
+        const runningSet = new Set(contexts
+            .filter((ctx) => ctx.status === 'Running')
+            .map((ctx) => ctx.scheduledActivityNodeId)
+            .filter((id) => !!id));
+        const visitedSet = new Set([...completedSet, ...runningSet]);
+        const currentStepId = Array.from(runningSet)[0] ?? undefined;
+        // Extract chosen outcomes from workflow state (written as `${stepId}_outcome`).
+        const outcomeByStep = new Map();
+        const stateProperties = instance.workflowState?.properties ?? {};
+        for (const [key, value] of Object.entries(stateProperties)) {
+            if (!key.endsWith('_outcome') || typeof value !== 'string') {
+                continue;
+            }
+            const stepId = key.slice(0, -'_outcome'.length);
+            if (stepId) {
+                outcomeByStep.set(stepId, value);
+            }
+        }
+        // Build incoming map to infer start step when startActivityId is not set.
+        const incomingMap = new Map();
+        for (const connection of allConnections) {
+            const targetId = connection.target.activtyName;
+            incomingMap.set(targetId, (incomingMap.get(targetId) ?? 0) + 1);
+        }
+        let startStepId = graph.startActivityId;
+        if (!startStepId) {
+            const root = allActivities.find((activity) => (incomingMap.get(activity.id) ?? 0) === 0);
+            startStepId = root?.id ?? allActivities[0]?.id;
+        }
+        // Resolve the "active path" by following decided outcomes and preferring visited targets.
+        const resolveNextStepId = (stepId) => {
+            const outgoing = allConnections.filter((connection) => connection.source.activtyName === stepId);
+            if (outgoing.length === 0) {
+                return null;
+            }
+            const chosenOutcome = outcomeByStep.get(stepId);
+            if (chosenOutcome) {
+                const exact = outgoing.find((connection) => connection.source.port === chosenOutcome);
+                if (exact) {
+                    return exact.target.activtyName;
+                }
+            }
+            if (currentStepId) {
+                const toCurrent = outgoing.find((connection) => connection.target.activtyName === currentStepId);
+                if (toCurrent) {
+                    return toCurrent.target.activtyName;
+                }
+            }
+            const toVisited = outgoing.find((connection) => visitedSet.has(connection.target.activtyName));
+            if (toVisited) {
+                return toVisited.target.activtyName;
+            }
+            const donePort = outgoing.find((connection) => connection.source.port === 'Done');
+            if (donePort) {
+                return donePort.target.activtyName;
+            }
+            return outgoing[0]?.target.activtyName ?? null;
+        };
+        const path = [];
+        const seen = new Set();
+        const maxDepth = Math.max(1, allActivities.length * 3);
+        let cursor = startStepId;
+        while (cursor && !seen.has(cursor) && path.length < maxDepth) {
+            path.push(cursor);
+            seen.add(cursor);
+            if (currentStepId && cursor === currentStepId) {
+                break;
+            }
+            cursor = resolveNextStepId(cursor);
+        }
+        if (currentStepId && !path.includes(currentStepId)) {
+            path.push(currentStepId);
+        }
+        const totalSteps = path.length > 0 ? path.length : allActivities.length;
+        const completedCount = path.filter((stepId) => completedSet.has(stepId)).length;
+        const hasRunning = !!currentStepId && path.includes(currentStepId);
+        const currentStepIndex = Math.min(totalSteps, hasRunning ? completedCount + 1 : completedCount);
+        const progressPercentage = instance.status === 'Finished'
+            ? 100
+            : totalSteps > 0
+                ? Math.min(100, Math.round((currentStepIndex / totalSteps) * 100))
+                : 0;
+        return { workflowTitle, statusDisplay, currentStepIndex, totalSteps, progressPercentage };
+    }
+    /**
+     * Compute runtime details for task board style overview fields.
+     */
+    computeRuntimeDetails(instance, definition, activeBookmarks) {
+        const currentStepId = this.resolveCurrentStepId(instance, activeBookmarks);
+        if (!definition?.graph || !currentStepId) {
+            return {
+                currentActivityTitle: 'N/A',
+                nextActivityTitle: instance.status === 'Finished' ? 'Completed' : 'N/A',
+            };
+        }
+        const graph = definition.graph;
+        const currentActivity = this.findActivityInGraph(graph, currentStepId);
+        const primaryBookmark = activeBookmarks.find((bookmark) => bookmark.activityId === currentStepId) ?? activeBookmarks[0] ?? null;
+        const bookmarkPayload = this.parseBookmarkPayloadJson(primaryBookmark?.payloadJson);
+        const currentActivityTitle = this.resolveActivityTitle(currentActivity, bookmarkPayload, currentStepId);
+        const nextActivityTitle = this.resolveNextActivityTitle(graph, currentStepId, instance, definition);
+        return {
+            currentActivityTitle,
+            nextActivityTitle,
+        };
+    }
+    /**
+     * Human-task / cartable bookmark types that surface on the task board.
+     */
+    isTaskBoardHumanBookmarkPayload(payload) {
+        if (!payload) {
+            return false;
+        }
+        const t = payload['activityType'];
+        return t === workflow_management_const_1.WorkflowManagementRootConfig.activities.humanTask || t === workflow_management_const_1.WorkflowManagementRootConfig.activities.cartable;
+    }
+    /**
+     * Primary user id for assignee column: suspended task-board bookmark (assigned, then candidate users),
+     * otherwise last completed step with a persisted user id.
+     */
+    resolvePrimaryAssignUserId(instance, activeBookmarks) {
+        const suspended = instance.subStatus === 'Suspended';
+        if (suspended && activeBookmarks.length > 0) {
+            const sorted = [...activeBookmarks].sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+            for (const bm of sorted) {
+                const payload = this.parseBookmarkPayloadJson(bm.payloadJson);
+                if (!this.isTaskBoardHumanBookmarkPayload(payload)) {
+                    continue;
+                }
+                const assigned = this.normalizeUserIds(payload?.['assignedUserIds']) ?? [];
+                if (assigned.length > 0) {
+                    return assigned[0];
+                }
+                const candidates = this.normalizeUserIds(payload?.['candidateUserIds']) ?? [];
+                if (candidates.length > 0) {
+                    return candidates[0];
+                }
+            }
+        }
+        return this.resolveLastPerformerUserId(instance);
+    }
+    /**
+     * Last completed activity's `completedByUserId` from workflow state properties.
+     */
+    resolveLastPerformerUserId(instance) {
+        const props = (instance.workflowState?.properties ?? {});
+        const contexts = [...(instance.workflowState?.activityExecutionContexts ?? [])];
+        contexts.sort((a, b) => new Date(a.startedAt).getTime() - new Date(b.startedAt).getTime());
+        let lastId;
+        for (const ctx of contexts) {
+            const completed = ctx.status === 'Completed' || (ctx.completedAt != null && String(ctx.completedAt).trim().length > 0);
+            if (!completed) {
+                continue;
+            }
+            const nodeId = ctx.scheduledActivityNodeId;
+            const uid = props[`${nodeId}_completedByUserId`];
+            if (uid != null && String(uid).trim() !== '') {
+                lastId = String(uid).trim();
+            }
+        }
+        return lastId;
+    }
+    /**
+     * Lookup user row for WorkflowInstance list/detail lookup column.
+     */
+    async resolveAssignUserLookupFields(userId) {
+        if (!userId) {
+            return {};
+        }
+        const entityName = 'SecurityManagement.User';
+        try {
+            const row = await this.entityStorageService.getOne(entityName, userId);
+            const displayName = row && typeof row === 'object' && row !== null && 'displayName' in row
+                ? String(row.displayName ?? '').trim()
+                : '';
+            const label = displayName.length > 0 ? displayName : userId;
+            return {
+                assignUser: { id: userId },
+                assignUserRef: { id: userId, displayName: label },
+            };
+        }
+        catch {
+            return {
+                assignUser: { id: userId },
+                assignUserRef: { id: userId, displayName: userId },
+            };
+        }
+    }
+    /**
+     * Resolve current step from active bookmark first, then running context.
+     */
+    resolveCurrentStepId(instance, activeBookmarks) {
+        if (activeBookmarks.length > 0) {
+            const latestBookmark = [...activeBookmarks].sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())[0];
+            return latestBookmark.activityId ?? null;
+        }
+        const contexts = instance.workflowState?.activityExecutionContexts ?? [];
+        const runningContext = contexts.find((ctx) => ctx.status === 'Running' && !ctx.completedAt);
+        return runningContext?.scheduledActivityNodeId ?? null;
+    }
+    /**
+     * Resolve friendly activity title using payload/title inputs and fallback label.
+     */
+    resolveActivityTitle(activity, bookmarkPayload, fallbackId) {
+        const payloadTitle = bookmarkPayload?.['title'];
+        if (typeof payloadTitle === 'string' && payloadTitle.trim().length > 0) {
+            return payloadTitle.trim();
+        }
+        const inputTitle = activity?.inputs?.['title'];
+        if (typeof inputTitle === 'string' && inputTitle.trim().length > 0) {
+            return inputTitle.trim();
+        }
+        return this.formatReadableLabel(activity?.id ?? fallbackId);
+    }
+    /**
+     * Resolve next activity title from workflow graph and known outcome.
+     */
+    resolveNextActivityTitle(graph, currentStepId, instance, definition) {
+        const outgoing = (graph.connections ?? []).filter((connection) => connection.source.activtyName === currentStepId);
+        if (outgoing.length === 0) {
+            return instance.status === 'Finished' ? 'Completed' : 'N/A';
+        }
+        const currentOutcomeKey = `${currentStepId}_outcome`;
+        const currentOutcome = instance.workflowState?.properties?.[currentOutcomeKey];
+        if (typeof currentOutcome === 'string' && currentOutcome.length > 0) {
+            const matched = outgoing.find((connection) => connection.source.port === currentOutcome);
+            if (matched) {
+                const target = this.findActivityInGraph(graph, matched.target.activtyName);
+                return this.resolveActivityTitle(target, null, matched.target.activtyName);
+            }
+        }
+        if (outgoing.length === 1) {
+            const target = this.findActivityInGraph(graph, outgoing[0].target.activtyName);
+            return this.resolveActivityTitle(target, null, outgoing[0].target.activtyName);
+        }
+        const nextOptions = outgoing.map((connection) => {
+            const target = this.findActivityInGraph(graph, connection.target.activtyName);
+            const targetTitle = this.resolveActivityTitle(target, null, connection.target.activtyName);
+            const port = connection.source.port || 'Done';
+            return `${port}: ${targetTitle}`;
+        });
+        return nextOptions.join(' | ');
+    }
+    /**
+     * Parse bookmark payload safely.
+     */
+    parseBookmarkPayloadJson(payloadJson) {
+        if (!payloadJson) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(payloadJson);
+            return parsed && typeof parsed === 'object' ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Convert technical identifier to readable title-case label.
+     */
+    formatReadableLabel(value) {
+        return value
+            .replace(/^workflow-activity:/, '')
+            .replace(/([a-z])([A-Z])/g, '$1 $2')
+            .replace(/[-_]/g, ' ')
+            .split(' ')
+            .filter((token) => token.length > 0)
+            .map((token) => token.charAt(0).toUpperCase() + token.slice(1))
+            .join(' ');
+    }
+    /**
+     * Build a user-friendly task board status from workflow status and sub-status.
+     * Returns plain English labels instead of translation keys.
+     */
+    getWorkflowStatusDisplay(status, subStatus) {
+        const normalizedStatus = (status ?? '').toString().trim().toLowerCase();
+        const normalizedSubStatus = (subStatus ?? '').toString().trim().toLowerCase();
+        const stateKey = `${normalizedStatus}:${normalizedSubStatus}`;
+        const combinedLabels = {
+            'running:executing': 'In Progress',
+            'running:suspended': 'Pending User Action',
+            'running:idle': 'Waiting',
+            running: 'In Progress',
+            'finished:finished': 'Completed',
+            'finished:faulted': 'Failed',
+            'finished:cancelled': 'Cancelled',
+            finished: 'Completed',
+        };
+        const exactMatch = combinedLabels[stateKey];
+        if (exactMatch) {
+            return exactMatch;
+        }
+        const statusOnlyMatch = combinedLabels[normalizedStatus];
+        if (statusOnlyMatch) {
+            return statusOnlyMatch;
+        }
+        if (normalizedSubStatus.includes('suspend')) {
+            return 'Pending User Action';
+        }
+        if (normalizedSubStatus.includes('fault') || normalizedSubStatus.includes('error')) {
+            return 'Failed';
+        }
+        if (normalizedSubStatus.includes('cancel')) {
+            return 'Cancelled';
+        }
+        if (normalizedSubStatus.includes('finish') || normalizedSubStatus.includes('complete')) {
+            return 'Completed';
+        }
+        if (normalizedSubStatus.includes('execut')) {
+            return 'In Progress';
+        }
+        const fallbackTokens = [status, subStatus]
+            .filter((value) => typeof value === 'string' && value.trim().length > 0)
+            .map((value) => value.replace(/([a-z])([A-Z])/g, '$1 $2').trim());
+        return fallbackTokens.length > 0 ? fallbackTokens.join(' - ') : 'Unknown';
+    }
+    /**
+     * Save workflow instance to entity service for entity-based access.
+     */
+    async saveInstanceToEntityService(instance) {
+        try {
+            // Get active bookmarks for this instance to include in entity model
+            const activeBookmarks = await this.getActiveBookmarks(instance.id);
+            // Add bookmarks to instance for entity storage access
+            const instanceWithBookmarks = {
+                ...instance,
+                bookmarks: activeBookmarks.map((b) => ({
+                    id: b.id,
+                    activityId: b.activityId,
+                    activityInstanceId: b.activityId, // For compatibility
+                    type: b.type,
+                    payload: b.payloadJson ? JSON.parse(b.payloadJson) : null,
+                    payloadJson: b.payloadJson,
+                    consumed: b.isConsumed,
+                    isConsumed: b.isConsumed,
+                    createdAt: b.createdAt,
+                })),
+            };
+            const definition = 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));
+            const entityModel = {
+                id: instance.id,
+                definitionId: instance.definitionId,
+                definitionVersionId: instance.definitionVersionId,
+                version: instance.version,
+                status: instance.status,
+                subStatus: instance.subStatus,
+                correlationId: instance.correlationId || undefined,
+                name: instance.name || undefined,
+                incidentCount: instance.incidentCount,
+                parentWorkflowInstanceId: instance.parentWorkflowInstanceId || undefined,
+                createdAt: instance.createdAt,
+                updatedAt: instance.updatedAt,
+                finishedAt: instance.finishedAt || undefined,
+                workflowInstance: instanceWithBookmarks, // Include bookmarks
+                workflowTitle: overview.workflowTitle,
+                statusDisplay: overview.statusDisplay,
+                startedAt: instance.createdAt,
+                ...assignUserFields,
+                currentActivityTitle: runtimeDetails.currentActivityTitle,
+                nextActivityTitle: runtimeDetails.nextActivityTitle,
+                currentStepIndex: overview.currentStepIndex,
+                totalSteps: overview.totalSteps,
+                progressPercentage: overview.progressPercentage,
+                workflowVariablesTable,
+            };
+            const entityName = 'WorkflowManagement.WorkflowInstance';
+            // Check if instance already exists
+            try {
+                const existing = await this.entityStorageService.getOne(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', {
+                        instanceId: instance.id,
+                    });
+                    return;
+                }
+            }
+            catch (getError) {
+                // Instance doesn't exist - proceed with insert
+            }
+            // Insert new instance
+            await this.entityStorageService.insertOne(entityName, entityModel);
+            console.log('[AXCWorkflowExecutionService] ✅ Inserted new instance in entity service', {
+                instanceId: instance.id,
+                status: instance.status,
+                subStatus: instance.subStatus,
+            });
+        }
+        catch (error) {
+            console.warn('[AXCWorkflowExecutionService] Failed to save instance to entity service:', error);
+            // Don't throw - IndexedDB is primary storage
+        }
+    }
+    /**
+     * Update workflow instance in entity service.
+     * Uses upsert pattern: try update first, if fails then insert.
+     */
+    async updateInstanceInEntityService(instance) {
+        try {
+            // Get active bookmarks for this instance to include in entity model
+            const activeBookmarks = await this.getActiveBookmarks(instance.id);
+            // Add bookmarks to instance for entity storage access
+            const instanceWithBookmarks = {
+                ...instance,
+                bookmarks: activeBookmarks.map((b) => ({
+                    id: b.id,
+                    activityId: b.activityId,
+                    activityInstanceId: b.activityId, // For compatibility
+                    type: b.type,
+                    payload: b.payloadJson ? JSON.parse(b.payloadJson) : null,
+                    payloadJson: b.payloadJson,
+                    consumed: b.isConsumed,
+                    isConsumed: b.isConsumed,
+                    createdAt: b.createdAt,
+                })),
+            };
+            const definition = 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));
+            const entityModel = {
+                id: instance.id,
+                definitionId: instance.definitionId,
+                definitionVersionId: instance.definitionVersionId,
+                version: instance.version,
+                status: instance.status,
+                subStatus: instance.subStatus,
+                correlationId: instance.correlationId || undefined,
+                name: instance.name || undefined,
+                incidentCount: instance.incidentCount,
+                parentWorkflowInstanceId: instance.parentWorkflowInstanceId || undefined,
+                createdAt: instance.createdAt,
+                updatedAt: instance.updatedAt,
+                finishedAt: instance.finishedAt || undefined,
+                workflowInstance: instanceWithBookmarks, // Include bookmarks
+                workflowTitle: overview.workflowTitle,
+                statusDisplay: overview.statusDisplay,
+                startedAt: instance.createdAt,
+                ...assignUserFields,
+                currentActivityTitle: runtimeDetails.currentActivityTitle,
+                nextActivityTitle: runtimeDetails.nextActivityTitle,
+                currentStepIndex: overview.currentStepIndex,
+                totalSteps: overview.totalSteps,
+                progressPercentage: overview.progressPercentage,
+                workflowVariablesTable,
+            };
+            const entityName = 'WorkflowManagement.WorkflowInstance';
+            // Try update first (upsert pattern)
+            try {
+                await this.entityStorageService.updateOne(entityName, entityModel.id, entityModel);
+                console.log('[AXCWorkflowExecutionService] ✅ Updated instance in entity service', {
+                    instanceId: instance.id,
+                    status: instance.status,
+                    subStatus: instance.subStatus,
+                });
+                return; // Successfully updated, exit
+            }
+            catch (updateError) {
+                // Update failed - instance doesn't exist, try insert
+                console.log('[AXCWorkflowExecutionService] ℹ️ Update failed, trying insert', {
+                    instanceId: instance.id,
+                    error: updateError.message,
+                });
+            }
+            // Try insert
+            try {
+                await this.entityStorageService.insertOne(entityName, entityModel);
+                console.log('[AXCWorkflowExecutionService] ✅ Inserted instance in entity service', {
+                    instanceId: instance.id,
+                    status: instance.status,
+                    subStatus: instance.subStatus,
+                });
+            }
+            catch (insertError) {
+                // 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);
+                    console.log('[AXCWorkflowExecutionService] ✅ Updated instance in entity service (after insert failed)', {
+                        instanceId: instance.id,
+                        status: instance.status,
+                        subStatus: instance.subStatus,
+                    });
+                }
+                catch (finalError) {
+                    console.warn('[AXCWorkflowExecutionService] Failed to upsert instance in entity service:', finalError);
+                }
+            }
+        }
+        catch (error) {
+            console.warn('[AXCWorkflowExecutionService] Failed to update instance in entity service:', error);
+            // Don't throw - IndexedDB is primary storage
+        }
+    }
+    //#endregion
+    //#region ----   Backend Activity Executors   ----
+    /**
+     * Evaluates activity inputs against current workflow scope (same as backend execution).
+     */
+    async evaluateActivityInputs(activity, state, lastOutput) {
+        const scope = this.expressionScopeService.buildScopeFromState(state, this.ensureOutputsForScope(lastOutput));
+        return (await this.expressionEvaluator.evaluate(activity.inputs || {}, scope));
+    }
+    /**
+     * After entity-create: link instance entity ref and persist {@link AXPRecordWorkflowInfo} on the row.
+     */
+    async linkEntityRecordAfterCreate(instanceId, activity, state, lastOutput, entityId) {
+        const properties = await this.evaluateActivityInputs(activity, state, lastOutput);
+        const entityType = typeof properties['entity'] === 'string' ? properties['entity'].trim() : '';
+        const recordId = entityId?.trim();
+        if (!entityType || !recordId) {
+            return;
+        }
+        const instance = await this.store.getInstance(instanceId);
+        const definitionId = instance?.definitionId ?? instance?.workflowState?.definitionId ?? state.workflowId ?? null;
+        const correlationId = instance?.correlationId ?? instance?.workflowState?.correlationId ?? null;
+        await (0, entity_workflow_info_sync_1.syncEntityRecordWorkflowInfo)(this.entityStorageService, this.store, {
+            entityType,
+            entityId: recordId,
+            instanceId,
+            definitionId: definitionId != null ? String(definitionId) : null,
+            correlationId: correlationId != null ? String(correlationId) : null,
+        });
+    }
+    /**
+     * Execute backend activities locally via {@link WorkflowActivityRegistryService}.
+     *
+     * Uses WorkflowExpressionScopeService + WorkflowExpressionEvaluatorService for expression
+     * evaluation (inputs, variables, outputs, context.eval) so backend activities get the
+     * same expression handling as the platform ActivityExecutor.
+     */
+    async executeBackendActivityLocally(activity, state, lastOutput) {
+        const rawInputs = activity.inputs || {};
+        // Evaluate expressions using same scope as platform (inputs, variables, outputs = lastActivityOutput)
+        const scope = this.expressionScopeService.buildScopeFromState(state, this.ensureOutputsForScope(lastOutput));
+        const properties = (await this.expressionEvaluator.evaluate(rawInputs, scope));
+        const activityType = activity.name;
+        return this.activityRegistry.execute(activityType, properties, {
+            entityStorage: this.entityStorageService,
+            sessionService: this.sessionService,
+        });
+    }
+    /**
+     * Build variable updates from activity output using activity's outputToVariables (BPMN-style: activity → variable).
+     * For each entry in activity.outputToVariables, sets variables[variableName] = output[outputPath].
+     */
+    getVariableUpdatesFromOutput(workflow, activityId, output) {
+        const activity = this.findActivityInGraph(workflow.graph, activityId);
+        const outputToVariables = activity?.outputToVariables;
+        if (!outputToVariables || typeof outputToVariables !== 'object')
+            return {};
+        const updates = {};
+        for (const [variableName, outputPath] of Object.entries(outputToVariables)) {
+            const path = String(outputPath);
+            const value = path.split('.').reduce((obj, key) => obj?.[key], output);
+            if (value !== undefined)
+                updates[variableName] = value;
+        }
+        return updates;
+    }
+    /**
+     * Resolves human-task bookmark title from evaluated inputs, then context, then activity definition.
+     */
+    resolveHumanTaskBookmarkTitle(inputs, activityDef, currentActivity) {
+        const rawTitle = inputs['title'];
+        if (typeof rawTitle === 'string' && rawTitle.trim().length > 0) {
+            return rawTitle.trim();
+        }
+        const ctx = inputs['context'];
+        if (ctx != null && typeof ctx === 'object') {
+            const composed = this.composeHumanTaskTitleFromContext(ctx);
+            if (composed) {
+                return composed;
+            }
+        }
+        const activityTitle = activityDef?.title;
+        const resolvedActivityTitle = activityTitle != null ? (0, multilanguage_util_1.resolveMultiLanguageString)(activityTitle) : '';
+        return resolvedActivityTitle || currentActivity.name || 'Workflow Task';
+    }
+    /**
+     * Builds title from `context._taskTitleParts` when activity title input did not resolve.
+     */
+    composeHumanTaskTitleFromContext(context) {
+        const parts = context[AXP_WORKFLOW_TASK_CONTEXT_TITLE_PARTS_KEY];
+        if (!Array.isArray(parts)) {
+            return '';
+        }
+        return parts
+            .map((part) => this.humanTaskContextLabel(part))
+            .filter((segment) => segment.length > 0)
+            .join(' — ');
+    }
+    humanTaskContextLabel(value) {
+        if (value == null) {
+            return '';
+        }
+        if (typeof value === 'string') {
+            return value.trim();
+        }
+        if (typeof value === 'object') {
+            return (0, multilanguage_util_1.resolveMultiLanguageString)(value)?.trim() ?? '';
+        }
+        return String(value).trim();
+    }
+    /**
+     * Normalize user/role id field to array for bookmark payload (task board expects array).
+     * Expression may evaluate to single string (e.g. {{ variables.managerId }}) or already array.
+     */
+    normalizeUserIds(value) {
+        if (value == null)
+            return null;
+        const raw = Array.isArray(value) ? value : [value];
+        const trimmed = raw.map((id) => String(id).trim()).filter((id) => id.length > 0);
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    /**
+     * Diagnostic logging for human-task bookmark assignment (task board assignee).
+     * Filter the browser console by `[WFM-LifecycleTaskTrace]`.
+     */
+    logHumanTaskBookmarkAssignmentTrace(info) {
+        const v = info.variables ?? {};
+        console.log('[WFM-LifecycleTaskTrace] human-task bookmark', {
+            phase: info.phase,
+            instanceId: info.instanceId,
+            workflowDefinitionName: info.workflowDefinitionName,
+            activityId: info.activityId,
+            activityType: info.activityType,
+            sessionUserId: this.getSessionUser()?.id ?? null,
+            rawAssignedUserIds: info.rawAssignedUserIds,
+            rawAssignedUserIdsType: typeof info.rawAssignedUserIds,
+            normalizedAssignedUserIds: info.normalizedAssignedUserIds,
+            lifecycleVariableSlice: {
+                employeeId: v['employeeId'],
+                assigneeUserId: v['assigneeUserId'],
+                managerUserId: v['managerUserId'],
+                initiatorUserId: v['initiatorUserId'],
+                targetEmployeeStatusId: v['targetEmployeeStatusId'],
+                questionnaireId: v['questionnaireId'],
+            },
+        });
+    }
+    //#endregion
+    //#region ----   Bookmark Management   ----
+    /**
+     * Create a bookmark for a workflow instance.
+     * Aligns with ERD: BOOKMARK table structure.
+     *
+     * @param instanceId - Workflow instance ID
+     * @param activityId - Activity ID where bookmark is created
+     * @param type - Bookmark type (e.g., 'user-task', 'event', 'timer')
+     * @param payload - Bookmark payload data
+     * @returns Bookmark ID
+     */
+    async createBookmark(instanceId, activityId, type, payload) {
+        const bookmarkId = (0, uuid_util_1.generateUuid)();
+        const hash = (0, uuid_util_1.generateUuid)(); // Simple hash for now
+        const now = new Date().toISOString();
+        const bookmark = {
+            id: bookmarkId,
+            instanceId,
+            activityId,
+            type,
+            hash,
+            payloadJson: JSON.stringify(payload),
+            isConsumed: false,
+            createdAt: now,
+        };
+        await this.store.addBookmark(bookmark);
+        console.log(`[BackendWorkflowEngineService] 📌 Created bookmark: ${bookmarkId} for activity ${activityId}`);
+        return bookmarkId;
+    }
+    /**
+     * Consume (mark as consumed) a bookmark for a workflow instance.
+     *
+     * @param instanceId - Workflow instance ID
+     * @param activityId - Activity ID of the bookmark to consume
+     */
+    async consumeBookmark(instanceId, activityId) {
+        const bookmarks = await this.store.getBookmarksByInstanceAndActivity(instanceId, activityId, true);
+        for (const bookmark of bookmarks) {
+            bookmark.isConsumed = true;
+            await this.store.updateBookmark(bookmark);
+            console.log(`[BackendWorkflowEngineService] ✅ Consumed bookmark: ${bookmark.id} for activity ${activityId}`);
+        }
+    }
+    /**
+     * Get active bookmarks for a workflow instance.
+     *
+     * @param instanceId - Workflow instance ID
+     * @returns Array of active (non-consumed) bookmarks
+     */
+    async getActiveBookmarks(instanceId) {
+        return this.store.getActiveBookmarks(instanceId);
+    }
+    //#endregion
+    //#region ----   Instance Management   ----
+    /**
+     * Convert workflow instance to instance state.
+     *
+     * Aligns with ERD structure:
+     * - WORKFLOW_INSTANCE: header fields (status, subStatus, timestamps)
+     * - WORKFLOW_INSTANCE_STATE: heavy state (input, output, properties, stateJson)
+     * - BOOKMARK: separate table (used to derive currentStepId)
+     */
+    async instanceToInstanceState(instance) {
+        const state = instance.workflowState;
+        // Derive currentStepId from active bookmarks (preferred) or execution contexts
+        let currentStepId;
+        // Try to get from active bookmarks first
+        const activeBookmarks = await this.getActiveBookmarks(instance.id);
+        if (activeBookmarks.length > 0) {
+            // Use the most recent bookmark's activityId
+            const latestBookmark = activeBookmarks.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())[0];
+            currentStepId = latestBookmark.activityId;
+        }
+        else {
+            // Fallback to execution contexts
+            const currentContext = state.activityExecutionContexts.find((ctx) => ctx.status === 'Running' && !ctx.completedAt);
+            currentStepId = currentContext?.scheduledActivityNodeId;
+        }
+        // Map status from instance header fields (ERD: WORKFLOW_INSTANCE.status/subStatus)
+        let status = 'running';
+        if (instance.status === 'Finished') {
+            if (instance.subStatus === 'Faulted') {
+                status = 'error';
+            }
+            else {
+                status = 'completed';
+            }
+        }
+        else if (instance.subStatus === 'Suspended') {
+            status = 'suspended';
+        }
+        // Extract state from workflowState (ERD: WORKFLOW_INSTANCE_STATE). Only last activity output is loaded.
+        const properties = (state.properties || {});
+        const { __lastActivityOutput, ...variables } = properties;
+        const lastActivityOutput = __lastActivityOutput;
+        const input = state.input || {};
+        const output = state.output || {};
+        // Normalize dates (instance.updatedAt is always string in AXPWorkflowInstance)
+        const lastUpdated = instance.updatedAt ? new Date(instance.updatedAt) : new Date();
+        return {
+            instanceId: instance.id,
+            workflowId: instance.definitionId,
+            status,
+            currentStepId,
+            variables,
+            lastActivityOutput,
+            input,
+            output,
+            lastUpdated,
+        };
+    }
+    /**
+     * Update instance state in instance and save to IndexedDB.
+     *
+     * Aligns with ERD structure:
+     * - WORKFLOW_INSTANCE: header fields (status, subStatus, timestamps, correlationId)
+     * - WORKFLOW_INSTANCE_STATE: heavy state (input, output, properties, stateJson)
+     *
+     * Handles status transitions correctly:
+     * - running → suspended (when frontend activity encountered)
+     * - suspended → running → completed (when workflow finishes)
+     * - any → error (on errors)
+     */
+    async updateInstanceFromState(instanceId, instanceState) {
+        const instance = await this.getInstance(instanceId);
+        if (!instance) {
+            throw new Error(`Workflow instance not found: ${instanceId}`);
+        }
+        // Update instance from state
+        const now = new Date().toISOString();
+        // Map state status to instance status (ERD: WORKFLOW_INSTANCE.status/subStatus)
+        let status = 'Running';
+        let subStatus = 'Executing';
+        // Handle status transitions
+        if (instanceState.status === 'completed') {
+            console.log('[BackendWorkflowEngineService] ✅ Marking workflow as Finished');
+            status = 'Finished';
+            subStatus = 'Finished';
+            instance.finishedAt = now;
+        }
+        else if (instanceState.status === 'error') {
+            status = 'Finished';
+            subStatus = 'Faulted';
+            instance.finishedAt = now;
+        }
+        else if (instanceState.status === 'suspended') {
+            subStatus = 'Suspended';
+        }
+        else if (instanceState.status === 'running') {
+            subStatus = 'Executing';
+        }
+        // Update WORKFLOW_INSTANCE header fields (ERD)
+        instance.status = status;
+        instance.subStatus = subStatus;
+        instance.updatedAt = now;
+        // Update WORKFLOW_INSTANCE_STATE heavy state (ERD). Only last activity output is persisted; exposed as scope.outputs.
+        instance.workflowState.status = status;
+        instance.workflowState.subStatus = subStatus;
+        instance.workflowState.input = instanceState.input || {};
+        instance.workflowState.output = instanceState.output || {};
+        instance.workflowState.properties = {
+            ...(instanceState.variables || {}),
+            __lastActivityOutput: instanceState.lastActivityOutput ?? null,
+        };
+        instance.workflowState.updatedAt = now;
+        if (instanceState.status === 'completed' || instanceState.status === 'error') {
+            instance.workflowState.finishedAt = now;
+        }
+        // Update activity execution context if currentStepId changed
+        if (instanceState.currentStepId) {
+            // Mark previous contexts as completed
+            instance.workflowState.activityExecutionContexts.forEach((ctx) => {
+                if (ctx.status === 'Running' && ctx.scheduledActivityNodeId !== instanceState.currentStepId) {
+                    ctx.status = 'Completed';
+                    ctx.completedAt = now;
+                    ctx.isExecuting = false;
+                }
+            });
+            // Find or create context for current step
+            let existingContext = instance.workflowState.activityExecutionContexts.find((ctx) => ctx.scheduledActivityNodeId === instanceState.currentStepId && ctx.status === 'Running');
+            if (!existingContext) {
+                // Add new context
+                existingContext = {
+                    id: `ctx-${instanceState.currentStepId}`,
+                    parentContextId: null,
+                    scheduledActivityNodeId: instanceState.currentStepId,
+                    ownerActivityNodeId: null,
+                    properties: {},
+                    activityState: null,
+                    dynamicVariables: [],
+                    status: 'Running',
+                    isExecuting: false,
+                    faultCount: 0,
+                    startedAt: now,
+                    completedAt: null,
+                    tag: null,
+                };
+                instance.workflowState.activityExecutionContexts.push(existingContext);
+            }
+        }
+        else {
+            // No current step - mark all contexts as completed
+            instance.workflowState.activityExecutionContexts.forEach((ctx) => {
+                if (ctx.status === 'Running') {
+                    ctx.status = 'Completed';
+                    ctx.completedAt = now;
+                    ctx.isExecuting = false;
+                }
+            });
+        }
+        // Save to IndexedDB
+        await this.updateInstance(instance);
+        // 🎯 Also update in entity service
+        await this.updateInstanceInEntityService(instance);
+        return instance;
+    }
+    /**
+     * Get workflow instance from IndexedDB.
+     */
+    async getInstance(instanceId) {
+        return this.store.getInstance(instanceId);
+    }
+    /**
+     * Update workflow instance in store.
+     */
+    async updateInstance(instance) {
+        instance.updatedAt = new Date().toISOString();
+        await this.store.updateInstance(instance);
+    }
+    /**
+     * Complete a frontend activity and continue workflow execution.
+     *
+     * This method is called when a frontend activity (ui-activity) completes execution.
+     * It applies the frontend output to workflow state, finds the next activity based on outcome,
+     * and executes all backend activities until reaching the next frontend activity or completion.
+     *
+     * Flow:
+     * 1. Apply frontend output to workflow state
+     * 2. Find next activity based on outcome from connections
+     * 3. Execute ALL backend activities until hitting frontend activity or completion
+     * 4. Return either nextTask (with new secure token) or completed status
+     *
+     * @param request - Front activity completion request with instanceId, activityNode, output, and outcome
+     * @returns Response with nextTask (if frontend activity) or completion status
+     */
+    async frontActivtyComplete(request) {
+        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}`);
+                }
+                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',
+                    };
+                }
+            }
+            // 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,
+                    };
+                }
+                // Backend activity → execute it
+                const executionResult = await this.executeBackendActivityLocally(currentActivity, state, lastActivityOutput);
+                lastActivityOutput = 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: 'completed',
+                currentStepId: undefined,
+                output: state.variables,
+                lastActivityOutput,
+            };
+            await this.updateInstanceFromState(request.instanceId, 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
+        }
+    }
+    //#endregion
+    //#region ----   Stale suspension cleanup (app startup)   ----
+    /**
+     * Cleans up stale UI activities (form/popup) when user refreshed without submitting.
+     * - Suspended instances with non-human-task bookmark → resume with outcome 'cancel'.
+     * - Running instances with non-human-task bookmark (e.g. rejectionReasonDialog) → frontActivtyComplete with outcome 'cancel'.
+     * So e.g. leave request: manager clicks Reject, dialog opens, user refreshes → dialog is "cancelled" and workflow goes back to managerConfirm (task board).
+     */
+    async resumeStaleNonHumanTaskSuspensions() {
+        // 1) Suspended instances: non-human-task bookmark → resume with cancel
+        const suspended = await this.store.getInstancesBySubStatus('Suspended');
+        for (const instance of suspended) {
+            try {
+                const bookmarks = await this.getActiveBookmarks(instance.id);
+                for (const b of bookmarks) {
+                    const payload = this.parseBookmarkPayload(b);
+                    if (payload?.activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.humanTask ||
+                        payload?.activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.cartable) {
+                        continue;
+                    }
+                    const taskToken = payload?.taskToken;
+                    if (!taskToken)
+                        continue;
+                    await this.resume({
+                        instanceId: instance.id,
+                        stepId: b.activityId,
+                        outcome: 'cancel',
+                        taskToken,
+                        userInput: {},
+                    });
+                    console.log(`[BackendWorkflowEngineService] 🧹 Resumed stale non-human-task suspension: ${instance.id} activity ${b.activityId} with outcome cancel`);
+                    break;
+                }
+            }
+            catch (err) {
+                console.warn(`[BackendWorkflowEngineService] ⚠️ Failed to resume stale suspension for instance ${instance.id}:`, err);
+            }
+        }
+        // 2) Running instances: non-human-task bookmark (e.g. show-layout-popup) → complete with cancel so flow returns to previous step (e.g. task board)
+        const running = await this.store.getInstancesBySubStatus('Executing');
+        for (const instance of running) {
+            try {
+                const bookmarks = await this.getActiveBookmarks(instance.id);
+                for (const b of bookmarks) {
+                    const payload = this.parseBookmarkPayload(b);
+                    if (payload?.activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.humanTask ||
+                        payload?.activityType === workflow_management_const_1.WorkflowManagementRootConfig.activities.cartable) {
+                        continue;
+                    }
+                    await this.frontActivtyComplete({
+                        instanceId: instance.id,
+                        activityNode: b.activityId,
+                        output: {},
+                        outcome: 'cancel',
+                    });
+                    console.log(`[BackendWorkflowEngineService] 🧹 Completed stale non-human-task (running): ${instance.id} activity ${b.activityId} with outcome cancel`);
+                    break;
+                }
+            }
+            catch (err) {
+                console.warn(`[BackendWorkflowEngineService] ⚠️ Failed to complete stale running activity for instance ${instance.id}:`, err);
+            }
+        }
+    }
+    parseBookmarkPayload(b) {
+        try {
+            return b.payloadJson ? JSON.parse(b.payloadJson) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+};
+exports.BackendWorkflowEngineService = BackendWorkflowEngineService;
+/**
+ * Default outcome used when the requested outcome is not in the allowed list (standard scenario).
+ */
+BackendWorkflowEngineService.DEFAULT_UNMATCHED_OUTCOME = 'Done';
+exports.BackendWorkflowEngineService = BackendWorkflowEngineService = BackendWorkflowEngineService_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [workflow_execution_store_service_1.WorkflowExecutionStoreService,
+        core_1.EntityStorageMiddlewareService,
+        workflow_activity_definition_service_1.WorkflowActivityDefinitionService,
+        workflow_expression_scope_service_1.WorkflowExpressionScopeService,
+        workflow_expression_evaluator_service_1.WorkflowExpressionEvaluatorService,
+        workflow_request_session_adapter_1.WorkflowRequestSessionAdapter,
+        workflow_activity_registry_1.WorkflowActivityRegistryService])
+], BackendWorkflowEngineService);
+//# sourceMappingURL=workflow-engine.service.js.map