@acorex/modules 21.0.0-next.57 → 21.0.0-next.59

package/fesm2022/acorex-modules-workflow-management.mjs

@@ -1,26 +1,27 @@
 import * as i0 from '@angular/core';
-import { Injectable, inject, NgModule, InjectionToken, Inject, makeEnvironmentProviders, Injector, runInInjectionContext } from '@angular/core';
+import { Injectable, inject, NgModule, Injector, runInInjectionContext, makeEnvironmentProviders, InjectionToken, Inject } from '@angular/core';
 import { AXPCommonMenuKeys, AXPWidgetsList } from '@acorex/modules/common';
 import { AXPSessionService, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
-import { AXPEntityService, AXPEntityFormBuilderService, AXPEntityDefinitionRegistryService, entityDetailsCrudActions, AXP_ENTITY_ACTION_PLUGIN, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
+import { AXPEntityService, AXPEntityFormBuilderService, AXPEntityDefinitionRegistryService, entityDetailsCrudActions, AXP_ENTITY_ACTION_PLUGIN, AXP_ENTITY_DEFINITION_LOADER, AXP_RECORD_WORKFLOW_INFO_INSTANCE_ID_FIELD } from '@acorex/platform/layout/entity';
 import { firstValueFrom } from 'rxjs';
 import { AXMCalendarManagementModule } from '@acorex/modules/calendar-management';
-import { AXPEntityCommandScope, AXPStatusProvider, AXPSystemStatusType, systemStatusToDefinition, AXPSystemStatuses, AXP_STATUS_PROVIDERS, AXP_MENU_PROVIDER } from '@acorex/platform/common';
-import { AXPSystemActionType, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXP_MODULE_MANIFEST_PROVIDER, provideLazyProvider } from '@acorex/platform/core';
+import { AXPEntityCommandScope, AXPStatusProvider, AXPSystemStatusType, systemStatusToDefinition, AXP_STATUS_PROVIDERS, AXP_MENU_PROVIDER, AXPSettingsService, AXPStatusDefinitionProviderService, AXPRegionalSetting, AXPSystemStatuses } from '@acorex/platform/common';
+import { AXPSystemActionType, AXPBroadcastEventService, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXP_MODULE_MANIFEST_PROVIDER, provideLazyProvider } from '@acorex/platform/core';
 import { AXP_PAGE_COMPONENT_PROVIDER } from '@acorex/platform/layout/components';
 import { AXPDomainModule } from '@acorex/platform/domain';
-import { AXPWidgetGroupEnum, AXP_WIDGETS_EDITOR_CATEGORY, AXPWidgetSerializationHelper, AXPWidgetCoreModule, AXP_WIDGET_DEFINITION_PROVIDER } from '@acorex/platform/layout/widget-core';
+import { AXPWidgetGroupEnum, AXP_WIDGETS_EDITOR_CATEGORY, AXPWidgetSerializationHelper, AXPWidgetCoreModule, AXP_WIDGET_DEFINITION_PROVIDER, AXPWidgetsCatalog } from '@acorex/platform/layout/widget-core';
 import { AXPBarChartWidget, AXPHeatmapChartWidget, AXPDonutChartWidget, AXPLineChartWidget, AXPGaugeChartWidget, AXPFunnelChartWidget, AXPKpiDetailsWidget, AXPKpiProgressWidget, AXPKpiSegmentedWidget, AXPKpiStatCardWidget } from '@acorex/modules/dashboard-management';
 import { AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY } from '@acorex/platform/layout/widgets';
 import { provideCommandSetups } from '@acorex/platform/runtime';
-import { AXPWorkflowManager, AXP_WORKFLOW_ERROR_CODES, AXPWorkflowDefinitionService, AXP_WORKFLOW_PROVIDER, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_CATEGORY_PROVIDER } from '@acorex/platform/workflow';
+import { AXPWorkflowDefinitionService, AXP_WORKFLOW_ENGINE, AXPWorkflowManager, AXP_WORKFLOW_SUPPRESS_CONTINUATION_INPUT_KEY, AXP_WORKFLOW_ERROR_CODES, axpIsWorkflowTaskBoardActivityType, AXP_WORKFLOW_PROVIDER, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_CATEGORY_PROVIDER, AXP_WORKFLOW_CONTINUATION_HOOK } from '@acorex/platform/workflow';
 import { AXDialogService } from '@acorex/components/dialog';
 import { AXTranslationService } from '@acorex/core/translation';
 import { AXPopupService } from '@acorex/components/popup';
 import { AXPDialogRendererComponent, AXPLayoutBuilderService } from '@acorex/platform/layout/builder';
 import { cloneDeep } from 'lodash-es';
 import { AXToastService } from '@acorex/components/toast';
-import { AXPWorkflowTaskProvider, matchesTaskBoardAssigneeUserIdsFilter, filterTasksOverlappingRange, AXP_WORKFLOW_TASK_PROVIDER } from '@acorex/modules/task-management';
+import { AXP_WORKFLOW_TASK_PROVIDER, AXPWorkflowTaskProvider, matchesTaskBoardAssigneeUserIdsFilter, filterTasksOverlappingRange } from '@acorex/modules/task-management';
+import { AXFormatService } from '@acorex/core/format';
 
 const config = {
     i18n: 'workflow-management',
@@ -167,7 +168,7 @@ class AXMWorkflowManagementModuleEntityProvider {
                 case RootConfig.entities.workflowDefinition.name:
                     return (await import('./acorex-modules-workflow-management-workflow-definition.entity-DISpkWE4.mjs')).factory();
                 case RootConfig.entities.workflowInstance.name:
-                    return (await import('./acorex-modules-workflow-management-workflow-instance.entity-B_V3uMSI.mjs')).factory();
+                    return (await import('./acorex-modules-workflow-management-workflow-instance.entity-BnKT3Wgh.mjs')).factory();
                 case RootConfig.entities.activityDefinition.name:
                     return (await import('./acorex-modules-workflow-management-activity-definition.entity-B3DkgDQb.mjs')).factory();
                 case RootConfig.entities.automation.name:
@@ -996,10 +997,10 @@ const AXMActivityCommandConfiguratorWidget = {
     ],
     components: {
         edit: {
-            component: () => import('./acorex-modules-workflow-management-activity-command-configurator-widget-edit.component-OLbCD-7P.mjs').then((c) => c.AXMActivityCommandConfiguratorWidgetEditComponent),
+            component: () => import('./acorex-modules-workflow-management-activity-command-configurator-widget-edit.component-B4DLmioy.mjs').then((c) => c.AXMActivityCommandConfiguratorWidgetEditComponent),
         },
         designer: {
-            component: () => import('./acorex-modules-workflow-management-activity-command-configurator-widget-edit.component-OLbCD-7P.mjs').then((c) => c.AXMActivityCommandConfiguratorWidgetEditComponent),
+            component: () => import('./acorex-modules-workflow-management-activity-command-configurator-widget-edit.component-B4DLmioy.mjs').then((c) => c.AXMActivityCommandConfiguratorWidgetEditComponent),
         },
         column: {
             component: () => import('./acorex-modules-workflow-management-activity-command-configurator-widget-column.component-CDo0QVFy.mjs').then((c) => c.AXMActivityCommandConfiguratorWidgetColumnComponent),
@@ -2137,6 +2138,8 @@ const automationPlugin = {
  * This plugin:
  * - Adds workflow capability marker to entity extensions
  * - Enables workflow trigger middleware to detect workflow-capable entities
+ * - Domain rows link runs via `workflowInfo` on the entity model (see `AXPRecordWorkflowInfo`),
+ *   not as entity definition properties
  * - Provides UI hooks for workflow-related features (future enhancement)
  *
  * Usage:
@@ -2550,6 +2553,68 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
             type: Injectable
         }] });
 
+//#region ----   Lazy loader   ----
+/** Code-split chunk for the generic workflow task provider implementation. */
+function loadGenericWorkflowTaskProviderClass() {
+    return Promise.resolve().then(function () { return genericWorkflowTask_provider; }).then((m) => m.AXPGenericWorkflowTaskProvider);
+}
+//#endregion
+//#region ----   Per-definition registration   ----
+/**
+ * Registers one workflow task provider for a single definition (lazy-loaded).
+ * Use in feature modules that need a dedicated task-board entry per workflow.
+ */
+function provideGenericWorkflowTaskProvider(config) {
+    return {
+        provide: AXP_WORKFLOW_TASK_PROVIDER,
+        multi: true,
+        useFactory: (injector) => loadGenericWorkflowTaskProviderClass().then((ProviderClass) => runInInjectionContext(injector, () => new ProviderClass(config))),
+        deps: [Injector],
+    };
+}
+//#endregion
+//#region ----   Auto-discovery registration   ----
+/**
+ * Registers one task provider per workflow definition (lazy-loaded).
+ * Discovers definitions via {@link AXPWorkflowDefinitionService} at first resolve.
+ */
+function provideTaskWorkflow() {
+    return makeEnvironmentProviders([
+        {
+            provide: AXP_WORKFLOW_TASK_PROVIDER,
+            multi: true,
+            useFactory: (injector) => (async () => {
+                const ProviderClass = await loadGenericWorkflowTaskProviderClass();
+                const workflowDefinitionService = injector.get(AXPWorkflowDefinitionService);
+                const multiLanguageResolver = injector.get(AXTranslationService);
+                const categories = await workflowDefinitionService.getCategories();
+                const providers = [];
+                const seenDefinitionNames = new Set();
+                for (const category of categories) {
+                    const workflows = await workflowDefinitionService.getWorkflowsByCategoryId(category.id);
+                    for (const workflow of workflows) {
+                        const key = workflow.name;
+                        if (!key || seenDefinitionNames.has(key)) {
+                            continue;
+                        }
+                        seenDefinitionNames.add(key);
+                        const provider = runInInjectionContext(injector, () => new ProviderClass({
+                            name: workflow.name,
+                            title: multiLanguageResolver.resolve(workflow.title) ?? workflow.name,
+                            icon: 'fa-light fa-diagram-project',
+                            definitionId: workflow.name,
+                        }));
+                        providers.push(provider);
+                    }
+                }
+                return providers;
+            })(),
+            deps: [Injector],
+        },
+    ]);
+}
+//#endregion
+
 //#region ----   Imports   ----
 //#endregion
 //#region ----   Permission Helpers   ----
@@ -2563,133 +2628,336 @@ function canReassignWorkflowTaskToSelf(sessionService) {
 }
 //#endregion
 
-//#region ----   Workflow task context (reserved keys)   ----
+//#region ----   Imports   ----
+//#endregion
+//#region ----   User id helpers   ----
+/** Normalizes platform user id lists on bookmark payloads. */
+function normalizeWorkflowTaskUserIds(value) {
+    if (!value || value.length === 0) {
+        return [];
+    }
+    return value.map((id) => String(id)).filter((s) => s.length > 0);
+}
+/** Workflow instance creator (task-board "started by"). */
+function getWorkflowInstanceInitiatorUserId(instance) {
+    const id = instance.auditInfo?.created?.by?.id;
+    return id != null && String(id).length > 0 ? String(id) : null;
+}
+/** Demo/platform operator accounts that bypass permission checks in mock auth. */
+function isWorkflowPlatformRootUser(sessionService) {
+    const username = sessionService.user?.name?.trim();
+    return username === 'root' || username === 'root2' || username === 'super-root';
+}
+//#endregion
+//#region ----   Bookmark payload helpers   ----
+/** Bookmark types rendered on the workflow task board. */
+function isWorkflowTaskBoardBookmarkPayload(payload) {
+    const t = payload.activityType;
+    return t === 'workflow-activity:human-task' || t === 'workflow-activity:cartable';
+}
+/** Pooled task that must be claimed before acting (no direct continuation offer). */
+function isWorkflowPooledClaimablePayload(payload) {
+    const assigned = normalizeWorkflowTaskUserIds(payload.assignedUserIds);
+    const candidates = normalizeWorkflowTaskUserIds(payload.candidateUserIds);
+    if (payload.activityType === 'workflow-activity:cartable') {
+        return assigned.length === 0 && candidates.length > 0;
+    }
+    return payload.activityType === 'workflow-activity:human-task' && assigned.length === 0 && candidates.length > 0;
+}
+/** Human-task assigned to another user; may be taken over when permitted. */
+function isWorkflowReassignableHumanTaskPayload(payload) {
+    if (payload.activityType !== 'workflow-activity:human-task') {
+        return false;
+    }
+    const assigned = normalizeWorkflowTaskUserIds(payload.assignedUserIds);
+    if (assigned.length === 0) {
+        return false;
+    }
+    return true;
+}
+/** Parses bookmark payload from entity storage. */
+function parseWorkflowTaskContinuationPayload(bookmark) {
+    try {
+        const raw = bookmark.payload ?? (bookmark.payloadJson ? JSON.parse(bookmark.payloadJson) : null);
+        if (typeof raw !== 'object' || raw === null) {
+            return null;
+        }
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+//#endregion
+//#region ----   Step advancement gate   ----
+/** Resume outcomes that do not advance the workflow graph (draft save, cancel, loop back). */
+const NON_ADVANCING_RESUME_OUTCOMES = new Set(['saved', 'cancelled', 'cancel', 'save', 'draft']);
 /**
- * Human-task / cartable `context` payload: technical ids at the root; display metadata under reserved keys.
+ * Whether the workflow moved forward enough to prompt "continue to next step".
+ * Skips draft save / cancel on questionnaire (same human-task bookmark remains).
+ */
+function shouldOfferWorkflowContinuationAfterStep(context, activeBookmarkActivityIds) {
+    const outcome = context.resumeOutcome?.trim().toLowerCase();
+    if (outcome && NON_ADVANCING_RESUME_OUTCOMES.has(outcome)) {
+        return false;
+    }
+    const pendingActivityId = context.pendingNextTask?.activityId;
+    const completedActivityId = context.completedActivityId;
+    if (pendingActivityId && completedActivityId && pendingActivityId === completedActivityId) {
+        return false;
+    }
+    if (activeBookmarkActivityIds.length === 0) {
+        return false;
+    }
+    if (!completedActivityId) {
+        return true;
+    }
+    return activeBookmarkActivityIds.some((id) => id !== completedActivityId);
+}
+//#endregion
+//#region ----   Continuation eligibility   ----
+/**
+ * Whether the UI should offer "continue to next step" after a successful resume.
  *
- * @example
- * ```json
- * {
- *   "leaveRequestId": "{{ variables.leaveRequestId }}",
- *   "_taskI18n": {
- *     "employeeDisplayName": "{{ variables.employeeDisplayName }}",
- *     "leaveTypeTitle": "{{ variables.leaveTypeTitle }}"
- *   },
- *   "_taskTitleParts": [
- *     "{{ variables.employeeDisplayName }}",
- *     "{{ variables.leaveTypeTitle }}"
- *   ]
- * }
- * ```
+ * - Current user is the assignee (sequential tasks for the same person, e.g. line manager).
+ * - Workflow initiator and assignee are the same person and that person is the current user.
+ * - Current user may take over a human-task assigned to someone else.
  */
-/** Interpolation map for `@scope:key` task title and description strings. */
-const AXP_WORKFLOW_TASK_CONTEXT_I18N_KEY = '_taskI18n';
-/** Ordered segments joined with " — " when bookmark title is still a generic activity label. */
-const AXP_WORKFLOW_TASK_CONTEXT_TITLE_PARTS_KEY = '_taskTitleParts';
+function shouldOfferWorkflowTaskContinuation(ctx) {
+    const currentUserId = ctx.sessionService.user?.id;
+    if (currentUserId == null) {
+        return false;
+    }
+    const current = String(currentUserId);
+    if (!isWorkflowTaskBoardBookmarkPayload(ctx.payload)) {
+        return false;
+    }
+    if (isWorkflowPooledClaimablePayload(ctx.payload)) {
+        return false;
+    }
+    const assigned = normalizeWorkflowTaskUserIds(ctx.payload.assignedUserIds);
+    const assigneeId = assigned[0] ?? null;
+    const initiatorId = getWorkflowInstanceInitiatorUserId(ctx.instance);
+    const isPlatformRoot = isWorkflowPlatformRootUser(ctx.sessionService);
+    const isInitiator = initiatorId != null && current === initiatorId;
+    if (assigneeId && current === assigneeId) {
+        return true;
+    }
+    if (initiatorId && assigneeId && initiatorId === assigneeId && current === initiatorId) {
+        return true;
+    }
+    /** User who started the workflow may continue (take over when not assignee). */
+    if (isInitiator && assigneeId) {
+        return true;
+    }
+    /** Platform operators (e.g. super-root) may continue any pending human task. */
+    if (isPlatformRoot) {
+        return true;
+    }
+    if (!canReassignWorkflowTaskToSelf(ctx.sessionService) && !isPlatformRoot) {
+        return false;
+    }
+    if (!isWorkflowReassignableHumanTaskPayload(ctx.payload)) {
+        return false;
+    }
+    if (!assigneeId || current === assigneeId) {
+        return false;
+    }
+    return true;
+}
+/** True when the user must take over the next bookmark before acting on it. */
+function needsTakeOverForWorkflowTaskContinuation(ctx) {
+    const currentUserId = ctx.sessionService.user?.id;
+    if (currentUserId == null) {
+        return false;
+    }
+    const current = String(currentUserId);
+    const assigned = normalizeWorkflowTaskUserIds(ctx.payload.assignedUserIds);
+    const assigneeId = assigned[0] ?? null;
+    if (!assigneeId || current === assigneeId) {
+        return false;
+    }
+    const canTakeOver = canReassignWorkflowTaskToSelf(ctx.sessionService) || isWorkflowPlatformRootUser(ctx.sessionService);
+    return canTakeOver && isWorkflowReassignableHumanTaskPayload(ctx.payload);
+}
 //#endregion
 
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Access factory   ----
+function getActiveBookmarks(instance) {
+    const wi = instance.workflowInstance;
+    const bookmarks = wi?.bookmarks ?? [];
+    return bookmarks.filter((b) => !b.isConsumed && !b.consumed);
+}
 /**
- * Injection token for provider config. Use when registering via DI (provide token + useFactory with deps).
- * When creating via useFactory: () => new AXPGenericWorkflowTaskProvider({ ... }), config is passed in the closure.
+ * Loads workflow instance entity rows (including embedded bookmarks).
  */
-const AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG = new InjectionToken('AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG');
+function createWorkflowInstanceBookmarkAccess(entityService = inject(AXPEntityService)) {
+    const workflowInstanceData = entityService
+        .withEntity('WorkflowManagement', 'WorkflowInstance')
+        .data();
+    return {
+        async loadInstance(instanceId) {
+            let instance = await workflowInstanceData.byKey(instanceId);
+            if (instance && getActiveBookmarks(instance).length > 0) {
+                return instance;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            instance = await workflowInstanceData.byKey(instanceId);
+            return instance ?? null;
+        },
+        getActiveBookmarks,
+        async findActiveBookmark(instanceId, activityId) {
+            const instance = await this.loadInstance(instanceId);
+            if (!instance) {
+                return null;
+            }
+            const bookmark = getActiveBookmarks(instance).find((b) => b.activityId === activityId);
+            if (!bookmark) {
+                return null;
+            }
+            return { instance, bookmark };
+        },
+        parseHumanTaskPayload(bookmark) {
+            const parsed = parseWorkflowTaskContinuationPayload(bookmark);
+            if (!parsed) {
+                return null;
+            }
+            return parsed;
+        },
+    };
+}
+//#endregion
+
 //#endregion
+//#region ----   Service   ----
 /**
- * Generic Workflow Task Provider
- *
- * Provides tasks from Workflow Instances directly (no Work Items).
- * Queries suspended workflow instances and extracts tasks from bookmarks.
- *
- * Create one provider per workflow definition by passing a config (name, title, definitionId).
- * E.g. leave request: { name: 'leave-request-workflow-tasks', title: 'Leave Request', definitionId: 'LeaveRequestWorkflow' }
- *
- * Architecture:
- * - Queries Workflow Instances with subStatus = 'Suspended'
- * - Filters by config.definitionId when set (one provider = one definition)
- * - Extracts active bookmarks for each instance
- * - Parses bookmark payload for assignment/actions
- * - Maps to task board format
+ * Workflow-instance human-task operations (resume, take-over, primary action).
+ * Independent of task board / popover — task board delegates here for the same behavior.
  */
-class AXPGenericWorkflowTaskProvider extends AXPWorkflowTaskProvider {
-    //#endregion
-    //#region ----   Constructor   ----
-    constructor(config) {
-        super();
-        //#endregion
+class AXPWorkflowInstanceHumanTaskService {
+    constructor() {
         //#region ----   Services & Dependencies   ----
-        this.entityService = inject(AXPEntityService);
-        this.workflowInstanceData = this.entityService
-            .withEntity('WorkflowManagement', 'WorkflowInstance')
-            .data();
-        this.userEntityData = this.entityService.withEntity('SecurityManagement', 'User').data();
-        this.translationService = inject(AXTranslationService);
-        this.workflowManager = inject(AXPWorkflowManager);
+        this.injector = inject(Injector);
         this.sessionService = inject(AXPSessionService);
-        this.toastService = inject(AXToastService);
+        this.translationService = inject(AXTranslationService);
         this.dialogService = inject(AXDialogService);
-        this.config = config;
-    }
-    //#endregion
-    //#region ----   Provider Metadata   ----
-    get name() {
-        return this.config.name;
-    }
-    get title() {
-        return this.config.title;
+        this.toastService = inject(AXToastService);
+        this.eventService = inject(AXPBroadcastEventService);
+        this.workflowEngine = inject(AXP_WORKFLOW_ENGINE);
+        this.bookmarkAccess = createWorkflowInstanceBookmarkAccess();
     }
-    get icon() {
-        return this.config.icon ?? 'fa-light fa-diagram-project';
+    /** Resolved lazily to avoid DI cycle with {@link AXPWorkflowManager} continuation hook. */
+    get workflowManager() {
+        return this.injector.get(AXPWorkflowManager);
     }
     //#endregion
-    //#region ----   Task Retrieval   ----
+    //#region ----   Resume & take-over   ----
     /**
-     * Bookmark types shown on the workflow task board.
+     * Resumes a suspended human-task bookmark (runs interactive activities via the workflow manager).
      */
-    isTaskBoardBookmarkPayload(payload) {
-        const t = payload.activityType;
-        return t === 'workflow-activity:human-task' || t === 'workflow-activity:cartable';
+    async resumeSuspendedHumanTask(request) {
+        const userInput = {
+            ...(request.userInput ?? {}),
+            bookmarkId: request.bookmarkId,
+        };
+        if (request.suppressContinuation) {
+            userInput[AXP_WORKFLOW_SUPPRESS_CONTINUATION_INPUT_KEY] = true;
+        }
+        let result = await this.workflowManager.resume(request.instanceId, request.activityId, request.outcome, userInput, request.taskToken);
+        if (result.success || result.errorCode !== AXP_WORKFLOW_ERROR_CODES.TASK_NOT_ASSIGNEE || !this.canTakeOver()) {
+            if (!result.success) {
+                await this.showResumeError(result);
+            }
+            return result;
+        }
+        const confirmed = await this.confirmReassignToSelf();
+        if (!confirmed) {
+            return { success: false, instanceId: request.instanceId, error: result.error, errorCode: result.errorCode };
+        }
+        const reassigned = await this.reassignBookmarkToCurrentUser(request.instanceId, request.bookmarkId, request.activityId);
+        if (!reassigned) {
+            return { success: false, instanceId: request.instanceId, error: result.error, errorCode: result.errorCode };
+        }
+        result = await this.workflowManager.resume(request.instanceId, request.activityId, request.outcome, userInput, request.taskToken);
+        if (!result.success) {
+            await this.showResumeError(result);
+        }
+        return result;
     }
     /**
-     * Pooled task: must be claimed before submit/cancel (cartable, or human-task with candidates only).
+     * Runs the first configured action on a suspended human-task bookmark (e.g. start-fill → questionnaire).
      */
-    isPooledClaimablePayload(payload) {
-        const assigned = this.normalizeUserIdList(payload.assignedUserIds);
-        const candidates = this.normalizeUserIdList(payload.candidateUserIds);
-        if (payload.activityType === 'workflow-activity:cartable') {
-            return assigned.length === 0 && candidates.length > 0;
+    async executePrimaryHumanTaskAction(instanceId, activityId, options) {
+        const found = await this.bookmarkAccess.findActiveBookmark(instanceId, activityId);
+        if (!found) {
+            return null;
         }
-        return payload.activityType === 'workflow-activity:human-task' && assigned.length === 0 && candidates.length > 0;
-    }
-    normalizeUserIdList(value) {
-        if (!value || value.length === 0)
-            return [];
-        return value.map((id) => String(id)).filter((s) => s.length > 0);
+        const payload = this.bookmarkAccess.parseHumanTaskPayload(found.bookmark);
+        if (!payload?.taskToken) {
+            return null;
+        }
+        const outcome = this.resolvePrimaryTaskOutcome(payload);
+        const result = await this.resumeSuspendedHumanTask({
+            instanceId,
+            bookmarkId: found.bookmark.id,
+            activityId,
+            taskToken: payload.taskToken,
+            outcome,
+            suppressContinuation: options?.suppressContinuation ?? true,
+        });
+        if (options?.notifyViews !== false) {
+            this.notifyWorkflowTaskViewsChanged();
+        }
+        return result;
     }
     /**
-     * Human-task assigned to another user; current user may take over when permitted.
+     * Reassigns a human-task bookmark to the current user (take over) without advancing the workflow.
      */
-    isReassignableHumanTaskPayload(payload) {
-        if (payload.activityType !== 'workflow-activity:human-task') {
+    async reassignBookmarkToCurrentUser(instanceId, bookmarkId, activityId) {
+        const reassign = this.workflowEngine.reassignTaskToSelf?.bind(this.workflowEngine);
+        if (!reassign) {
             return false;
         }
-        const assigned = this.normalizeUserIdList(payload.assignedUserIds);
-        if (assigned.length === 0) {
+        const result = await reassign({ instanceId, bookmarkId, stepId: activityId });
+        if (!result.success) {
+            await this.showToast('@workflow-management:tasks.errors.reassign-failed');
             return false;
         }
-        const currentUserId = this.sessionService.user?.id;
-        if (currentUserId == null) {
+        return true;
+    }
+    /**
+     * Take over with confirmation dialog (task board "Take Over" action).
+     */
+    async reassignBookmarkToCurrentUserWithConfirm(instanceId, bookmarkId, activityId) {
+        if (!this.canTakeOver()) {
+            await this.showToast('@workflow-management:tasks.errors.not-assignee');
             return false;
         }
-        return !assigned.includes(String(currentUserId));
+        const confirmed = await this.confirmReassignToSelf();
+        if (!confirmed) {
+            return true;
+        }
+        return this.reassignBookmarkToCurrentUser(instanceId, bookmarkId, activityId);
     }
-    canTakeOverTask() {
-        return canReassignWorkflowTaskToSelf(this.sessionService);
+    //#endregion
+    //#region ----   Outcome resolution   ----
+    /** First action command name on the human-task bookmark (e.g. start-fill, approve). */
+    resolvePrimaryTaskOutcome(payload) {
+        const actions = [...(payload.actions?.prefix ?? []), ...(payload.actions?.suffix ?? [])];
+        for (const action of actions) {
+            const outcome = action.command?.name ?? action.name;
+            if (outcome && outcome !== 'unknown') {
+                return outcome;
+            }
+        }
+        return 'submit';
     }
-    //#region ----   Task Command UX   ----
-    async showWorkflowTaskToast(contentKey, color = 'danger') {
-        const title = await this.translationService.translateAsync('@general:messages.generic.error.title');
-        const content = await this.translationService.translateAsync(contentKey);
-        this.toastService.show({ color, title, content });
+    //#endregion
+    //#region ----   UI helpers   ----
+    canTakeOver() {
+        return canReassignWorkflowTaskToSelf(this.sessionService);
     }
     async confirmReassignToSelf() {
         const title = await this.translationService.translateAsync('@workflow-management:tasks.dialogs.reassign-to-self.title');
@@ -2697,626 +2965,199 @@ class AXPGenericWorkflowTaskProvider extends AXPWorkflowTaskProvider {
         const dialogResult = await this.dialogService.confirm(title, message, 'warning', 'horizontal', false, 'cancel');
         return dialogResult.result === true;
     }
-    async reassignTaskToSelf(instanceId, bookmarkId, activityId) {
-        const result = await this.workflowManager.reassignTaskToSelf(instanceId, bookmarkId, activityId);
-        if (result.success) {
-            return true;
-        }
-        await this.showWorkflowTaskToast('@workflow-management:tasks.errors.reassign-failed');
-        return false;
-    }
-    async resumeWorkflowTask(instanceId, bookmarkId, activityId, outcome, userInput, taskToken) {
-        let result = await this.workflowManager.resume(instanceId, activityId, outcome, userInput, taskToken);
-        if (result.success || result.errorCode !== AXP_WORKFLOW_ERROR_CODES.TASK_NOT_ASSIGNEE || !this.canTakeOverTask()) {
-            if (!result.success) {
-                const toastKey = result.errorCode === AXP_WORKFLOW_ERROR_CODES.TASK_NOT_ASSIGNEE
-                    ? '@workflow-management:tasks.errors.not-assignee'
-                    : undefined;
-                if (toastKey) {
-                    await this.showWorkflowTaskToast(toastKey);
-                }
-                else if (result.error) {
-                    this.toastService.show({
-                        color: 'danger',
-                        title: await this.translationService.translateAsync('@general:messages.generic.error.title'),
-                        content: result.error,
-                    });
-                }
-            }
-            return result;
-        }
-        const confirmed = await this.confirmReassignToSelf();
-        if (!confirmed) {
-            return { success: false, instanceId, error: result.error, errorCode: result.errorCode };
-        }
-        const reassigned = await this.reassignTaskToSelf(instanceId, bookmarkId, activityId);
-        if (!reassigned) {
-            return { success: false, instanceId, error: result.error, errorCode: result.errorCode };
+    async showResumeError(result) {
+        const toastKey = result.errorCode === AXP_WORKFLOW_ERROR_CODES.TASK_NOT_ASSIGNEE
+            ? '@workflow-management:tasks.errors.not-assignee'
+            : undefined;
+        if (toastKey) {
+            await this.showToast(toastKey);
+            return;
         }
-        result = await this.workflowManager.resume(instanceId, activityId, outcome, userInput, taskToken);
-        if (!result.success) {
+        if (result.error) {
             this.toastService.show({
                 color: 'danger',
                 title: await this.translationService.translateAsync('@general:messages.generic.error.title'),
-                content: result.error ?? 'Failed to resume workflow',
+                content: result.error,
             });
         }
-        return result;
+    }
+    async showToast(contentKey, color = 'danger') {
+        const title = await this.translationService.translateAsync('@general:messages.generic.error.title');
+        const content = await this.translationService.translateAsync(contentKey);
+        this.toastService.show({ color, title, content });
+    }
+    /** Optional broadcast so open task-board views refresh; does not require task-board module at runtime. */
+    notifyWorkflowTaskViewsChanged(provider) {
+        this.eventService.publish('task-board.refresh', { provider });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowInstanceHumanTaskService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowInstanceHumanTaskService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowInstanceHumanTaskService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Service   ----
+/**
+ * Offers "continue to next step" / take-over after workflow start, resume, and interactive chains.
+ * Uses {@link AXPWorkflowInstanceHumanTaskService} only — not task board or popover.
+ */
+class AXPWorkflowTaskContinuationService {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.sessionService = inject(AXPSessionService);
+        this.translationService = inject(AXTranslationService);
+        this.dialogService = inject(AXDialogService);
+        this.humanTaskService = inject(AXPWorkflowInstanceHumanTaskService);
+        this.bookmarkAccess = createWorkflowInstanceBookmarkAccess();
     }
     //#endregion
-    /**
-     * Get tasks from suspended workflow instances.
-     *
-     * Queries workflow instances filtered by:
-     * - subStatus = 'Suspended'
-     * - entityRefType (if provided in filter)
-     * - definitionId (if provided in filter)
-     * - assignee/claimant (if filter provided)
-     *
-     * Then extracts active bookmarks and maps to task board format.
-     */
-    async getTasks(options) {
-        // Build filter for workflow instances
-        const baseFilter = { logic: 'and', filters: [] };
-        // Filter by subStatus = 'Suspended' (only suspended workflows have pending tasks)
-        baseFilter.filters?.push({
-            field: 'subStatus',
-            operator: { type: 'equal' },
-            value: 'Suspended',
-        });
-        // Scope this provider to one workflow definition
-        if (this.config.definitionId) {
-            baseFilter.filters?.push({
-                field: 'definitionId',
-                operator: { type: 'equal' },
-                value: this.config.definitionId,
-            });
-        }
-        // Date range is applied after mapping bookmarks (task start/end overlap), not on instance createdAt.
-        // Query workflow instances
-        const { items: instances } = await this.workflowInstanceData.query({
-            skip: options?.skip ?? 0,
-            take: options?.take ?? 20,
-            filter: baseFilter,
-        });
-        // Extract tasks from bookmarks for each instance
-        const tasks = [];
-        for (const instance of instances) {
-            try {
-                // Get active bookmarks from instance entity (workflowInstance.bookmarks)
-                const bookmarks = this.getActiveBookmarksFromInstance(instance);
-                // Process each bookmark (typically one per suspended activity)
-                for (const bookmark of bookmarks) {
-                    try {
-                        // Get payload from entity (payload object or parse payloadJson)
-                        let payload;
-                        try {
-                            const raw = bookmark.payload ?? (bookmark.payloadJson ? JSON.parse(bookmark.payloadJson) : null);
-                            payload =
-                                typeof raw === 'object' && raw !== null
-                                    ? raw
-                                    : {};
-                        }
-                        catch {
-                            continue;
-                        }
-                        // Task board: human-task and cartable (pooled); exclude other suspended UI bookmarks
-                        if (!this.isTaskBoardBookmarkPayload(payload)) {
-                            continue;
-                        }
-                        // Check assignment filter if provided
-                        if (options?.assigneeIds && options.assigneeIds.length > 0) {
-                            const assignedIds = payload.assignedUserIds || [];
-                            const candidateIds = payload.candidateUserIds || [];
-                            const allUserIds = [...assignedIds, ...candidateIds].map(String);
-                            // TODO: Also check candidateRoleIds by resolving role members
-                            if (!matchesTaskBoardAssigneeUserIdsFilter(allUserIds, options.assigneeIds)) {
-                                continue;
-                            }
-                        }
-                        // Map bookmark to task
-                        const task = await this.mapBookmarkToTask(instance, bookmark, payload);
-                        tasks.push(task);
-                    }
-                    catch {
-                        // Skip this bookmark and continue
-                    }
-                }
+    //#region ----   Hook   ----
+    async offerAfterWorkflowStep(context) {
+        try {
+            const instance = await this.bookmarkAccess.loadInstance(context.instanceId);
+            if (!instance) {
+                return;
             }
-            catch {
-                // Skip this instance and continue
+            const activeActivityIds = this.bookmarkAccess
+                .getActiveBookmarks(instance)
+                .map((b) => b.activityId);
+            if (!shouldOfferWorkflowContinuationAfterStep(context, activeActivityIds)) {
+                return;
             }
-        }
-        const rangeFiltered = filterTasksOverlappingRange(tasks, options?.range);
-        const total = rangeFiltered.length;
-        const skip = options?.skip ?? 0;
-        const take = options?.take ?? total;
-        const items = rangeFiltered.slice(skip, skip + take);
-        return { items, total };
-    }
-    /**
-     * Get active (non-consumed) bookmarks from workflow instance entity.
-     * Reads from instance.workflowInstance?.bookmarks — no direct DB access.
-     */
-    getActiveBookmarksFromInstance(instance) {
-        const wi = instance?.workflowInstance;
-        const bookmarks = wi?.bookmarks ?? [];
-        const active = bookmarks.filter((b) => !b.isConsumed && !b.consumed);
-        return active;
-    }
-    /**
-     * Task-board reporter: signed-in user who is viewing the app (workflow initiator context).
-     */
-    buildReporterFromSession(instance) {
-        const sessionUser = this.sessionService.user;
-        if (sessionUser?.id) {
-            const label = sessionUser.title?.trim() || sessionUser.name?.trim() || sessionUser.id;
-            return { id: sessionUser.id, type: 'user', fullName: label };
-        }
-        const audit = instance.auditInfo?.created?.by;
-        return {
-            id: audit?.id ?? '',
-            type: 'user',
-            fullName: audit?.fullName ?? '',
-        };
-    }
-    /**
-     * Builds interpolation params from `context._taskI18n` (workflow-defined; provider stays domain-agnostic).
-     */
-    buildTaskTranslationParams(context) {
-        const params = {};
-        const i18n = context?.[AXP_WORKFLOW_TASK_CONTEXT_I18N_KEY];
-        if (!i18n || typeof i18n !== 'object' || Array.isArray(i18n)) {
-            return params;
-        }
-        for (const [key, value] of Object.entries(i18n)) {
-            const text = this.toTaskTranslationParam(value);
-            if (text.length > 0) {
-                params[key] = text;
+            if (context.pendingNextTask &&
+                axpIsWorkflowTaskBoardActivityType(context.pendingNextTask.activityType)) {
+                const offered = await this.offerFromPendingNextTask(instance, context, context.pendingNextTask);
+                if (offered) {
+                    return;
+                }
             }
+            await this.offerFromInstanceBookmarks(instance, context);
         }
-        return params;
-    }
-    /**
-     * Normalizes bookmark context values for i18n interpolation (strings or multi-language maps).
-     */
-    toTaskTranslationParam(value) {
-        if (value == null) {
-            return '';
-        }
-        if (typeof value === 'string') {
-            return value.trim();
-        }
-        if (typeof value === 'number' || typeof value === 'boolean') {
-            return String(value);
-        }
-        if (typeof value === 'object') {
-            const resolved = this.translationService.resolve(value);
-            return resolved?.trim() ?? '';
+        catch (error) {
+            console.warn('[AXPWorkflowTaskContinuationService] offerAfterWorkflowStep failed', error);
         }
-        return String(value).trim();
     }
-    /**
-     * Resolves task copy: literal strings pass through; keys starting with `@` are translated with context params.
-     */
-    async resolveTaskDisplayText(value, params) {
-        const raw = value?.trim();
-        if (!raw) {
-            return '';
-        }
-        if (!raw.startsWith('@')) {
-            return raw;
+    //#endregion
+    //#region ----   Offer paths   ----
+    async offerFromPendingNextTask(instance, context, nextTask) {
+        const payload = this.buildPayloadFromWorkflowTask(nextTask);
+        const bookmark = this.bookmarkAccess
+            .getActiveBookmarks(instance)
+            .find((b) => b.activityId === nextTask.activityId);
+        const continuationCtx = {
+            instance,
+            bookmark: bookmark ?? { id: '', activityId: nextTask.activityId, type: 'user-task' },
+            payload,
+            sessionService: this.sessionService,
+            completedBookmarkId: context.completedBookmarkId,
+            completedActivityId: context.completedActivityId,
+        };
+        if (!shouldOfferWorkflowTaskContinuation(continuationCtx)) {
+            return false;
         }
-        return this.translationService.translateAsync(raw, { params });
+        return this.confirmAndAdvance(instance.id, context, continuationCtx, nextTask.activityId, bookmark?.id);
     }
-    /**
-     * Builds a display title from `context._taskTitleParts` when bookmark title is still generic.
-     */
-    composeTaskTitleFromContext(context) {
-        const parts = context?.[AXP_WORKFLOW_TASK_CONTEXT_TITLE_PARTS_KEY];
-        if (!Array.isArray(parts)) {
-            return '';
+    async offerFromInstanceBookmarks(instance, context) {
+        for (const bookmark of this.bookmarkAccess.getActiveBookmarks(instance)) {
+            if (this.isCompletedBookmark(bookmark, context)) {
+                continue;
+            }
+            const payload = parseWorkflowTaskContinuationPayload(bookmark);
+            if (!payload) {
+                continue;
+            }
+            const continuationCtx = {
+                instance,
+                bookmark,
+                payload,
+                sessionService: this.sessionService,
+                completedBookmarkId: context.completedBookmarkId,
+                completedActivityId: context.completedActivityId,
+            };
+            if (!shouldOfferWorkflowTaskContinuation(continuationCtx)) {
+                continue;
+            }
+            await this.confirmAndAdvance(instance.id, context, continuationCtx, bookmark.activityId, bookmark.id);
+            return;
         }
-        return parts
-            .map((part) => this.toTaskTranslationParam(part))
-            .filter((segment) => segment.length > 0)
-            .join(' — ');
-    }
-    /**
-     * True when bookmark title is the generic activity label, not workflow-specific copy.
-     */
-    isGenericHumanTaskTitle(title) {
-        const normalized = title?.trim().toLowerCase();
-        return (!normalized ||
-            normalized === 'human task' ||
-            normalized === 'cartable task' ||
-            normalized === 'workflow-activity:human-task' ||
-            normalized === 'workflow-activity:cartable' ||
-            normalized === 'workflow task');
     }
-    /**
-     * Resolve platform user id to a display label for the task board grid.
-     */
-    async resolveAssigneeReference(userId) {
-        const id = userId?.trim();
-        if (!id) {
-            return undefined;
+    async confirmAndAdvance(instanceId, context, continuationCtx, nextActivityId, nextBookmarkId) {
+        const takeOver = needsTakeOverForWorkflowTaskContinuation(continuationCtx);
+        const confirmed = await this.confirmContinueToNextStep(takeOver);
+        if (!confirmed) {
+            return true;
         }
-        try {
-            const row = await this.userEntityData.byKey(id);
-            if (!row || typeof row !== 'object') {
-                return { id, type: 'user', fullName: id };
+        if (takeOver) {
+            let bookmarkIdToUse = nextBookmarkId;
+            if (!bookmarkIdToUse) {
+                const found = await this.bookmarkAccess.findActiveBookmark(instanceId, nextActivityId);
+                bookmarkIdToUse = found?.bookmark.id;
             }
-            const displayName = 'displayName' in row ? String(row.displayName ?? '').trim() : '';
-            const username = 'username' in row ? String(row.username ?? '').trim() : '';
-            const fullName = displayName || username || id;
-            const ref = { id, type: 'user', fullName };
-            if (username) {
-                ref.username = username;
+            if (!bookmarkIdToUse) {
+                return true;
+            }
+            const reassigned = await this.humanTaskService.reassignBookmarkToCurrentUser(instanceId, bookmarkIdToUse, nextActivityId);
+            if (!reassigned) {
+                return true;
             }
-            return ref;
-        }
-        catch {
-            return { id, type: 'user', fullName: id };
         }
+        await this.humanTaskService.executePrimaryHumanTaskAction(instanceId, nextActivityId, {
+            suppressContinuation: true,
+            notifyViews: true,
+        });
+        return true;
     }
-    /**
-     * Map bookmark to task board task format.
-     */
-    async mapBookmarkToTask(instance, bookmark, payload) {
-        // Extract dates
-        const dueDate = payload.dueDate
-            ? typeof payload.dueDate === 'string'
-                ? new Date(payload.dueDate)
-                : payload.dueDate
-            : instance.createdAt
-                ? new Date(instance.createdAt)
-                : new Date();
-        const startDate = instance.createdAt ? new Date(instance.createdAt) : dueDate;
-        // If startDate and endDate are the same, set endDate to one day after startDate
-        let endDate = dueDate;
-        if (startDate.getTime() === dueDate.getTime()) {
-            endDate = new Date(startDate);
-            endDate.setDate(endDate.getDate() + 1);
+    //#endregion
+    //#region ----   Helpers   ----
+    isCompletedBookmark(bookmark, context) {
+        if (context.completedBookmarkId && bookmark.id === context.completedBookmarkId) {
+            return true;
         }
-        // Map priority
-        const priority = this.mapPriorityToTaskPriority(payload.priority || 'Normal');
-        const taskTranslationParams = this.buildTaskTranslationParams(payload.context);
-        let titleSource = payload.title || payload.activityName || 'Workflow Task';
-        if (this.isGenericHumanTaskTitle(titleSource)) {
-            const composed = this.composeTaskTitleFromContext(payload.context);
-            if (composed) {
-                titleSource = composed;
-            }
+        if (context.completedActivityId && bookmark.activityId === context.completedActivityId) {
+            return true;
         }
-        const title = await this.resolveTaskDisplayText(titleSource, taskTranslationParams);
-        const description = await this.resolveTaskDisplayText(payload.description || `Action required: ${payload.activityName}`, taskTranslationParams);
-        const assigneeId = payload.assignedUserIds?.[0];
-        const assignee = await this.resolveAssigneeReference(assigneeId);
+        return false;
+    }
+    buildPayloadFromWorkflowTask(task) {
+        const input = task.input ?? {};
+        const assigned = input['assignedUserIds'];
+        const assignedUserIds = Array.isArray(assigned)
+            ? assigned.map(String)
+            : assigned != null && String(assigned).length > 0
+                ? [String(assigned)]
+                : null;
         return {
-            id: bookmark.id, // Use bookmark ID as task ID
-            title,
-            description,
-            startDate,
-            endDate,
-            allDay: false,
-            assignee,
-            index: 2,
-            status: {
-                id: AXPSystemStatuses.Pending.name,
-                title: this.translationService.translateSync('@workflow-management:tasks.states.pending'),
-            },
-            priority,
-            reporter: this.buildReporterFromSession(instance),
-            data: {
-                // Store workflow instance and bookmark metadata
-                instanceId: instance.id,
-                bookmarkId: bookmark.id,
-                activityId: bookmark.activityId,
-                activityType: payload.activityType,
-                activityName: payload.activityName,
-                taskToken: payload.taskToken,
-                entityRefId: instance.entityRefId,
-                entityRefType: instance.entityRefType,
-                definitionId: instance.definitionId,
-                // Store full payload for actions
-                payload: payload,
-            },
+            activityType: task.activityType,
+            activityName: task.activityName ?? task.activityType,
+            taskToken: task.taskToken,
+            assignedUserIds,
+            candidateUserIds: input['candidateUserIds'],
+            title: input['title'],
+            description: input['description'],
+            actions: input['actions'],
+            context: input['context'],
         };
     }
-    /**
-     * Map priority to task board priority.
-     */
-    mapPriorityToTaskPriority(priority) {
-        switch (priority) {
-            case 'Urgent':
-                return 'highest';
-            case 'High':
-                return 'high';
-            case 'Normal':
-                return 'medium';
-            case 'Low':
-                return 'low';
-            default:
-                return 'medium';
-        }
-    }
-    //#endregion
-    //#region ----   Task Updates   ----
-    /**
-     * Update tasks (not applicable for workflow instances - they are read-only from task provider perspective).
-     */
-    async updateTasks(tasksToUpdate) {
-        // Workflow instances are managed by workflow engine
-        // Task updates should be done through workflow resume, not direct updates
-        return tasksToUpdate;
-    }
-    //#endregion
-    //#region ----   Command Execution   ----
-    /**
-     * Execute commands on tasks.
-     *
-     * Supports:
-     * - Workflow resume commands (Complete, Cancel)
-     */
-    async executeCommand(command) {
-        if (!command?.name)
-            return { success: true };
-        const taskData = command.options?.['data'];
-        const instanceId = taskData?.instanceId ?? command.options?.['instanceId'] ?? '';
-        const bookmarkId = taskData?.bookmarkId ?? command.options?.['bookmarkId'] ?? '';
-        const taskToken = taskData?.taskToken ?? command.options?.['taskToken'] ?? '';
-        const activityId = taskData?.activityId ?? command.options?.['activityId'] ?? command.options?.['stepId'] ?? '';
-        const outcome = command.options?.['outcome'] ?? 'Done';
-        const userInput = command.options?.['userInput'] ?? {};
-        if (command.name === 'WorkflowManagement.WorkflowInstance:ClaimTask') {
-            if (!instanceId || !bookmarkId || !activityId) {
-                return {
-                    success: false,
-                    message: {
-                        text: 'Missing required parameters: instanceId, bookmarkId, activityId',
-                    },
-                };
-            }
-            const claimResult = await this.workflowManager.claimTask(instanceId, bookmarkId, activityId);
-            if (!claimResult.success && claimResult.error) {
-                this.toastService.show({
-                    color: 'danger',
-                    title: await this.translationService.translateAsync('@general:messages.generic.error.title'),
-                    content: claimResult.error,
-                });
-            }
-            return {
-                success: claimResult.success,
-                message: claimResult.error
-                    ? {
-                        text: claimResult.error,
-                    }
-                    : undefined,
-            };
-        }
-        if (command.name === 'WorkflowManagement.WorkflowInstance:ReassignToSelf') {
-            if (!instanceId || !bookmarkId || !activityId) {
-                return {
-                    success: false,
-                    message: {
-                        text: 'Missing required parameters: instanceId, bookmarkId, activityId',
-                    },
-                };
-            }
-            if (!this.canTakeOverTask()) {
-                await this.showWorkflowTaskToast('@workflow-management:tasks.errors.not-assignee');
-                return { success: false };
-            }
-            const confirmed = await this.confirmReassignToSelf();
-            if (!confirmed) {
-                return { success: true };
-            }
-            const reassigned = await this.reassignTaskToSelf(instanceId, bookmarkId, activityId);
-            return { success: reassigned };
-        }
-        // Handle workflow resume commands
-        if (command.name === 'WorkflowManagement.WorkflowInstance:Resume' || command.name === 'resume-workflow') {
-            if (!instanceId || !taskToken || !activityId) {
-                return {
-                    success: false,
-                    message: {
-                        text: 'Missing required parameters: instanceId, taskToken, activityId',
-                    },
-                };
-            }
-            const result = await this.resumeWorkflowTask(instanceId, bookmarkId, activityId, outcome, userInput, taskToken);
-            return {
-                success: result.success,
-                message: result.error
-                    ? {
-                        text: result.error,
-                    }
-                    : undefined,
-            };
-        }
-        return { success: true };
-    }
-    //#endregion
-    //#region ----   Actions & Statuses   ----
-    /**
-     * Get available actions for a task.
-     *
-     * Extracts actions from bookmark payload.
-     */
-    async getActions(task) {
-        const actions = [];
-        if (!task)
-            return actions;
-        const taskData = task.data;
-        const payload = taskData?.payload;
-        if (!payload)
-            return actions;
-        if (this.isPooledClaimablePayload(payload)) {
-            actions.push({
-                name: 'claim',
-                title: this.translationService.translateSync('@workflow-management:tasks.actions.claim.title'),
-                icon: 'fa-light fa-hand',
-                color: 'primary',
-                priority: 'primary',
-                command: {
-                    name: 'WorkflowManagement.WorkflowInstance:ClaimTask',
-                    options: {
-                        instanceId: taskData.instanceId,
-                        bookmarkId: taskData.bookmarkId,
-                        activityId: taskData.activityId,
-                    },
-                },
-            });
-            return actions;
-        }
-        if (this.isReassignableHumanTaskPayload(payload) && this.canTakeOverTask()) {
-            actions.push({
-                name: 'reassign-to-self',
-                title: this.translationService.translateSync('@workflow-management:tasks.actions.reassign-to-self.title'),
-                icon: 'fa-light fa-user-check',
-                color: 'warning',
-                priority: 'secondary',
-                command: {
-                    name: 'WorkflowManagement.WorkflowInstance:ReassignToSelf',
-                    options: {
-                        instanceId: taskData.instanceId,
-                        bookmarkId: taskData.bookmarkId,
-                        activityId: taskData.activityId,
-                    },
-                },
-            });
-        }
-        // Extract actions from payload
-        if (payload.actions) {
-            const allActions = [...(payload.actions.prefix || []), ...(payload.actions.suffix || [])];
-            for (const action of allActions) {
-                const actionName = action.command?.name || action.name || 'unknown';
-                actions.push({
-                    name: actionName,
-                    title: action.title || actionName,
-                    icon: action.icon,
-                    color: action.color,
-                    priority: 'primary',
-                    command: {
-                        name: 'WorkflowManagement.WorkflowInstance:Resume',
-                        options: {
-                            instanceId: taskData.instanceId,
-                            bookmarkId: taskData.bookmarkId,
-                            activityId: taskData.activityId,
-                            taskToken: taskData.taskToken,
-                            outcome: actionName,
-                            userInput: {},
-                        },
-                    },
-                });
-            }
-        }
-        else {
-            // Default actions if none provided
-            actions.push({
-                name: 'submit',
-                title: this.translationService.translateSync('@general:actions.submit.title'),
-                icon: 'fa-light fa-check',
-                color: 'primary',
-                priority: 'primary',
-                command: {
-                    name: 'WorkflowManagement.WorkflowInstance:Resume',
-                    options: {
-                        instanceId: taskData.instanceId,
-                        bookmarkId: taskData.bookmarkId,
-                        activityId: taskData.activityId,
-                        taskToken: taskData.taskToken,
-                        outcome: 'submit',
-                        userInput: {},
-                    },
-                },
-            });
-            actions.push({
-                name: 'cancel',
-                title: this.translationService.translateSync('@general:actions.cancel.title'),
-                icon: 'fa-light fa-times',
-                color: 'default',
-                priority: 'secondary',
-                command: {
-                    name: 'WorkflowManagement.WorkflowInstance:Resume',
-                    options: {
-                        instanceId: taskData.instanceId,
-                        bookmarkId: taskData.bookmarkId,
-                        activityId: taskData.activityId,
-                        taskToken: taskData.taskToken,
-                        outcome: 'cancel',
-                        userInput: {},
-                    },
-                },
-            });
-        }
-        return actions;
-    }
-    async getExtraFields() {
-        return [];
-    }
-    async getStatuses() {
-        return [
-            {
-                index: 0,
-                key: AXPSystemStatuses.Pending.name,
-                title: await this.translationService.translateAsync('@workflow-management:tasks.states.pending'),
-                color: 'warning',
-            },
-        ];
-    }
-    //#endregion
-    //#region ----   Component   ----
-    getComponent() {
-        return () => import('./acorex-modules-workflow-management-workflow-task-popover.component-DMszilef.mjs').then((m) => m.AXMWorkflowTaskPopoverComponent);
+    async confirmContinueToNextStep(requiresTakeOver) {
+        const title = await this.translationService.translateAsync('@workflow-management:tasks.dialogs.continue-next-step.title');
+        const messageKey = requiresTakeOver
+            ? '@workflow-management:tasks.dialogs.continue-next-step.take-over-message'
+            : '@workflow-management:tasks.dialogs.continue-next-step.message';
+        const message = await this.translationService.translateAsync(messageKey);
+        const dialogResult = await this.dialogService.confirm(title, message, 'primary', 'horizontal', false, 'cancel');
+        return dialogResult.result === true;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGenericWorkflowTaskProvider, deps: [{ token: AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGenericWorkflowTaskProvider }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGenericWorkflowTaskProvider, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG]
-                }] }] });
-
-function provideTaskWorkflow() {
-    return makeEnvironmentProviders([
-        {
-            provide: AXP_WORKFLOW_TASK_PROVIDER,
-            multi: true,
-            useFactory: (injector) => {
-                return (async () => {
-                    const workflowDefinitionService = injector.get(AXPWorkflowDefinitionService);
-                    const multiLanguageResolver = injector.get(AXTranslationService);
-                    const categories = await workflowDefinitionService.getCategories();
-                    const providers = [];
-                    const seenDefinitionNames = new Set();
-                    for (const category of categories) {
-                        const workflows = await workflowDefinitionService.getWorkflowsByCategoryId(category.id);
-                        for (const workflow of workflows) {
-                            const key = workflow.name;
-                            if (!key || seenDefinitionNames.has(key)) {
-                                continue;
-                            }
-                            seenDefinitionNames.add(key);
-                            const provider = runInInjectionContext(injector, () => new AXPGenericWorkflowTaskProvider({
-                                name: workflow.name,
-                                title: multiLanguageResolver.resolve(workflow.title) ?? workflow.name,
-                                icon: 'fa-light fa-diagram-project',
-                                definitionId: workflow.name,
-                            }));
-                            providers.push(provider);
-                        }
-                    }
-                    return providers;
-                })();
-            },
-            deps: [Injector],
-        },
-    ]);
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowTaskContinuationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowTaskContinuationService, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPWorkflowTaskContinuationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
 class AXMWorkflowManagementModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMWorkflowManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
@@ -3380,8 +3221,8 @@ class AXMWorkflowManagementModule {
                 useClass: AXMWorkflowManagementModuleEntityProvider,
                 multi: true,
             },
-            provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-workflow-management-index-Eh5DDK-V.mjs').then((m) => m.AXMWorkflowInstanceActivityInstancesPageComponentProvider)),
-            provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-workflow-management-index-RRzkvrNM.mjs').then((m) => m.AXMWorkflowDefinitionActivitiesPageComponentProvider)),
+            provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-workflow-management-index-DC_9M9dk.mjs').then((m) => m.AXMWorkflowInstanceActivityInstancesPageComponentProvider)),
+            provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-workflow-management-index-BhVZ1Bcw.mjs').then((m) => m.AXMWorkflowDefinitionActivitiesPageComponentProvider)),
             // Automation condition builder: default automation.rules(refType, refId); modules override for their refTypes
             {
                 provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
@@ -3440,29 +3281,18 @@ class AXMWorkflowManagementModule {
             CartableTaskActivity,
             ShowToastActivity,
             CollectSignatureActivity,
-            // Generic Workflow Task Provider (all workflows – no definitionId filter).
-            // For one provider per definition, register in your module with definitionId, e.g.:
-            // { provide: AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG, useValue: { name: 'leave-request-workflow-tasks', title: 'Leave Request', definitionId: 'LeaveRequestWorkflow' } },
-            // { provide: AXP_WORKFLOW_TASK_PROVIDER, multi: true, useFactory: (c) => new AXPGenericWorkflowTaskProvider(c), deps: [AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG] }
-            // Leave Request workflow: task board shows suspended human-tasks.
-            // definitionId must match instance.definitionId: mock engine uses workflow name ('createLeaveRequest'); real API may use definition entity id.
-            // {
-            //   provide: AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG,
-            //   useValue: {
-            //     name: 'leave-request',
-            //     title: 'Leave Request Tasks',
-            //     icon: 'fa-light fa-diagram-project',
-            //     definitionId: 'createLeaveRequest',
-            //   } as AXPGenericWorkflowTaskProviderConfig,
-            // },
-            // {
-            //   provide: AXP_WORKFLOW_TASK_PROVIDER,
-            //   multi: true,
-            //   useFactory: (config: AXPGenericWorkflowTaskProviderConfig) =>
-            //     new AXPGenericWorkflowTaskProvider(config),
-            //   deps: [AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG],
-            // },
-            provideTaskWorkflow()
+            // Per-workflow task provider (lazy-loaded). Import provideGenericWorkflowTaskProvider from provider.task.ts:
+            // provideGenericWorkflowTaskProvider({
+            //   name: 'leave-request',
+            //   title: 'Leave Request Tasks',
+            //   icon: 'fa-light fa-diagram-project',
+            //   definitionId: 'createLeaveRequest',
+            // }),
+            provideTaskWorkflow(),
+            {
+                provide: AXP_WORKFLOW_CONTINUATION_HOOK,
+                useExisting: AXPWorkflowTaskContinuationService,
+            },
         ], imports: [AXMCalendarManagementModule,
             AXPDomainModule,
             AXMWorkflowPluginModule, // Register workflow plugin
@@ -3533,8 +3363,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                             useClass: AXMWorkflowManagementModuleEntityProvider,
                             multi: true,
                         },
-                        provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-workflow-management-index-Eh5DDK-V.mjs').then((m) => m.AXMWorkflowInstanceActivityInstancesPageComponentProvider)),
-                        provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-workflow-management-index-RRzkvrNM.mjs').then((m) => m.AXMWorkflowDefinitionActivitiesPageComponentProvider)),
+                        provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-workflow-management-index-DC_9M9dk.mjs').then((m) => m.AXMWorkflowInstanceActivityInstancesPageComponentProvider)),
+                        provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-modules-workflow-management-index-BhVZ1Bcw.mjs').then((m) => m.AXMWorkflowDefinitionActivitiesPageComponentProvider)),
                         // Automation condition builder: default automation.rules(refType, refId); modules override for their refTypes
                         {
                             provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
@@ -3593,29 +3423,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                         CartableTaskActivity,
                         ShowToastActivity,
                         CollectSignatureActivity,
-                        // Generic Workflow Task Provider (all workflows – no definitionId filter).
-                        // For one provider per definition, register in your module with definitionId, e.g.:
-                        // { provide: AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG, useValue: { name: 'leave-request-workflow-tasks', title: 'Leave Request', definitionId: 'LeaveRequestWorkflow' } },
-                        // { provide: AXP_WORKFLOW_TASK_PROVIDER, multi: true, useFactory: (c) => new AXPGenericWorkflowTaskProvider(c), deps: [AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG] }
-                        // Leave Request workflow: task board shows suspended human-tasks.
-                        // definitionId must match instance.definitionId: mock engine uses workflow name ('createLeaveRequest'); real API may use definition entity id.
-                        // {
-                        //   provide: AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG,
-                        //   useValue: {
-                        //     name: 'leave-request',
-                        //     title: 'Leave Request Tasks',
-                        //     icon: 'fa-light fa-diagram-project',
-                        //     definitionId: 'createLeaveRequest',
-                        //   } as AXPGenericWorkflowTaskProviderConfig,
-                        // },
-                        // {
-                        //   provide: AXP_WORKFLOW_TASK_PROVIDER,
-                        //   multi: true,
-                        //   useFactory: (config: AXPGenericWorkflowTaskProviderConfig) =>
-                        //     new AXPGenericWorkflowTaskProvider(config),
-                        //   deps: [AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG],
-                        // },
-                        provideTaskWorkflow()
+                        // Per-workflow task provider (lazy-loaded). Import provideGenericWorkflowTaskProvider from provider.task.ts:
+                        // provideGenericWorkflowTaskProvider({
+                        //   name: 'leave-request',
+                        //   title: 'Leave Request Tasks',
+                        //   icon: 'fa-light fa-diagram-project',
+                        //   definitionId: 'createLeaveRequest',
+                        // }),
+                        provideTaskWorkflow(),
+                        {
+                            provide: AXP_WORKFLOW_CONTINUATION_HOOK,
+                            useExisting: AXPWorkflowTaskContinuationService,
+                        },
                     ],
                 }]
         }] });
@@ -3626,9 +3445,1264 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
 // Entity exports - services and modules removed, handled by middleware
 // Exporting entity types for use in feature components
 
+//#region ----   Workflow task context (reserved keys)   ----
+/**
+ * Human-task / cartable `context` payload: technical ids at the root; display metadata under reserved keys.
+ *
+ * @example
+ * ```json
+ * {
+ *   "leaveRequestId": "{{ variables.leaveRequestId }}",
+ *   "_taskI18n": {
+ *     "employeeDisplayName": "{{ variables.employeeDisplayName }}",
+ *     "leaveTypeTitle": "{{ variables.leaveTypeTitle }}"
+ *   },
+ *   "_taskTitleParts": [
+ *     "{{ variables.employeeDisplayName }}",
+ *     "{{ variables.leaveTypeTitle }}"
+ *   ]
+ * }
+ * ```
+ */
+/** Interpolation map for `@scope:key` task title and description strings. */
+const AXP_WORKFLOW_TASK_CONTEXT_I18N_KEY = '_taskI18n';
+/** Ordered segments joined with " — " when bookmark title is still a generic activity label. */
+const AXP_WORKFLOW_TASK_CONTEXT_TITLE_PARTS_KEY = '_taskTitleParts';
+//#endregion
+
+/**
+ * Injection token for provider config. Use when registering via DI (provide token + useFactory with deps).
+ * Prefer {@link provideGenericWorkflowTaskProvider} (dynamic import) instead of a static class import in NgModule providers.
+ */
+const AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG = new InjectionToken('AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG');
+//#endregion
+//#region ----   Provider Class   ----
+/**
+ * Generic Workflow Task Provider
+ *
+ * Provides tasks from Workflow Instances directly (no Work Items).
+ * Queries suspended workflow instances and extracts tasks from bookmarks.
+ *
+ * Create one provider per workflow definition by passing a config (name, title, definitionId).
+ * E.g. leave request: { name: 'leave-request-workflow-tasks', title: 'Leave Request', definitionId: 'LeaveRequestWorkflow' }
+ *
+ * Architecture:
+ * - Queries Workflow Instances with subStatus = 'Suspended'
+ * - Filters by config.definitionId when set (one provider = one definition)
+ * - Extracts active bookmarks for each instance
+ * - Parses bookmark payload for assignment/actions
+ * - Maps to task board format
+ */
+class AXPGenericWorkflowTaskProvider extends AXPWorkflowTaskProvider {
+    //#endregion
+    //#region ----   Constructor   ----
+    constructor(config) {
+        super();
+        //#endregion
+        //#region ----   Services & Dependencies   ----
+        this.entityService = inject(AXPEntityService);
+        this.workflowInstanceData = this.entityService
+            .withEntity('WorkflowManagement', 'WorkflowInstance')
+            .data();
+        this.userEntityData = this.entityService.withEntity('SecurityManagement', 'User').data();
+        this.translationService = inject(AXTranslationService);
+        this.formatService = inject(AXFormatService);
+        this.settingsService = inject(AXPSettingsService);
+        this.entityRegistry = inject(AXPEntityDefinitionRegistryService);
+        this.statusDefinitionService = inject(AXPStatusDefinitionProviderService);
+        this.workflowDefinitionService = inject(AXPWorkflowDefinitionService);
+        this.workflowManager = inject(AXPWorkflowManager);
+        this.humanTaskService = inject(AXPWorkflowInstanceHumanTaskService);
+        this.sessionService = inject(AXPSessionService);
+        this.toastService = inject(AXToastService);
+        /** Per-provider caches (one instance per workflow definition). */
+        this.entityDefinitionCache = new Map();
+        this.statusDefinitionKeyByEntityType = new Map();
+        this.statusProviderByDefinitionKey = new Map();
+        this.userReferenceCache = new Map();
+        this.entityStatusIdCache = new Map();
+        this.config = config;
+    }
+    //#endregion
+    //#region ----   Provider Metadata   ----
+    get name() {
+        return this.config.name;
+    }
+    get title() {
+        return this.config.title;
+    }
+    get icon() {
+        return this.config.icon ?? 'fa-light fa-diagram-project';
+    }
+    //#endregion
+    //#region ----   Bookmark Helpers   ----
+    /** Bookmark types shown on the workflow task board. */
+    isTaskBoardBookmarkPayload(payload) {
+        const t = payload.activityType;
+        return t === 'workflow-activity:human-task' || t === 'workflow-activity:cartable';
+    }
+    /** Pooled task: must be claimed before submit/cancel (cartable, or human-task with candidates only). */
+    isPooledClaimablePayload(payload) {
+        const assigned = this.normalizeUserIdList(payload.assignedUserIds);
+        const candidates = this.normalizeUserIdList(payload.candidateUserIds);
+        if (payload.activityType === 'workflow-activity:cartable') {
+            return assigned.length === 0 && candidates.length > 0;
+        }
+        return payload.activityType === 'workflow-activity:human-task' && assigned.length === 0 && candidates.length > 0;
+    }
+    normalizeUserIdList(value) {
+        if (!value || value.length === 0)
+            return [];
+        return value.map((id) => String(id)).filter((s) => s.length > 0);
+    }
+    /** Human-task assigned to another user; current user may take over when permitted. */
+    isReassignableHumanTaskPayload(payload) {
+        if (payload.activityType !== 'workflow-activity:human-task') {
+            return false;
+        }
+        const assigned = this.normalizeUserIdList(payload.assignedUserIds);
+        if (assigned.length === 0) {
+            return false;
+        }
+        const currentUserId = this.sessionService.user?.id;
+        if (currentUserId == null) {
+            return false;
+        }
+        return !assigned.includes(String(currentUserId));
+    }
+    canTakeOverTask() {
+        return canReassignWorkflowTaskToSelf(this.sessionService);
+    }
+    //#endregion
+    //#region ----   Task Retrieval   ----
+    /**
+     * Get tasks from suspended workflow instances.
+     *
+     * Queries workflow instances filtered by:
+     * - subStatus = 'Suspended'
+     * - entityRefType (if provided in filter)
+     * - definitionId (if provided in filter)
+     * - assignee/claimant (if filter provided)
+     *
+     * Then extracts active bookmarks and maps to task board format.
+     */
+    async getTasks(options) {
+        // Build filter for workflow instances
+        const baseFilter = { logic: 'and', filters: [] };
+        // Filter by subStatus = 'Suspended' (only suspended workflows have pending tasks)
+        baseFilter.filters?.push({
+            field: 'subStatus',
+            operator: { type: 'equal' },
+            value: 'Suspended',
+        });
+        // Scope this provider to one workflow definition
+        if (this.config.definitionId) {
+            baseFilter.filters?.push({
+                field: 'definitionId',
+                operator: { type: 'equal' },
+                value: this.config.definitionId,
+            });
+        }
+        // Date range is applied after mapping bookmarks (task start/end overlap), not on instance createdAt.
+        // Query workflow instances
+        const { items: instances } = await this.workflowInstanceData.query({
+            skip: options?.skip ?? 0,
+            take: options?.take ?? 20,
+            filter: baseFilter,
+        });
+        // Extract tasks from bookmarks for each instance
+        const tasks = [];
+        for (const instance of instances) {
+            try {
+                // Get active bookmarks from instance entity (workflowInstance.bookmarks)
+                const bookmarks = this.getActiveBookmarksFromInstance(instance);
+                // Process each bookmark (typically one per suspended activity)
+                for (const bookmark of bookmarks) {
+                    try {
+                        // Get payload from entity (payload object or parse payloadJson)
+                        let payload;
+                        try {
+                            const raw = bookmark.payload ?? (bookmark.payloadJson ? JSON.parse(bookmark.payloadJson) : null);
+                            payload =
+                                typeof raw === 'object' && raw !== null
+                                    ? raw
+                                    : {};
+                        }
+                        catch {
+                            continue;
+                        }
+                        // Task board: human-task and cartable (pooled); exclude other suspended UI bookmarks
+                        if (!this.isTaskBoardBookmarkPayload(payload)) {
+                            continue;
+                        }
+                        // Check assignment filter if provided
+                        if (options?.assigneeIds && options.assigneeIds.length > 0) {
+                            const assignedIds = payload.assignedUserIds || [];
+                            const candidateIds = payload.candidateUserIds || [];
+                            const allUserIds = [...assignedIds, ...candidateIds].map(String);
+                            // TODO: Also check candidateRoleIds by resolving role members
+                            if (!matchesTaskBoardAssigneeUserIdsFilter(allUserIds, options.assigneeIds)) {
+                                continue;
+                            }
+                        }
+                        // Map bookmark to task
+                        const task = await this.mapBookmarkToTask(instance, bookmark, payload);
+                        tasks.push(task);
+                    }
+                    catch {
+                        // Skip this bookmark and continue
+                    }
+                }
+            }
+            catch {
+                // Skip this instance and continue
+            }
+        }
+        const rangeFiltered = filterTasksOverlappingRange(tasks, options?.range);
+        const total = rangeFiltered.length;
+        const skip = options?.skip ?? 0;
+        const take = options?.take ?? total;
+        const items = rangeFiltered.slice(skip, skip + take);
+        return { items, total };
+    }
+    /**
+     * Get active (non-consumed) bookmarks from workflow instance entity.
+     * Reads from instance.workflowInstance?.bookmarks — no direct DB access.
+     */
+    getActiveBookmarksFromInstance(instance) {
+        const wi = instance?.workflowInstance;
+        const bookmarks = wi?.bookmarks ?? [];
+        const active = bookmarks.filter((b) => !b.isConsumed && !b.consumed);
+        return active;
+    }
+    //#endregion
+    //#region ----   Task Display & Translation   ----
+    /** Task-board "started by": workflow instance creator (initiator), not the current viewer. */
+    buildStartedByFromInstance(instance) {
+        const audit = instance.auditInfo?.created?.by;
+        if (audit?.id) {
+            return {
+                id: audit.id,
+                type: 'user',
+                fullName: audit.fullName?.trim() || audit.id,
+            };
+        }
+        const sessionUser = this.sessionService.user;
+        if (sessionUser?.id) {
+            const label = sessionUser.title?.trim() || sessionUser.name?.trim() || sessionUser.id;
+            return { id: sessionUser.id, type: 'user', fullName: label };
+        }
+        return { id: '', type: 'user', fullName: '' };
+    }
+    /**
+     * Builds interpolation params from `context._taskI18n` (workflow-defined; provider stays domain-agnostic).
+     */
+    async buildTaskTranslationParams(context) {
+        const params = {};
+        const i18n = context?.[AXP_WORKFLOW_TASK_CONTEXT_I18N_KEY];
+        if (!i18n || typeof i18n !== 'object' || Array.isArray(i18n)) {
+            return params;
+        }
+        for (const [key, value] of Object.entries(i18n)) {
+            const text = await this.toTaskTranslationParam(value);
+            if (text.length > 0) {
+                params[key] = text;
+            }
+        }
+        return params;
+    }
+    /**
+     * Normalizes bookmark context values for i18n interpolation (strings or multi-language maps).
+     */
+    async toTaskTranslationParam(value) {
+        if (value == null) {
+            return '';
+        }
+        if (value instanceof Date) {
+            return this.formatDateForTaskDisplay(value);
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (!trimmed) {
+                return '';
+            }
+            if (this.isDateLikeString(trimmed)) {
+                return this.formatDateForTaskDisplay(trimmed);
+            }
+            return trimmed;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return String(value);
+        }
+        if (typeof value === 'object') {
+            const resolved = this.translationService.resolve(value);
+            return resolved?.trim() ?? '';
+        }
+        return String(value).trim();
+    }
+    /**
+     * Formats dates for task title/description interpolation using regional short-date settings.
+     */
+    async formatDateForTaskDisplay(value) {
+        const date = value instanceof Date
+            ? value
+            : this.parseDateOnlyString(value) ?? this.parseIsoDateString(value);
+        if (!date || Number.isNaN(date.getTime())) {
+            return typeof value === 'string' ? value.trim() : '';
+        }
+        const format = await this.settingsService.get(AXPRegionalSetting.ShortDate);
+        const formatted = this.formatService.format(date, 'date', { format });
+        return typeof formatted === 'string' ? formatted : String(formatted ?? '');
+    }
+    isDateLikeString(value) {
+        return /^\d{4}-\d{2}-\d{2}(?:T|$)/.test(value.trim());
+    }
+    parseIsoDateString(value) {
+        const parsed = new Date(value);
+        return Number.isNaN(parsed.getTime()) ? null : parsed;
+    }
+    /**
+     * Resolves task copy: literal strings pass through; keys starting with `@` are translated with context params.
+     */
+    async resolveTaskDisplayText(value, params) {
+        const raw = value?.trim();
+        if (!raw) {
+            return '';
+        }
+        if (!raw.startsWith('@')) {
+            return raw;
+        }
+        return this.translationService.translateAsync(raw, { params });
+    }
+    /**
+     * Builds a display title from `context._taskTitleParts` when bookmark title is still generic.
+     */
+    async composeTaskTitleFromContext(context) {
+        const parts = context?.[AXP_WORKFLOW_TASK_CONTEXT_TITLE_PARTS_KEY];
+        if (!Array.isArray(parts)) {
+            return '';
+        }
+        const segments = [];
+        for (const part of parts) {
+            const segment = await this.toTaskTranslationParam(part);
+            if (segment.length > 0) {
+                segments.push(segment);
+            }
+        }
+        return segments.join(' — ');
+    }
+    /**
+     * True when bookmark title is the generic activity label, not workflow-specific copy.
+     */
+    isGenericHumanTaskTitle(title) {
+        const normalized = title?.trim().toLowerCase();
+        return (!normalized ||
+            normalized === 'human task' ||
+            normalized === 'cartable task' ||
+            normalized === 'workflow-activity:human-task' ||
+            normalized === 'workflow-activity:cartable' ||
+            normalized === 'workflow task');
+    }
+    //#endregion
+    //#region ----   User Resolution   ----
+    /** Resolve platform user id to a display label for the task board grid. */
+    async resolveAssigneeReference(userId) {
+        const id = userId?.trim();
+        if (!id) {
+            return undefined;
+        }
+        const cached = this.userReferenceCache.get(id);
+        if (cached) {
+            return cached;
+        }
+        const load = this.loadUserReference(id);
+        this.userReferenceCache.set(id, load);
+        return load;
+    }
+    async loadUserReference(id) {
+        try {
+            const row = await this.userEntityData.byKey(id);
+            if (!row || typeof row !== 'object') {
+                return { id, type: 'user', fullName: id };
+            }
+            const displayName = 'displayName' in row ? String(row.displayName ?? '').trim() : '';
+            const username = 'username' in row ? String(row.username ?? '').trim() : '';
+            const fullName = displayName || username || id;
+            const ref = { id, type: 'user', fullName };
+            if (username) {
+                ref.username = username;
+            }
+            return ref;
+        }
+        catch {
+            return { id, type: 'user', fullName: id };
+        }
+    }
+    //#endregion
+    //#region ----   Task Mapping   ----
+    /** Map bookmark to task board task format. */
+    async mapBookmarkToTask(instance, bookmark, payload) {
+        // Extract dates
+        const dueDate = payload.dueDate
+            ? typeof payload.dueDate === 'string'
+                ? new Date(payload.dueDate)
+                : payload.dueDate
+            : instance.createdAt
+                ? new Date(instance.createdAt)
+                : new Date();
+        const startDate = instance.createdAt ? new Date(instance.createdAt) : dueDate;
+        // If startDate and endDate are the same, set endDate to one day after startDate
+        let endDate = dueDate;
+        if (startDate.getTime() === dueDate.getTime()) {
+            endDate = new Date(startDate);
+            endDate.setDate(endDate.getDate() + 1);
+        }
+        // Map priority
+        const priority = this.mapPriorityToTaskPriority(payload.priority || 'Normal');
+        const taskTranslationParams = await this.buildTaskTranslationParams(payload.context);
+        let titleSource = payload.title || payload.activityName || 'Workflow Task';
+        if (this.isGenericHumanTaskTitle(titleSource)) {
+            const composed = await this.composeTaskTitleFromContext(payload.context);
+            if (composed) {
+                titleSource = composed;
+            }
+        }
+        const title = await this.resolveTaskDisplayText(titleSource, taskTranslationParams);
+        const description = await this.resolveTaskDisplayText(payload.description || `Action required: ${payload.activityName}`, taskTranslationParams);
+        const assigneeId = payload.assignedUserIds?.[0];
+        const assignee = await this.resolveAssigneeReference(assigneeId);
+        const instanceCreatedAt = instance.createdAt ? new Date(instance.createdAt) : startDate;
+        const resolvedStatus = await this.resolveTaskStatus(payload, instance);
+        return {
+            id: bookmark.id, // Use bookmark ID as task ID
+            title,
+            description,
+            startDate,
+            endDate,
+            allDay: false,
+            assignee,
+            index: 2,
+            createdAt: instanceCreatedAt,
+            updatedAt: instance.updatedAt ? new Date(instance.updatedAt) : instanceCreatedAt,
+            status: {
+                id: resolvedStatus.id,
+                title: resolvedStatus.title,
+            },
+            priority,
+            reporter: this.buildStartedByFromInstance(instance),
+            data: {
+                // Store workflow instance and bookmark metadata
+                instanceId: instance.id,
+                bookmarkId: bookmark.id,
+                activityId: bookmark.activityId,
+                activityType: payload.activityType,
+                activityName: payload.activityName,
+                taskToken: payload.taskToken,
+                entityRefId: instance.entityRefId,
+                entityRefType: instance.entityRefType,
+                definitionId: instance.definitionId,
+                statusColor: resolvedStatus.color,
+                entityStatusDefinition: resolvedStatus.definition,
+                entityStatusDefinitionKey: resolvedStatus.definitionKey,
+                // Store full payload for actions
+                payload: payload,
+            },
+        };
+    }
+    /** Map workflow bookmark priority to task board priority. */
+    mapPriorityToTaskPriority(priority) {
+        switch (priority) {
+            case 'Urgent':
+                return 'highest';
+            case 'High':
+                return 'high';
+            case 'Normal':
+                return 'medium';
+            case 'Low':
+                return 'low';
+            default:
+                return 'medium';
+        }
+    }
+    //#endregion
+    //#region ----   Task Updates   ----
+    /**
+     * Update tasks (not applicable for workflow instances - they are read-only from task provider perspective).
+     */
+    async updateTasks(tasksToUpdate) {
+        // Workflow instances are managed by workflow engine
+        // Task updates should be done through workflow resume, not direct updates
+        return tasksToUpdate;
+    }
+    //#endregion
+    //#region ----   Command Execution   ----
+    /**
+     * Execute commands on tasks.
+     *
+     * Supports:
+     * - Workflow resume commands (Complete, Cancel)
+     */
+    async executeCommand(command) {
+        if (!command?.name)
+            return { success: true };
+        const taskData = command.options?.['data'];
+        const instanceId = taskData?.instanceId ?? command.options?.['instanceId'] ?? '';
+        const bookmarkId = taskData?.bookmarkId ?? command.options?.['bookmarkId'] ?? '';
+        const taskToken = taskData?.taskToken ?? command.options?.['taskToken'] ?? '';
+        const activityId = taskData?.activityId ?? command.options?.['activityId'] ?? command.options?.['stepId'] ?? '';
+        const outcome = command.options?.['outcome'] ?? 'Done';
+        const userInput = command.options?.['userInput'] ?? {};
+        if (command.name === 'WorkflowManagement.WorkflowInstance:ClaimTask') {
+            if (!instanceId || !bookmarkId || !activityId) {
+                return {
+                    success: false,
+                    message: {
+                        text: 'Missing required parameters: instanceId, bookmarkId, activityId',
+                    },
+                };
+            }
+            const claimResult = await this.workflowManager.claimTask(instanceId, bookmarkId, activityId);
+            if (!claimResult.success && claimResult.error) {
+                this.toastService.show({
+                    color: 'danger',
+                    title: await this.translationService.translateAsync('@general:messages.generic.error.title'),
+                    content: claimResult.error,
+                });
+            }
+            return {
+                success: claimResult.success,
+                message: claimResult.error
+                    ? {
+                        text: claimResult.error,
+                    }
+                    : undefined,
+            };
+        }
+        if (command.name === 'WorkflowManagement.WorkflowInstance:ReassignToSelf') {
+            if (!instanceId || !bookmarkId || !activityId) {
+                return {
+                    success: false,
+                    message: {
+                        text: 'Missing required parameters: instanceId, bookmarkId, activityId',
+                    },
+                };
+            }
+            const reassigned = await this.humanTaskService.reassignBookmarkToCurrentUserWithConfirm(instanceId, bookmarkId, activityId);
+            return { success: reassigned };
+        }
+        // Handle workflow resume commands
+        if (command.name === 'WorkflowManagement.WorkflowInstance:Resume' || command.name === 'resume-workflow') {
+            if (!instanceId || !taskToken || !activityId) {
+                return {
+                    success: false,
+                    message: {
+                        text: 'Missing required parameters: instanceId, taskToken, activityId',
+                    },
+                };
+            }
+            const result = await this.humanTaskService.resumeSuspendedHumanTask({
+                instanceId,
+                bookmarkId,
+                activityId,
+                taskToken,
+                outcome,
+                userInput: { ...userInput, bookmarkId },
+            });
+            if (result.success) {
+                this.refresh();
+            }
+            return {
+                success: result.success,
+                message: result.error
+                    ? {
+                        text: result.error,
+                    }
+                    : undefined,
+            };
+        }
+        return { success: true };
+    }
+    //#endregion
+    //#region ----   Actions & Statuses   ----
+    /**
+     * Get available actions for a task.
+     *
+     * Extracts actions from bookmark payload.
+     */
+    async getActions(task) {
+        const actions = [];
+        if (!task)
+            return actions;
+        const taskData = task.data;
+        const payload = taskData?.payload;
+        if (!payload)
+            return actions;
+        if (this.isPooledClaimablePayload(payload)) {
+            actions.push({
+                name: 'claim',
+                title: this.translationService.translateSync('@workflow-management:tasks.actions.claim.title'),
+                icon: 'fa-light fa-hand',
+                color: 'primary',
+                priority: 'primary',
+                command: {
+                    name: 'WorkflowManagement.WorkflowInstance:ClaimTask',
+                    options: {
+                        instanceId: taskData.instanceId,
+                        bookmarkId: taskData.bookmarkId,
+                        activityId: taskData.activityId,
+                    },
+                },
+            });
+            return actions;
+        }
+        // if (this.isReassignableHumanTaskPayload(payload) && this.canTakeOverTask()) {
+        //   actions.push({
+        //     name: 'reassign-to-self',
+        //     title: this.translationService.translateSync('@workflow-management:tasks.actions.reassign-to-self.title'),
+        //     icon: 'fa-light fa-user-check',
+        //     color: 'warning',
+        //     priority: 'secondary',
+        //     command: {
+        //       name: 'WorkflowManagement.WorkflowInstance:ReassignToSelf',
+        //       options: {
+        //         instanceId: taskData.instanceId,
+        //         bookmarkId: taskData.bookmarkId,
+        //         activityId: taskData.activityId,
+        //       },
+        //     },
+        //   });
+        // }
+        // Extract actions from payload
+        if (payload.actions) {
+            const allActions = [...(payload.actions.prefix || []), ...(payload.actions.suffix || [])];
+            for (const action of allActions) {
+                const actionName = action.command?.name || action.name || 'unknown';
+                actions.push({
+                    name: actionName,
+                    title: action.title || actionName,
+                    icon: action.icon,
+                    color: action.color,
+                    priority: 'primary',
+                    command: {
+                        name: 'WorkflowManagement.WorkflowInstance:Resume',
+                        options: {
+                            instanceId: taskData.instanceId,
+                            bookmarkId: taskData.bookmarkId,
+                            activityId: taskData.activityId,
+                            taskToken: taskData.taskToken,
+                            outcome: actionName,
+                            userInput: {},
+                        },
+                    },
+                });
+            }
+        }
+        else {
+            // Default actions if none provided
+            actions.push({
+                name: 'submit',
+                title: this.translationService.translateSync('@general:actions.submit.title'),
+                icon: 'fa-light fa-check',
+                color: 'primary',
+                priority: 'primary',
+                command: {
+                    name: 'WorkflowManagement.WorkflowInstance:Resume',
+                    options: {
+                        instanceId: taskData.instanceId,
+                        bookmarkId: taskData.bookmarkId,
+                        activityId: taskData.activityId,
+                        taskToken: taskData.taskToken,
+                        outcome: 'submit',
+                        userInput: {},
+                    },
+                },
+            });
+            actions.push({
+                name: 'cancel',
+                title: this.translationService.translateSync('@general:actions.cancel.title'),
+                icon: 'fa-light fa-times',
+                color: 'default',
+                priority: 'secondary',
+                command: {
+                    name: 'WorkflowManagement.WorkflowInstance:Resume',
+                    options: {
+                        instanceId: taskData.instanceId,
+                        bookmarkId: taskData.bookmarkId,
+                        activityId: taskData.activityId,
+                        taskToken: taskData.taskToken,
+                        outcome: 'cancel',
+                        userInput: {},
+                    },
+                },
+            });
+        }
+        return actions;
+    }
+    async getExtraFields() {
+        return [];
+    }
+    async getStatuses() {
+        const entityType = await this.resolvePrimaryEntityTypeForProvider();
+        if (entityType) {
+            const provider = await this.getEntityStatusProvider(entityType);
+            if (provider) {
+                return this.mapStatusProviderToTaskStatuses(provider);
+            }
+        }
+        return this.getWorkflowTaskStatuses();
+    }
+    //#endregion
+    //#region ----   Entity Status Resolution   ----
+    /** Resolves task status from bookmark context `statusId` and entity status plugin; falls back to workflow Pending. */
+    async resolveTaskStatus(payload, instance) {
+        const context = payload.context;
+        const entityType = await this.resolveEntityTypeForTask(context, instance);
+        if (!entityType) {
+            return this.getWorkflowPendingStatus();
+        }
+        const definitionKey = this.getStatusDefinitionKeyForEntityType(entityType);
+        if (!definitionKey) {
+            return this.getWorkflowPendingStatus();
+        }
+        const provider = await this.getStatusProviderByDefinitionKey(definitionKey);
+        if (!provider) {
+            return this.getWorkflowPendingStatus();
+        }
+        let statusId = this.readContextString(context, 'statusId');
+        if (this.isUnresolvedWorkflowExpression(statusId)) {
+            statusId = null;
+        }
+        if (!statusId) {
+            statusId = await this.loadEntityStatusIdFromContext(context, entityType, instance);
+        }
+        if (!statusId) {
+            statusId = await this.loadEntityStatusIdByWorkflowInstance(entityType, instance.id);
+        }
+        if (!statusId) {
+            const defaultStatus = provider.defaultStatus;
+            statusId = typeof defaultStatus === 'string' && defaultStatus.trim().length > 0 ? defaultStatus.trim() : null;
+        }
+        if (statusId) {
+            const definition = provider.statuses.find((status) => status.name === statusId);
+            if (definition) {
+                return {
+                    id: definition.name,
+                    title: await this.translateStatusTitle(definition.title),
+                    color: definition.color,
+                    definition,
+                    definitionKey,
+                };
+            }
+        }
+        return this.getWorkflowPendingStatus();
+    }
+    async resolveEntityTypeForTask(context, instance) {
+        const fromContext = this.readContextString(context, 'entityType');
+        if (fromContext && (await this.entityTypeHasStatusPlugin(fromContext))) {
+            return fromContext;
+        }
+        const refType = instance.entityRefType?.trim();
+        if (refType && (await this.entityTypeHasStatusPlugin(refType))) {
+            return refType;
+        }
+        return this.resolvePrimaryEntityTypeForProvider();
+    }
+    /** True when a bookmark value was stored without expression evaluation. */
+    isUnresolvedWorkflowExpression(value) {
+        if (!value) {
+            return false;
+        }
+        return /\{\{/.test(value) || /\}\}/.test(value);
+    }
+    /**
+     * Loads `statusId` from the linked entity row when bookmark context omits or stale-fails it.
+     */
+    async loadEntityStatusIdFromContext(context, entityType, instance) {
+        const contextEntityId = this.readContextString(context, 'lifecycleEventId');
+        const refType = instance.entityRefType?.trim();
+        const refId = instance.entityRefId?.trim();
+        const entityId = contextEntityId ??
+            (refType === entityType && refId ? refId : null);
+        if (!entityId) {
+            return null;
+        }
+        return this.loadEntityStatusId(entityType, entityId);
+    }
+    /**
+     * Finds a row of `entityType` linked to this workflow instance (e.g. LifecycleEvent.workflowInfo.instanceId).
+     */
+    async loadEntityStatusIdByWorkflowInstance(entityType, workflowInstanceId) {
+        const instanceId = workflowInstanceId?.trim();
+        if (!instanceId) {
+            return null;
+        }
+        const cacheKey = `${entityType}::wi::${instanceId}`;
+        const cached = this.entityStatusIdCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const load = this.fetchEntityStatusIdByWorkflowInstance(entityType, instanceId);
+        this.entityStatusIdCache.set(cacheKey, load);
+        return load;
+    }
+    async fetchEntityStatusIdByWorkflowInstance(entityType, instanceId) {
+        const parsed = this.parseQualifiedEntityType(entityType);
+        if (!parsed) {
+            return null;
+        }
+        try {
+            const { items } = await this.entityService.withEntity(parsed.module, parsed.name).data().query({
+                skip: 0,
+                take: 1,
+                filter: {
+                    logic: 'and',
+                    filters: [
+                        { field: AXP_RECORD_WORKFLOW_INFO_INSTANCE_ID_FIELD, operator: { type: 'equal' }, value: instanceId },
+                    ],
+                },
+            });
+            const row = items?.[0];
+            if (!row || typeof row !== 'object') {
+                return null;
+            }
+            const raw = row.statusId;
+            if (raw == null) {
+                return null;
+            }
+            const text = String(raw).trim();
+            return text.length > 0 ? text : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async loadEntityStatusId(entityType, entityId) {
+        const cacheKey = `${entityType}::${entityId}`;
+        const cached = this.entityStatusIdCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const load = this.fetchEntityStatusIdByKey(entityType, entityId);
+        this.entityStatusIdCache.set(cacheKey, load);
+        return load;
+    }
+    async fetchEntityStatusIdByKey(entityType, entityId) {
+        const parsed = this.parseQualifiedEntityType(entityType);
+        if (!parsed) {
+            return null;
+        }
+        try {
+            const row = await this.entityService.withEntity(parsed.module, parsed.name).data().byKey(entityId);
+            if (!row || typeof row !== 'object') {
+                return null;
+            }
+            const raw = row.statusId;
+            if (raw == null) {
+                return null;
+            }
+            const text = String(raw).trim();
+            return text.length > 0 ? text : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    //#endregion
+    //#region ----   Task Board Status Labels   ----
+    /** Fallback workflow task-board status when no entity status plugin applies. */
+    getWorkflowPendingStatus() {
+        return {
+            id: AXPSystemStatuses.Pending.name,
+            title: this.translationService.translateSync('@workflow-management:tasks.states.pending'),
+            color: 'warning',
+        };
+    }
+    async getWorkflowTaskStatuses() {
+        const pending = this.getWorkflowPendingStatus();
+        return [
+            {
+                index: 0,
+                key: pending.id,
+                title: pending.title,
+                color: pending.color,
+            },
+        ];
+    }
+    async mapStatusProviderToTaskStatuses(provider) {
+        const sorted = [...provider.statuses].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+        const statuses = [];
+        for (let index = 0; index < sorted.length; index++) {
+            const status = sorted[index];
+            statuses.push({
+                index,
+                key: status.name,
+                title: await this.translateStatusTitle(status.title),
+                color: status.color,
+            });
+        }
+        return statuses;
+    }
+    async translateStatusTitle(title) {
+        const raw = title?.trim();
+        if (!raw) {
+            return '';
+        }
+        if (raw.startsWith('@')) {
+            return this.translationService.translateAsync(raw);
+        }
+        return raw;
+    }
+    //#endregion
+    //#region ----   Entity Status Cache & Registry   ----
+    readContextString(context, key) {
+        const value = context?.[key];
+        if (value == null) {
+            return null;
+        }
+        const text = String(value).trim();
+        return text.length > 0 ? text : null;
+    }
+    parseQualifiedEntityType(entityType) {
+        const trimmed = entityType.trim();
+        const dot = trimmed.indexOf('.');
+        if (dot <= 0 || dot >= trimmed.length - 1) {
+            return null;
+        }
+        return { module: trimmed.slice(0, dot), name: trimmed.slice(dot + 1) };
+    }
+    async resolveEntityDefinition(entityType) {
+        const key = entityType.trim();
+        if (!key) {
+            return null;
+        }
+        const existing = this.entityDefinitionCache.get(key);
+        if (existing) {
+            return existing;
+        }
+        const load = this.fetchEntityDefinition(key);
+        this.entityDefinitionCache.set(key, load);
+        return load;
+    }
+    async fetchEntityDefinition(entityType) {
+        const parsed = this.parseQualifiedEntityType(entityType);
+        if (!parsed) {
+            return null;
+        }
+        try {
+            return await this.entityRegistry.resolve(parsed.module, parsed.name);
+        }
+        catch {
+            return null;
+        }
+    }
+    getStatusPluginDefinitionKey(entity) {
+        const plugin = entity.plugins?.find((p) => p.name === 'status');
+        const definition = plugin?.options?.['definition'];
+        return typeof definition === 'string' && definition.trim().length > 0 ? definition.trim() : null;
+    }
+    async entityTypeHasStatusPlugin(entityType) {
+        if (!entityType?.trim()) {
+            return false;
+        }
+        await this.warmStatusDefinitionKeyCache(entityType);
+        return this.getStatusDefinitionKeyForEntityType(entityType) != null;
+    }
+    getStatusDefinitionKeyForEntityType(entityType) {
+        const key = entityType.trim();
+        if (!key) {
+            return null;
+        }
+        if (this.statusDefinitionKeyByEntityType.has(key)) {
+            return this.statusDefinitionKeyByEntityType.get(key) ?? null;
+        }
+        return null;
+    }
+    /**
+     * Warms status-definition-key cache for an entity type (call after resolveEntityDefinition).
+     */
+    rememberStatusDefinitionKeyForEntityType(entityType, entity) {
+        const key = entityType.trim();
+        if (!key || this.statusDefinitionKeyByEntityType.has(key)) {
+            return;
+        }
+        const definitionKey = entity ? this.getStatusPluginDefinitionKey(entity) : null;
+        this.statusDefinitionKeyByEntityType.set(key, definitionKey);
+    }
+    async getEntityStatusProvider(entityType) {
+        let definitionKey = this.getStatusDefinitionKeyForEntityType(entityType);
+        if (!definitionKey) {
+            const entity = await this.resolveEntityDefinition(entityType);
+            this.rememberStatusDefinitionKeyForEntityType(entityType, entity);
+            definitionKey = this.getStatusDefinitionKeyForEntityType(entityType);
+        }
+        if (!definitionKey) {
+            return undefined;
+        }
+        return this.getStatusProviderByDefinitionKey(definitionKey);
+    }
+    getStatusProviderByDefinitionKey(definitionKey) {
+        const key = definitionKey.trim();
+        const existing = this.statusProviderByDefinitionKey.get(key);
+        if (existing) {
+            return existing;
+        }
+        const load = this.statusDefinitionService.getStatus(key);
+        this.statusProviderByDefinitionKey.set(key, load);
+        return load;
+    }
+    //#endregion
+    //#region ----   Entity Status Presentation   ----
+    /** Maps entity status semantic colors to badge-layout tokens (`info` → `accent3`). */
+    mapEntityStatusColorForBadge(color, statusId) {
+        const normalized = color?.trim().toLowerCase();
+        if (normalized === 'info') {
+            return 'accent3';
+        }
+        const badgeColors = new Set([
+            'primary',
+            'secondary',
+            'success',
+            'warning',
+            'danger',
+            'neutral',
+            'ghost',
+            'accent1',
+            'accent2',
+            'accent3',
+        ]);
+        if (normalized && badgeColors.has(normalized)) {
+            return normalized;
+        }
+        return this.resolveTaskStatusColor(statusId);
+    }
+    async findStatusDefinition(entityType, statusId) {
+        const provider = await this.getEntityStatusProvider(entityType);
+        return provider?.statuses.find((status) => status.name === statusId);
+    }
+    async warmStatusDefinitionKeyCache(entityType) {
+        if (this.statusDefinitionKeyByEntityType.has(entityType.trim())) {
+            return;
+        }
+        const entity = await this.resolveEntityDefinition(entityType);
+        this.rememberStatusDefinitionKeyForEntityType(entityType, entity);
+    }
+    /**
+     * First `entity-create` target in this workflow whose entity has a status plugin (cached per provider).
+     */
+    async resolvePrimaryEntityTypeForProvider() {
+        if (this.primaryEntityTypeWithStatus !== undefined) {
+            return this.primaryEntityTypeWithStatus;
+        }
+        let resolved = null;
+        const definitionId = this.config.definitionId?.trim();
+        if (definitionId) {
+            const definition = await this.workflowDefinitionService.getWorkflowByName(definitionId);
+            for (const activity of definition?.graph?.activities ?? []) {
+                if (activity.name !== 'workflow-activity:entity-create') {
+                    continue;
+                }
+                const entity = activity.inputs?.['entity'];
+                if (typeof entity !== 'string' || !entity.trim()) {
+                    continue;
+                }
+                const entityType = entity.trim();
+                await this.warmStatusDefinitionKeyCache(entityType);
+                if (this.getStatusDefinitionKeyForEntityType(entityType)) {
+                    resolved = entityType;
+                    break;
+                }
+            }
+        }
+        this.primaryEntityTypeWithStatus = resolved;
+        return resolved;
+    }
+    //#endregion
+    //#region ----   Popover Metadata   ----
+    async getPopoverMetadata(task) {
+        return this.buildPopoverMetadata(task);
+    }
+    /**
+     * Builds label/value metadata rows for the workflow task popover (view-mode widgets).
+     */
+    async buildPopoverMetadata(task) {
+        const context = {};
+        const fields = [];
+        const payload = task.data?.payload;
+        const pushField = (name, title, widgetType, value, options = {}, allowEmpty = false) => {
+            if (!allowEmpty && !this.hasMeaningfulPopoverValue(value)) {
+                return;
+            }
+            context[name] = value;
+            fields.push({
+                name,
+                title,
+                node: {
+                    type: widgetType,
+                    name,
+                    path: name,
+                    mode: 'view',
+                    options,
+                },
+            });
+        };
+        if (task.status?.id != null && String(task.status.id).trim()) {
+            const taskData = task.data;
+            const statusId = String(task.status.id);
+            const statusDefinition = taskData?.entityStatusDefinition;
+            const statusDefinitionKey = taskData?.entityStatusDefinitionKey;
+            if (statusDefinitionKey && statusDefinition) {
+                // Pass the full status definition so the chip renders before async provider load completes.
+                pushField('status', '@general:terms.status.title', AXPWidgetsList.Advanced.Status, statusDefinition, {
+                    definitionKey: statusDefinitionKey,
+                    readonly: true,
+                });
+            }
+            else {
+                const statusColor = this.mapEntityStatusColorForBadge(statusDefinition?.color ??
+                    task.data?.statusColor, task.status.id);
+                pushField('status', '@general:terms.status.title', AXPWidgetsList.Layouts.BadgeLayout, {
+                    text: task.status.title,
+                    color: statusColor,
+                    icon: statusDefinition?.icon ?? 'fa-light fa-flag',
+                }, { look: 'twotone' });
+            }
+        }
+        pushField('assignee', '@workflow-management:tasks.popover.assignee', AXPWidgetsCatalog.text, this.formatUserReferenceLabel(task.assignee), {}, true);
+        pushField('startedBy', '@workflow-management:tasks.popover.started-by', AXPWidgetsCatalog.text, this.formatUserReferenceLabel(task.reporter), {}, true);
+        const createdAt = task.createdAt ?? task.startDate;
+        if (createdAt) {
+            pushField('createdAt', '@workflow-management:tasks.popover.created', AXPWidgetsCatalog.dateTime, createdAt, {
+                showTime: false,
+            });
+        }
+        const effectiveDate = this.resolveEffectiveDateValue(payload?.context);
+        if (effectiveDate.kind === 'date') {
+            pushField('effectiveDate', '@workflow-management:tasks.popover.effective-date', AXPWidgetsCatalog.dateTime, effectiveDate.value, { showTime: false });
+        }
+        else if (effectiveDate.kind === 'text') {
+            pushField('effectiveDate', '@workflow-management:tasks.popover.effective-date', AXPWidgetsCatalog.text, effectiveDate.value);
+        }
+        if (task.priority) {
+            pushField('priority', '@workflow-management:tasks.popover.priority', AXPWidgetsList.Layouts.BadgeLayout, {
+                text: task.priority.charAt(0).toUpperCase() + task.priority.slice(1),
+                color: this.resolveTaskPriorityColor(task.priority),
+                icon: 'fa-light fa-exclamation-circle',
+            }, { look: 'twotone' });
+        }
+        return { context, fields };
+    }
+    //#endregion
+    //#region ----   Popover Helpers   ----
+    hasMeaningfulPopoverValue(value) {
+        if (value === null || value === undefined) {
+            return false;
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            return trimmed.length > 0 && trimmed !== '—';
+        }
+        if (value instanceof Date) {
+            return !Number.isNaN(value.getTime());
+        }
+        return true;
+    }
+    formatUserReferenceLabel(user) {
+        return user?.fullName?.trim() || user?.username?.trim() || '—';
+    }
+    resolveDueDate(raw) {
+        if (raw == null || raw === '') {
+            return null;
+        }
+        const date = typeof raw === 'string' ? new Date(raw) : raw;
+        return Number.isNaN(date.getTime()) ? null : date;
+    }
+    resolveEffectiveDateValue(context) {
+        if (!context || typeof context !== 'object') {
+            return { kind: 'none' };
+        }
+        const i18n = context[AXP_WORKFLOW_TASK_CONTEXT_I18N_KEY];
+        const rawFromI18n = i18n && typeof i18n === 'object' && !Array.isArray(i18n)
+            ? i18n['effectiveDate']
+            : undefined;
+        const raw = rawFromI18n ??
+            context['effectiveDate'] ??
+            (context['result'] && typeof context['result'] === 'object' && !Array.isArray(context['result'])
+                ? context['result']['effectiveDate']
+                : undefined);
+        if (raw instanceof Date) {
+            return Number.isNaN(raw.getTime()) ? { kind: 'none' } : { kind: 'date', value: raw };
+        }
+        if (typeof raw !== 'string' || !raw.trim()) {
+            return { kind: 'none' };
+        }
+        const trimmed = raw.trim();
+        const parsed = this.parseDateOnlyString(trimmed);
+        if (parsed) {
+            return { kind: 'date', value: parsed };
+        }
+        return { kind: 'text', value: trimmed };
+    }
+    /** Parses `yyyy-mm-dd` (and ISO date prefixes) in local time to avoid UTC day shifts in the date widget. */
+    parseDateOnlyString(value) {
+        const dateOnlyMatch = /^(\d{4})-(\d{2})-(\d{2})/.exec(value.trim());
+        if (!dateOnlyMatch) {
+            return null;
+        }
+        const year = Number(dateOnlyMatch[1]);
+        const month = Number(dateOnlyMatch[2]);
+        const day = Number(dateOnlyMatch[3]);
+        if (!year || month < 1 || month > 12 || day < 1 || day > 31) {
+            return null;
+        }
+        const local = new Date(year, month - 1, day);
+        return Number.isNaN(local.getTime()) ? null : local;
+    }
+    resolveTaskStatusColor(statusId) {
+        const id = String(statusId);
+        if (id === AXPSystemStatuses.Pending.name) {
+            return 'warning';
+        }
+        return 'primary';
+    }
+    resolveTaskPriorityColor(priority) {
+        switch (priority) {
+            case 'highest':
+                return 'danger';
+            case 'high':
+                return 'warning';
+            case 'medium':
+                return 'secondary';
+            case 'low':
+            case 'lowest':
+                return 'neutral';
+            default:
+                return 'primary';
+        }
+    }
+    //#endregion
+    //#region ----   Component   ----
+    getComponent() {
+        return () => import('./acorex-modules-workflow-management-workflow-task-popover.component-DjYDwHWU.mjs').then((m) => m.AXMWorkflowTaskPopoverComponent);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGenericWorkflowTaskProvider, deps: [{ token: AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGenericWorkflowTaskProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPGenericWorkflowTaskProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG]
+                }] }] });
+
+var genericWorkflowTask_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPGenericWorkflowTaskProvider: AXPGenericWorkflowTaskProvider,
+    AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG: AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG
+});
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXCCategoryProvider, AXMMenuProvider, AXMPermissionsKeys, AXMWorkflowActivitiesDefinitionProvider, AXMWorkflowManagementModule, AXMWorkflowManagementModuleEntityProvider, AXPCreateEntityActivity, AXPGenericWorkflowTaskProvider, AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG, AXP_WORKFLOW_TASK_CONTEXT_I18N_KEY, AXP_WORKFLOW_TASK_CONTEXT_TITLE_PARTS_KEY, CartableTaskActivity, CollectSignatureActivity, CreateEntityFormActivity, HumanTaskActivity, RootConfig, ShowConfirmPopupActivity, ShowLayoutPopupActivity, ShowToastActivity };
+export { AXCCategoryProvider, AXMMenuProvider, AXMPermissionsKeys, AXMWorkflowActivitiesDefinitionProvider, AXMWorkflowManagementModule, AXMWorkflowManagementModuleEntityProvider, AXPCreateEntityActivity, AXPGenericWorkflowTaskProvider, AXPWorkflowInstanceHumanTaskService, AXPWorkflowTaskContinuationService, AXP_GENERIC_WORKFLOW_TASK_PROVIDER_CONFIG, AXP_WORKFLOW_TASK_CONTEXT_I18N_KEY, AXP_WORKFLOW_TASK_CONTEXT_TITLE_PARTS_KEY, CartableTaskActivity, CollectSignatureActivity, CreateEntityFormActivity, HumanTaskActivity, RootConfig, ShowConfirmPopupActivity, ShowLayoutPopupActivity, ShowToastActivity, createWorkflowInstanceBookmarkAccess, getWorkflowInstanceInitiatorUserId, isWorkflowPlatformRootUser, isWorkflowPooledClaimablePayload, isWorkflowReassignableHumanTaskPayload, isWorkflowTaskBoardBookmarkPayload, needsTakeOverForWorkflowTaskContinuation, normalizeWorkflowTaskUserIds, parseWorkflowTaskContinuationPayload, provideGenericWorkflowTaskProvider, provideTaskWorkflow, shouldOfferWorkflowContinuationAfterStep, shouldOfferWorkflowTaskContinuation };
 //# sourceMappingURL=acorex-modules-workflow-management.mjs.map