@rytass/bpm-core-nestjs-module 0.15.0 → 0.17.0

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

@@ -1,9 +1,11 @@
 "use strict";
+var WorkflowEngineService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowEngineService = exports.MANUAL_TRANSFER_DELEGATION_REASON = exports.MAX_APPROVAL_INSTANCE_BUSINESS_KEY_LENGTH = void 0;
+exports.WorkflowEngineService = exports.ADMIN_REASSIGN_DELEGATION_REASON = exports.MANUAL_TRANSFER_DELEGATION_REASON = exports.MAX_APPROVAL_INSTANCE_BUSINESS_KEY_LENGTH = void 0;
 const tslib_1 = require("tslib");
 const class_validator_1 = require("class-validator");
 const form_1 = require("@rytass/bpm-core-shared/form");
+const workflow_1 = require("@rytass/bpm-core-shared/workflow");
 const workflow_graph_1 = require("@rytass/bpm-core-shared/workflow-graph");
 const workflow_webhook_delivery_service_1 = require("../workflow-webhook/workflow-webhook-delivery.service");
 const common_1 = require("@nestjs/common");
@@ -57,13 +59,65 @@ const SYSTEM_DRY_RUN_INSTANCE_ID = 'dry-run-instance';
  * opposed to {@link SLA_ESCALATION_DELEGATION_REASON}.
  */
 exports.MANUAL_TRANSFER_DELEGATION_REASON = 'MANUAL_TRANSFER';
+/**
+ * Delegation-chain reason for a seat an administrator moved to another member
+ * (see {@link WorkflowEngineService.reassignTask}). The step's `actorMemberId`
+ * names the administrator and `comment` carries the reason they typed.
+ */
+exports.ADMIN_REASSIGN_DELEGATION_REASON = 'ADMIN_REASSIGN';
+const TASK_REASSIGNMENT_MESSAGES = {
+    [workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.INSTANCE_NOT_RUNNING]: '案件已不在進行中',
+    [workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.REASON_REQUIRED]: '必須填寫改派原因',
+    [workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.SOURCE_NOT_ON_TASK]: '來源成員已不在此任務的待簽名單上',
+    [workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TARGET_ALREADY_DECIDED]: '接手人已對此任務簽過核',
+    [workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TARGET_ALREADY_ON_TASK]: '接手人已在此任務的待簽名單上',
+    [workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TARGET_GRADE_TOO_LOW]: '接手人職等不足，不能取代此簽核位置',
+    [workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TARGET_IS_INITIATOR]: '此節點不允許申請人自簽，接手人不能是申請人',
+    [workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TARGET_IS_SUBMITTER]: '此節點不允許代送人簽核，接手人不能是代為送出此單的人',
+    [workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TARGET_SAME_AS_SOURCE]: '接手人與原簽核人相同',
+    [workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TASK_NOT_OPEN]: '任務已不在待簽狀態',
+    [workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.UNEXPECTED_ERROR]: '改派時發生非預期錯誤',
+};
+/** Statuses in which a candidate row still holds a seat on the task. */
+const OPEN_SEAT_STATUSES = [
+    workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING,
+    workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED,
+    workflow_engine_enums_1.TaskCandidateStatusEnum.WAITING,
+];
+/** Closed row states that a member can be moved back into (one row per member per task). */
+const REUSABLE_SEAT_STATUSES = [
+    workflow_engine_enums_1.TaskCandidateStatusEnum.CANCELLED,
+    workflow_engine_enums_1.TaskCandidateStatusEnum.SUPERSEDED,
+    workflow_engine_enums_1.TaskCandidateStatusEnum.TRANSFERRED,
+];
+const OPEN_TASK_STATUSES = [
+    workflow_engine_enums_1.TaskStatusEnum.PENDING,
+    workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS,
+];
+function buildTaskReassignmentResult(task, outcome, errorCode) {
+    return {
+        errorCode,
+        instanceId: task.instanceId,
+        message: errorCode ? TASK_REASSIGNMENT_MESSAGES[errorCode] : null,
+        nodeId: task.nodeId,
+        outcome,
+        taskId: task.id,
+    };
+}
+/** A refused reassignment: raised while planning, before anything is written. */
+class TaskReassignmentRejectedError extends Error {
+    constructor(errorCode) {
+        super(TASK_REASSIGNMENT_MESSAGES[errorCode]);
+        this.errorCode = errorCode;
+    }
+}
 const WORKFLOW_READ_ALL_PERMISSIONS = new Set([
     'bpm:*',
     'bpm.workflow.read_all',
     'bpm:workflow:read_all',
     'workflow.read_all',
 ]);
-let WorkflowEngineService = class WorkflowEngineService {
+let WorkflowEngineService = WorkflowEngineService_1 = class WorkflowEngineService {
     constructor(approvalInstanceRepository, workflowTokenRepository, taskRepository, taskCandidateRepository, taskDecisionRepository, notificationRepository, activityLogRepository, adhocDirectiveRepository, approvalTemplateRepository, approvalTemplateVersionRepository, formDefinitionVersionRepository, attachmentService, conditionService, delegationService, notificationService, signatureService, slaScheduleService, injectedServiceTaskDispatcher, formDataSourceValueResolver, rootOptions, webhookDeliveryService) {
         this.approvalInstanceRepository = approvalInstanceRepository;
         this.workflowTokenRepository = workflowTokenRepository;
@@ -84,6 +138,7 @@ let WorkflowEngineService = class WorkflowEngineService {
         this.slaScheduleService = slaScheduleService;
         this.formDataSourceValueResolver = formDataSourceValueResolver;
         this.webhookDeliveryService = webhookDeliveryService;
+        this.logger = new common_1.Logger(WorkflowEngineService_1.name);
         // A binding under the token wins: that is either the host's own provider
         // or `workflowServiceTaskDispatcherProvider`, both of them deliberate. The
         // runtime instance from `BPMRootModule`'s async factory comes next.
@@ -356,6 +411,24 @@ let WorkflowEngineService = class WorkflowEngineService {
             if (!instance) {
                 throw new common_1.NotFoundException(`Approval instance ${task.instanceId} was not found`);
             }
+            if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.TRANSFERRED &&
+                transferToMemberId !== null &&
+                isGroupDecisionPolicy(readDecisionPolicySnapshot(task)) &&
+                taskCandidates.some((candidate) => candidate.memberId === transferToMemberId &&
+                    OPEN_SEAT_STATUSES.includes(candidate.status))) {
+                throw new common_1.ConflictException('Transfer target already holds an open seat on this task');
+            }
+            // A member who has decided keeps a COMPLETED row, and the database
+            // allows one row per (task, member): moving a seat to them would hit
+            // that index instead of answering why. Mirrors TARGET_ALREADY_DECIDED
+            // on the administrator reassignment.
+            if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.TRANSFERRED &&
+                transferToMemberId !== null &&
+                isGroupDecisionPolicy(readDecisionPolicySnapshot(task)) &&
+                taskCandidates.some((candidate) => candidate.memberId === transferToMemberId &&
+                    candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.COMPLETED)) {
+                throw new common_1.ConflictException('Transfer target has already decided this task');
+            }
             if (instance.state !== workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING) {
                 throw new common_1.ConflictException(`Approval instance ${instance.id} is not running`);
             }
@@ -449,6 +522,25 @@ let WorkflowEngineService = class WorkflowEngineService {
                 taskId: task.id,
                 transferToMemberId,
             }));
+            if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.TRANSFERRED &&
+                transferToMemberId !== null &&
+                isGroupDecisionPolicy(readDecisionPolicySnapshot(claimedTask))) {
+                await this.transferGroupSeat(manager, {
+                    actorCandidate: claimedCandidate,
+                    decidedAt,
+                    decision,
+                    instance,
+                    node: taskNode,
+                    reusableRow: taskCandidates.find((candidate) => candidate.memberId === transferToMemberId &&
+                        REUSABLE_SEAT_STATUSES.includes(candidate.status)) ?? null,
+                    signature,
+                    task: claimedTask,
+                    taskBeforeClaim: task,
+                    toMemberId: transferToMemberId,
+                    transferReason: options.transferReason ?? exports.MANUAL_TRANSFER_DELEGATION_REASON,
+                });
+                return decision;
+            }
             if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.TRANSFERRED) {
                 await this.transferTask(manager, instance, claimedTask, decision, signature, transferToMemberId, decisionComment, decidedAt, claimedCandidate, options.transferReason ?? exports.MANUAL_TRANSFER_DELEGATION_REASON);
                 await this.notificationService.resolveTaskNotifications({
@@ -582,21 +674,7 @@ let WorkflowEngineService = class WorkflowEngineService {
                 instance.state !== workflow_engine_enums_1.ApprovalInstanceStateEnum.RETURNED) {
                 throw new common_1.ConflictException(`Approval instance ${instance.id} is not cancellable`);
             }
-            const cancelledAt = new Date();
-            await this.consumeOpenRuntimeState(manager, instance, cancelledAt, workflow_engine_enums_1.TaskStatusEnum.CANCELLED);
-            await this.notificationService.supersedeInstanceTaskNotifications({
-                instanceId: instance.id,
-                manager,
-            });
-            // Same prototype-preserving reason as `cancelAdhocDirective`: this
-            // entity is returned to the resolver and `ApprovalInstance` exposes
-            // five getter-backed JSON fields.
-            const cancelledInstance = await instanceRepository.save(Object.assign(new approval_instance_entity_1.ApprovalInstanceEntity(), instance, {
-                completedAt: cancelledAt,
-                state: workflow_engine_enums_1.ApprovalInstanceStateEnum.CANCELLED,
-            }));
-            await this.dispatchAdhocCompletionNotifications(manager, cancelledInstance, workflow_engine_enums_1.ApprovalInstanceStateEnum.CANCELLED);
-            await this.cancelPendingAdhocDirectives(manager, instance.id, null);
+            const cancelledInstance = await this.closeInstance(manager, instance, workflow_engine_enums_1.ApprovalInstanceStateEnum.CANCELLED);
             await manager.getRepository(activity_log_entity_1.ActivityLogEntity).save(manager.getRepository(activity_log_entity_1.ActivityLogEntity).create({
                 actorMemberId: input.cancelledByMemberId,
                 eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.INSTANCE_CANCELLED,
@@ -610,6 +688,67 @@ let WorkflowEngineService = class WorkflowEngineService {
             return cancelledInstance;
         });
     }
+    /**
+     * Ends a running or returned instance because a task on it ran past its SLA
+     * with `onTimeout: 'TERMINATE_INSTANCE'`. It closes the instance exactly as
+     * a cancellation does, but lands in `EXPIRED` and is recorded with no actor:
+     * nobody chose to end it. An instance that is already closed — another
+     * overdue task of it got here first, or someone decided it meanwhile — is
+     * returned unchanged.
+     */
+    async expireApprovalInstance(input) {
+        return this.approvalInstanceRepository.manager.transaction(async (manager) => {
+            await manager.query('SELECT pg_advisory_xact_lock(hashtext($1))', [
+                input.instanceId,
+            ]);
+            const instance = await manager
+                .getRepository(approval_instance_entity_1.ApprovalInstanceEntity)
+                .findOne({ where: { id: input.instanceId } });
+            if (!instance) {
+                throw new common_1.NotFoundException(`Approval instance ${input.instanceId} was not found`);
+            }
+            if (instance.state !== workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING &&
+                instance.state !== workflow_engine_enums_1.ApprovalInstanceStateEnum.RETURNED) {
+                return instance;
+            }
+            const expiredInstance = await this.closeInstance(manager, instance, workflow_engine_enums_1.ApprovalInstanceStateEnum.EXPIRED);
+            await manager.getRepository(activity_log_entity_1.ActivityLogEntity).save(manager.getRepository(activity_log_entity_1.ActivityLogEntity).create({
+                actorMemberId: null,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.INSTANCE_EXPIRED,
+                instanceId: instance.id,
+                nodeId: input.nodeId ?? null,
+                payload: {
+                    comment: input.comment?.trim() || null,
+                },
+                taskId: input.taskId ?? null,
+            }));
+            return expiredInstance;
+        });
+    }
+    // Shared ending of a cancellation and an SLA expiry: everything open on the
+    // instance is closed, its task notifications are superseded, ad-hoc
+    // completion notices go out with the final state, and what is still pending
+    // is dropped. The caller records who (if anyone) ended it.
+    async closeInstance(manager, instance, finalState) {
+        const closedAt = new Date();
+        await this.consumeOpenRuntimeState(manager, instance, closedAt, workflow_engine_enums_1.TaskStatusEnum.CANCELLED);
+        await this.notificationService.supersedeInstanceTaskNotifications({
+            instanceId: instance.id,
+            manager,
+        });
+        // Same prototype-preserving reason as `cancelAdhocDirective`: this
+        // entity is returned to the resolver and `ApprovalInstance` exposes
+        // five getter-backed JSON fields.
+        const closedInstance = await manager
+            .getRepository(approval_instance_entity_1.ApprovalInstanceEntity)
+            .save(Object.assign(new approval_instance_entity_1.ApprovalInstanceEntity(), instance, {
+            completedAt: closedAt,
+            state: finalState,
+        }));
+        await this.dispatchAdhocCompletionNotifications(manager, closedInstance, finalState);
+        await this.cancelPendingAdhocDirectives(manager, instance.id, null);
+        return closedInstance;
+    }
     async resubmitApprovalInstance(input, authContext) {
         const formData = parseJsonObject(input.formDataJson, 'formDataJson');
         const preparation = this.formDataSourceValueResolver
@@ -1804,14 +1943,13 @@ let WorkflowEngineService = class WorkflowEngineService {
             view: workflow_engine_enums_1.ApprovalInstanceListViewEnum.ALL,
         })).filter((instance) => isInstanceWithinRange(instance, options));
         const instanceIds = instances.map((instance) => instance.id);
-        const openTasks = instanceIds.length
-            ? await this.taskRepository.find({
-                where: {
-                    instanceId: (0, typeorm_2.In)(instanceIds),
-                    status: (0, typeorm_2.In)([workflow_engine_enums_1.TaskStatusEnum.PENDING, workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS]),
-                },
-            })
-            : [];
+        // The task counters answer "what is waiting on me", not "what is open on
+        // the instances I can see": a member who can read an instance as initiator,
+        // reader or administrator is not thereby the one who has to act on it. So
+        // they count the member's own inbox, narrowed to the instances in range.
+        // Without a scope there is no member to speak for, and the counters keep
+        // describing every open task.
+        const openTasks = await this.readDashboardOpenTasks(scope, instanceIds);
         const now = Date.now();
         return {
             activeInstanceCount: instances.filter((instance) => instance.state === workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING).length,
@@ -1822,6 +1960,21 @@ let WorkflowEngineService = class WorkflowEngineService {
             totalInstanceCount: instances.length,
         };
     }
+    async readDashboardOpenTasks(scope, instanceIds) {
+        if (!instanceIds.length) {
+            return [];
+        }
+        if (scope) {
+            const instanceIdSet = new Set(instanceIds);
+            return (await this.readOpenInboxTasks(scope.memberId)).filter((task) => instanceIdSet.has(task.instanceId));
+        }
+        return this.taskRepository.find({
+            where: {
+                instanceId: (0, typeorm_2.In)(instanceIds),
+                status: (0, typeorm_2.In)([workflow_engine_enums_1.TaskStatusEnum.PENDING, workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS]),
+            },
+        });
+    }
     async listLaunchableApprovalTemplates(memberId) {
         const templates = await this.approvalTemplateRepository.find({
             order: { updatedAt: 'DESC' },
@@ -1869,6 +2022,20 @@ let WorkflowEngineService = class WorkflowEngineService {
         }));
     }
     async listInboxTasks(assigneeMemberId) {
+        return this.attachTaskCandidateSummaries(await this.readOpenInboxTasks(assigneeMemberId));
+    }
+    /**
+     * The open tasks that are this member's own to act on — the single
+     * definition behind both the inbox list and the dashboard counters, so the
+     * two can never disagree. A task is theirs when it is assigned to them, or
+     * when they hold a PENDING or CLAIMED candidate row on it. A sequential
+     * chain's later candidates sit in WAITING until it is their turn, so a task
+     * that has not reached them is not theirs yet.
+     */
+    async readOpenInboxTasks(assigneeMemberId, candidateStatuses = [
+        workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING,
+        workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED,
+    ]) {
         const directTasks = await this.taskRepository.find({
             order: { createdAt: 'DESC' },
             where: [
@@ -1881,10 +2048,7 @@ let WorkflowEngineService = class WorkflowEngineService {
         const candidateRows = await this.taskCandidateRepository.find({
             where: {
                 memberId: assigneeMemberId,
-                status: (0, typeorm_2.In)([
-                    workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING,
-                    workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED,
-                ]),
+                status: (0, typeorm_2.In)(candidateStatuses),
             },
         });
         const candidateTasks = candidateRows.length
@@ -1918,7 +2082,7 @@ let WorkflowEngineService = class WorkflowEngineService {
             })
             : [];
         const settledTaskIds = new Set(settledCandidateRows.map((candidate) => candidate.taskId));
-        return this.attachTaskCandidateSummaries(openTasks.filter((task) => !settledTaskIds.has(task.id)));
+        return openTasks.filter((task) => !settledTaskIds.has(task.id));
     }
     async listApprovalHistoryTasks(assigneeMemberId) {
         const directTasks = await this.taskRepository.find({
@@ -2951,6 +3115,439 @@ let WorkflowEngineService = class WorkflowEngineService {
             });
         }
     }
+    /**
+     * Administrator reassignment of one open task, moved in place: the task keeps
+     * its id, decision policy, SLA and every other seat. Only `fromMemberId`'s
+     * seat (and the assignee field, when it is theirs) moves to `toMemberId`.
+     *
+     * This is not a decision by the holder: it writes no TaskDecision and no
+     * signature. It is recorded as a TASK_REASSIGNED activity and an
+     * {@link ADMIN_REASSIGN_DELEGATION_REASON} delegation step.
+     *
+     * Unlike the holder's transfer, the target is NOT run through the delegation
+     * rules (a rule for `toMemberId` does not apply). The initiator and submitter
+     * exclusions and the grade check of ORG_MANAGER_CHAIN nodes still do.
+     *
+     * A refused reassignment is reported as `REJECTED` with an error code. When
+     * `dryRun` is off, a refusal is thrown as a ConflictException whose message
+     * carries that code.
+     */
+    async reassignTask(taskId, options) {
+        const task = await this.taskRepository.findOne({ where: { id: taskId } });
+        if (!task) {
+            throw new common_1.NotFoundException(`Task ${taskId} was not found`);
+        }
+        const result = await this.executeTaskReassignment(task, options);
+        if (result.outcome === workflow_engine_enums_1.TaskReassignmentOutcomeEnum.REJECTED &&
+            !options.dryRun) {
+            throw new common_1.ConflictException(`[${result.errorCode}] ${result.message ?? ''}`.trim());
+        }
+        return result;
+    }
+    /**
+     * Runs {@link reassignTask} for every open task `fromMemberId` holds, each in
+     * its own transaction, and reports one result per task. A failing task does
+     * not stop the others: a refusal is a REJECTED result, and an unexpected
+     * error is reported as REJECTED with UNEXPECTED_ERROR for that task alone.
+     */
+    async reassignMemberTasks(options) {
+        const held = await this.readRunningMemberTasks(options.fromMemberId);
+        return held.reduce(async (previous, { task }) => {
+            const results = await previous;
+            const result = await this.executeTaskReassignment(task, options).catch((error) => {
+                this.logger.warn(`Reassigning task ${task.id} failed: ${error instanceof Error ? error.message : String(error)}`);
+                return buildTaskReassignmentResult(task, workflow_engine_enums_1.TaskReassignmentOutcomeEnum.REJECTED, workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.UNEXPECTED_ERROR);
+            });
+            return [...results, result];
+        }, Promise.resolve([]));
+    }
+    /**
+     * The open tasks a member holds, for the administrator's reassignment screen.
+     * Same definition as the inbox, plus WAITING sequential seats, restricted to
+     * RUNNING instances.
+     */
+    async listMemberOpenTasks(memberId) {
+        const held = await this.readRunningMemberTasks(memberId);
+        if (!held.length) {
+            return [];
+        }
+        const tasks = await this.attachTaskCandidateSummaries(held.map(({ task }) => task));
+        const openRows = await this.taskCandidateRepository.find({
+            where: {
+                memberId,
+                status: (0, typeorm_2.In)(OPEN_SEAT_STATUSES),
+                taskId: (0, typeorm_2.In)(tasks.map((task) => task.id)),
+            },
+        });
+        // One query for every template, not one per template: the listing opens
+        // each time an administrator opens the reassignment screen.
+        const templates = await this.approvalTemplateRepository.find({
+            where: {
+                id: (0, typeorm_2.In)([...new Set(held.map(({ instance }) => instance.templateId))]),
+            },
+        });
+        const templateNameById = new Map(templates.map((template) => [
+            template.id,
+            template.name,
+        ]));
+        const openRowByTaskId = new Map(openRows.map((row) => [
+            row.taskId,
+            row,
+        ]));
+        const summaryByTaskId = new Map(tasks.map((summary) => [
+            summary.id,
+            summary,
+        ]));
+        return held.map(({ instance, task }) => {
+            const row = openRowByTaskId.get(task.id);
+            const summary = summaryByTaskId.get(task.id);
+            return {
+                candidateStatus: row?.status ?? null,
+                createdAt: task.createdAt,
+                decisionPolicyType: readDecisionPolicySnapshot(task).type,
+                businessKey: instance.businessKey,
+                instanceId: instance.id,
+                instanceTitle: instance.title,
+                memberRole: row
+                    ? workflow_engine_enums_1.MemberTaskRoleEnum.CANDIDATE
+                    : workflow_engine_enums_1.MemberTaskRoleEnum.ASSIGNEE,
+                nodeId: task.nodeId,
+                nodeLabel: summary?.nodeLabel ?? null,
+                slaDueAt: task.slaDueAt,
+                taskId: task.id,
+                templateId: instance.templateId,
+                templateName: templateNameById.get(instance.templateId) ?? null,
+            };
+        });
+    }
+    /**
+     * The open tasks `memberId` holds on RUNNING instances, with the instance
+     * each belongs to. The instance filter is applied here, not only in the query.
+     */
+    async readRunningMemberTasks(memberId) {
+        const tasks = await this.readOpenInboxTasks(memberId, OPEN_SEAT_STATUSES);
+        if (!tasks.length) {
+            return [];
+        }
+        const instances = await this.approvalInstanceRepository.find({
+            where: { id: (0, typeorm_2.In)([...new Set(tasks.map((task) => task.instanceId))]) },
+        });
+        const runningById = new Map(instances
+            .filter((instance) => instance.state === workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING)
+            .map((instance) => [
+            instance.id,
+            instance,
+        ]));
+        return tasks.flatMap((task) => {
+            const instance = runningById.get(task.instanceId);
+            return instance ? [{ instance, task }] : [];
+        });
+    }
+    async executeTaskReassignment(preRead, options) {
+        return this.approvalInstanceRepository.manager.transaction(async (manager) => {
+            try {
+                const plan = await this.planTaskReassignment(manager, preRead.id, options);
+                if (options.dryRun) {
+                    return buildTaskReassignmentResult(preRead, workflow_engine_enums_1.TaskReassignmentOutcomeEnum.WOULD_REASSIGN, null);
+                }
+                await this.applyTaskReassignment(manager, plan, options);
+                return buildTaskReassignmentResult(preRead, workflow_engine_enums_1.TaskReassignmentOutcomeEnum.REASSIGNED, null);
+            }
+            catch (error) {
+                // Planning writes nothing, so a refusal commits no change.
+                if (error instanceof TaskReassignmentRejectedError) {
+                    return buildTaskReassignmentResult(preRead, workflow_engine_enums_1.TaskReassignmentOutcomeEnum.REJECTED, error.errorCode);
+                }
+                throw error;
+            }
+        });
+    }
+    /**
+     * Checks every rule of an administrator reassignment under the instance lock,
+     * against the rows as they are now. Writes nothing; a refusal throws
+     * {@link TaskReassignmentRejectedError}.
+     */
+    async planTaskReassignment(manager, taskId, options) {
+        const fromMemberId = options.fromMemberId;
+        const toMemberId = options.toMemberId;
+        if (!options.reason.trim()) {
+            throw new TaskReassignmentRejectedError(workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.REASON_REQUIRED);
+        }
+        if (fromMemberId === toMemberId) {
+            throw new TaskReassignmentRejectedError(workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TARGET_SAME_AS_SOURCE);
+        }
+        const taskRepository = manager.getRepository(task_entity_1.TaskEntity);
+        const unlockedTask = await taskRepository.findOne({
+            where: { id: taskId },
+        });
+        if (!unlockedTask) {
+            throw new TaskReassignmentRejectedError(workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TASK_NOT_OPEN);
+        }
+        await manager.query('SELECT pg_advisory_xact_lock(hashtext($1))', [
+            unlockedTask.instanceId,
+        ]);
+        // Read again under the lock: the task may have been decided or moved while
+        // this request waited for it.
+        const task = await taskRepository.findOne({ where: { id: taskId } });
+        if (!task || !OPEN_TASK_STATUSES.includes(task.status)) {
+            throw new TaskReassignmentRejectedError(workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TASK_NOT_OPEN);
+        }
+        const instance = await manager
+            .getRepository(approval_instance_entity_1.ApprovalInstanceEntity)
+            .findOne({ where: { id: task.instanceId } });
+        if (!instance || instance.state !== workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING) {
+            throw new TaskReassignmentRejectedError(workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.INSTANCE_NOT_RUNNING);
+        }
+        const node = readWorkflowNodeOrThrow(instance.workflowSnapshot, task.nodeId);
+        if (node.type !== 'userTask') {
+            throw new common_1.ConflictException(`Task ${task.id} is not bound to a user task node`);
+        }
+        const candidates = await manager
+            .getRepository(task_candidate_entity_1.TaskCandidateEntity)
+            .find({ where: { taskId: task.id } });
+        const sourceRow = candidates.find((candidate) => candidate.memberId === fromMemberId &&
+            OPEN_SEAT_STATUSES.includes(candidate.status)) ?? null;
+        // A holder with no candidate row at all is the assignee of a direct task.
+        // Anyone with a row that is not open (COMPLETED, TRANSFERRED, ...) no
+        // longer has a seat, so they are refused even when they are the assignee.
+        const sourceHasAnyRow = candidates.some((candidate) => candidate.memberId === fromMemberId);
+        if (!sourceRow &&
+            !(task.assigneeMemberId === fromMemberId && !sourceHasAnyRow)) {
+            throw new TaskReassignmentRejectedError(workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.SOURCE_NOT_ON_TASK);
+        }
+        const targetRows = candidates.filter((candidate) => candidate.memberId === toMemberId);
+        const targetDecisions = await manager
+            .getRepository(task_decision_entity_1.TaskDecisionEntity)
+            .find({ where: { decidedByMemberId: toMemberId, taskId: task.id } });
+        // Checked before "already on task": a member who has decided here may
+        // still be the assignee field, and the decided reason is the useful one.
+        if (targetDecisions.length > 0 ||
+            targetRows.some((candidate) => candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.COMPLETED)) {
+            throw new TaskReassignmentRejectedError(workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TARGET_ALREADY_DECIDED);
+        }
+        if (task.assigneeMemberId === toMemberId ||
+            targetRows.some((candidate) => OPEN_SEAT_STATUSES.includes(candidate.status))) {
+            throw new TaskReassignmentRejectedError(workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TARGET_ALREADY_ON_TASK);
+        }
+        if (isInitiatorExcluded(node)) {
+            if (toMemberId === instance.initiatorMemberId) {
+                throw new TaskReassignmentRejectedError(workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TARGET_IS_INITIATOR);
+            }
+            if (toMemberId === (0, instance_submitter_1.readDistinctSubmitterMemberId)(instance)) {
+                throw new TaskReassignmentRejectedError(workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TARGET_IS_SUBMITTER);
+            }
+        }
+        if (!task.isAdhoc && isOrgManagerChainNode(node)) {
+            const requiredGrade = await this.readTransferTargetRequiredGrade(manager, {
+                actorMemberId: fromMemberId,
+                delegationChain: sourceRow?.delegationChain ?? task.delegationChain,
+                targetMemberId: toMemberId,
+            });
+            if (requiredGrade !== null) {
+                throw new TaskReassignmentRejectedError(workflow_engine_enums_1.TaskReassignmentErrorCodeEnum.TARGET_GRADE_TOO_LOW);
+            }
+        }
+        return {
+            instance,
+            node,
+            reusableRow: targetRows.find((candidate) => REUSABLE_SEAT_STATUSES.includes(candidate.status)) ?? null,
+            sourceRow,
+            task,
+        };
+    }
+    async applyTaskReassignment(manager, plan, options) {
+        const decidedAt = new Date();
+        const reason = options.reason.trim();
+        const step = {
+            actorMemberId: options.actorMemberId,
+            comment: reason,
+            from: options.fromMemberId,
+            reason: exports.ADMIN_REASSIGN_DELEGATION_REASON,
+            ruleId: null,
+            to: options.toMemberId,
+        };
+        const seat = await this.replaceOpenSeat(manager, {
+            decidedAt,
+            fromMemberId: options.fromMemberId,
+            reusableRow: plan.reusableRow,
+            sourceRow: plan.sourceRow,
+            step,
+            task: plan.task,
+            toMemberId: options.toMemberId,
+        });
+        const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+        await activityRepository.save(activityRepository.create({
+            actorMemberId: options.actorMemberId,
+            eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TASK_REASSIGNED,
+            instanceId: plan.instance.id,
+            nodeId: plan.task.nodeId,
+            payload: {
+                actorMemberId: options.actorMemberId,
+                assigneeChanged: seat.assigneeMoved,
+                candidateStatus: plan.sourceRow?.status ?? null,
+                fromMemberId: options.fromMemberId,
+                reason,
+                sequence: plan.sourceRow?.sequence ?? null,
+                toMemberId: options.toMemberId,
+            },
+            taskId: plan.task.id,
+        }));
+        await this.notifySeatReplaced(manager, {
+            fromMemberId: options.fromMemberId,
+            instance: plan.instance,
+            node: plan.node,
+            seat,
+            toMemberId: options.toMemberId,
+        });
+    }
+    /**
+     * A holder's transfer of their seat on a group stage (PARALLEL_ALL,
+     * PARALLEL_ANY, QUORUM). The stage stays open: the transferring seat moves
+     * to the target in place, the other seats keep their state, and the task
+     * keeps its id. Unlike transferTask, no replacement SINGLE task is created
+     * and the other voters are not superseded. The transferring member's
+     * decision and signature are kept on the task.
+     */
+    async transferGroupSeat(manager, { actorCandidate, decidedAt, decision, instance, node, reusableRow, signature, task, taskBeforeClaim, toMemberId, transferReason, }) {
+        const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+        const fromMemberId = decision.decidedByMemberId;
+        // decideTask claims the task for whoever decides, writing them into the
+        // task-level assignee. A seat transfer is not a claim of the whole stage:
+        // put the task-level holder back first, so the seat replacement only moves
+        // the assignee, the delegation chain and openedAt when the transferring
+        // member really held the task.
+        const unclaimedTask = await manager.getRepository(task_entity_1.TaskEntity).save(Object.assign(new task_entity_1.TaskEntity(), task, {
+            assigneeMemberId: taskBeforeClaim.assigneeMemberId,
+            openedAt: taskBeforeClaim.openedAt,
+            originalAssigneeMemberId: taskBeforeClaim.originalAssigneeMemberId,
+        }));
+        const seat = await this.replaceOpenSeat(manager, {
+            decidedAt,
+            fromMemberId,
+            reusableRow,
+            sourceRow: actorCandidate,
+            step: {
+                from: fromMemberId,
+                reason: transferReason,
+                ruleId: null,
+                to: toMemberId,
+            },
+            task: unclaimedTask,
+            toMemberId,
+        });
+        await activityRepository.save(activityRepository.create({
+            actorMemberId: fromMemberId,
+            eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TASK_DECIDED,
+            instanceId: instance.id,
+            nodeId: task.nodeId,
+            payload: {
+                action: workflow_engine_enums_1.TaskDecisionActionEnum.TRANSFERRED,
+                comment: decision.comment,
+                decisionId: decision.id,
+                signatureId: signature.id,
+                signedPayloadHash: signature.signedPayloadHash,
+                transferToMemberId: toMemberId,
+            },
+            taskId: task.id,
+        }));
+        await this.notifySeatReplaced(manager, {
+            fromMemberId,
+            instance,
+            node,
+            seat,
+            toMemberId,
+        });
+    }
+    /**
+     * Moves one open seat from `fromMemberId` to `toMemberId` on the same task.
+     *
+     * With a source candidate row: that row is marked TRANSFERRED, and the target
+     * takes a row with the same sequence, source type and original member. A
+     * WAITING seat stays WAITING; anything else becomes PENDING. A closed row the
+     * target already has (CANCELLED, SUPERSEDED, TRANSFERRED) is reused, because
+     * the database allows one row per (task, member).
+     *
+     * Without one (a direct assignee with no candidate row) only the assignee
+     * field moves. When the source is the assignee, the assignee moves too and
+     * the step is appended to the task's chain.
+     */
+    async replaceOpenSeat(manager, { decidedAt, fromMemberId, reusableRow, sourceRow, step, task, toMemberId, }) {
+        const taskRepository = manager.getRepository(task_entity_1.TaskEntity);
+        const candidateRepository = manager.getRepository(task_candidate_entity_1.TaskCandidateEntity);
+        const assigneeMoved = task.assigneeMemberId === fromMemberId;
+        if (sourceRow) {
+            await candidateRepository.save(Object.assign(new task_candidate_entity_1.TaskCandidateEntity(), sourceRow, {
+                decidedAt,
+                status: workflow_engine_enums_1.TaskCandidateStatusEnum.TRANSFERRED,
+            }));
+        }
+        const seatStatus = sourceRow
+            ? sourceRow.status === workflow_engine_enums_1.TaskCandidateStatusEnum.WAITING
+                ? workflow_engine_enums_1.TaskCandidateStatusEnum.WAITING
+                : workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING
+            : null;
+        if (sourceRow) {
+            const seat = {
+                claimedAt: null,
+                decidedAt: null,
+                delegationChain: [
+                    ...readDelegationSteps(sourceRow.delegationChain),
+                    step,
+                ],
+                memberId: toMemberId,
+                originalMemberId: sourceRow.originalMemberId,
+                sequence: sourceRow.sequence,
+                sourceType: sourceRow.sourceType,
+                status: seatStatus ?? workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING,
+            };
+            if (reusableRow) {
+                await candidateRepository.save(Object.assign(new task_candidate_entity_1.TaskCandidateEntity(), reusableRow, seat));
+            }
+            else {
+                await candidateRepository.save(candidateRepository.create({ ...seat, taskId: task.id }));
+            }
+        }
+        const nextTask = assigneeMoved
+            ? await taskRepository.save(Object.assign(new task_entity_1.TaskEntity(), task, {
+                assigneeMemberId: toMemberId,
+                delegationChain: [
+                    ...readDelegationSteps(task.delegationChain),
+                    step,
+                ],
+                openedAt: null,
+            }))
+            : task;
+        return { assigneeMoved, seatStatus, task: nextTask };
+    }
+    /**
+     * Notifications for a replaced seat: the member who gave it up is resolved as
+     * TRANSFERRED (their notifications on this task only), and the member who
+     * takes it is notified now if the seat is active. A WAITING seat notifies
+     * when its turn comes, through the normal sequential activation.
+     */
+    async notifySeatReplaced(manager, { fromMemberId, instance, node, seat, toMemberId, }) {
+        await this.notificationService.resolveTaskNotifications({
+            actingMemberId: fromMemberId,
+            manager,
+            resolution: notification_enums_1.NotificationResolutionEnum.TRANSFERRED,
+            supersedeOthers: false,
+            taskId: seat.task.id,
+        });
+        const isActive = seat.seatStatus === null ||
+            seat.seatStatus === workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING;
+        if (!isActive) {
+            return;
+        }
+        await this.notificationService.createTaskAssignedNotification({
+            instance,
+            manager,
+            node,
+            task: Object.assign(new task_entity_1.TaskEntity(), seat.task, {
+                assigneeMemberId: toMemberId,
+            }),
+            transferred: true,
+        });
+    }
     /**
      * Resolves who gets the node's task. `null` means the node asked to be
      * skipped (`excludeInitiator.whenEmpty = SKIP_NODE`) because the initiator
@@ -3060,17 +3657,29 @@ let WorkflowEngineService = class WorkflowEngineService {
      * delegated, otherwise the actor). No grade on the principal means no
      * constraint.
      */
-    async assertTransferTargetGrade(manager, { actorMemberId, delegationChain, label, targetMemberId, }) {
+    async assertTransferTargetGrade(manager, args) {
+        const requiredLevel = await this.readTransferTargetRequiredGrade(manager, args);
+        if (requiredLevel !== null) {
+            throw new common_1.ForbiddenException(`簽核節點「${args.label}」需由職等 ${requiredLevel} 以上的成員簽核，不能轉簽給職等不足的成員`);
+        }
+    }
+    /**
+     * The grade a transfer target must reach, or `null` when the target passes.
+     * Seniority is measured from the member being replaced: the first delegator
+     * on their chain, or that member themselves. Shared by the user transfer
+     * (which throws) and the administrator reassignment (which reports).
+     */
+    async readTransferTargetRequiredGrade(manager, { actorMemberId, delegationChain, targetMemberId, }) {
         const principalMemberId = readDelegationSteps(delegationChain)[0]?.from ?? actorMemberId;
         const date = this.readOrganizationToday();
         const requiredLevel = await this.readMemberPositionLevel(manager, principalMemberId, date);
         if (requiredLevel === null) {
-            return;
+            return null;
         }
         const targetLevel = await this.readMemberPositionLevel(manager, targetMemberId, date);
-        if (targetLevel === null || targetLevel < requiredLevel) {
-            throw new common_1.ForbiddenException(`簽核節點「${label}」需由職等 ${requiredLevel} 以上的成員簽核，不能轉簽給職等不足的成員`);
-        }
+        return targetLevel === null || targetLevel < requiredLevel
+            ? requiredLevel
+            : null;
     }
     async resolveApproverResolver(manager, instance, resolver, label, subject = '簽核人', skippedChainMemberIds = []) {
         if (resolver.type === 'DIRECT') {
@@ -3100,6 +3709,18 @@ let WorkflowEngineService = class WorkflowEngineService {
         return this.resolveInitiatorManagerCandidates(manager, instance, resolver.levelsUp, resolver.fallback, label, resolver.preferClosestOrgUnit === true, subject).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
     }
     async resolvePositionCandidates(manager, positionId, label, subject) {
+        const memberIds = await this.readActivePositionMemberIds(manager, positionId);
+        if (!memberIds.length) {
+            throw new common_1.ConflictException(`${label} 找不到${subject}：職位「${await this.readPositionName(manager, positionId)}」目前沒有任何有效成員`);
+        }
+        return memberIds;
+    }
+    /**
+     * The members who hold the position today (organisation time zone) within
+     * their effective period. Primary memberships come first, then the most
+     * recently started. Empty when nobody holds it; never throws.
+     */
+    async readActivePositionMemberIds(manager, positionId) {
         const today = this.readOrganizationToday();
         const memberships = await manager.getRepository(membership_entity_1.MembershipEntity).find({
             where: { positionId },
@@ -3113,9 +3734,6 @@ let WorkflowEngineService = class WorkflowEngineService {
             }
             return second.effectiveFrom.localeCompare(first.effectiveFrom);
         });
-        if (!activeMemberships.length) {
-            throw new common_1.ConflictException(`${label} 找不到${subject}：職位「${await this.readPositionName(manager, positionId)}」目前沒有任何有效成員`);
-        }
         return uniqueTexts(activeMemberships.map((membership) => membership.memberId));
     }
     async resolveInitiatorManagerCandidates(manager, instance, levelsUp, fallback, label, preferClosestOrgUnit, subject) {
@@ -3124,9 +3742,7 @@ let WorkflowEngineService = class WorkflowEngineService {
         if (resolvedManagerMemberIds.length) {
             return resolvedManagerMemberIds;
         }
-        return [
-            this.resolveFallbackAssignee(instance, fallback, label, subject, `找不到發起人的第 ${normalizedLevelsUp} 層主管`),
-        ];
+        return this.resolveFallbackAssignees(manager, instance, fallback, label, subject, `找不到發起人的第 ${normalizedLevelsUp} 層主管`);
     }
     /**
      * Walks up the initiator's manager chain, nearest manager first, until a
@@ -3177,10 +3793,10 @@ let WorkflowEngineService = class WorkflowEngineService {
                 return chain;
             }
         }
-        const fallbackMemberId = this.resolveFallbackAssignee(instance, fallback, label, subject, `沿主管鏈找不到職等達 ${minPositionLevel} 的主管`);
-        return chain.includes(fallbackMemberId)
-            ? chain
-            : [...chain, fallbackMemberId];
+        // A position fallback can name several holders. They all join the last
+        // tier, so they all have to sign, the same as every other chain member.
+        const fallbackMemberIds = await this.resolveFallbackAssignees(manager, instance, fallback, label, subject, `沿主管鏈找不到職等達 ${minPositionLevel} 的主管`);
+        return uniqueTexts([...chain, ...fallbackMemberIds]);
     }
     /** Highest position level over the member's active memberships, or `null`. */
     async readMemberPositionLevel(manager, memberId, date) {
@@ -3215,11 +3831,46 @@ let WorkflowEngineService = class WorkflowEngineService {
             return [memberId, levels.length === 0 ? null : Math.max(...levels)];
         }));
     }
+    /**
+     * Every member a manager resolver's fallback yields. A `DIRECT` or `NONE`
+     * fallback yields at most one; a `POSITION` fallback yields the position's
+     * current holders, minus the initiator unless the fallback allows self
+     * approval. Failure throws, as the single-member path does.
+     */
+    async resolveFallbackAssignees(manager, instance, fallback, label, subject, failureReason) {
+        if (fallback?.type !== 'POSITION') {
+            return [
+                this.resolveFallbackAssignee(instance, fallback, label, subject, failureReason),
+            ];
+        }
+        const failure = subject === '通知對象' ? '無法建立通知' : '無法建立待簽任務';
+        if (!fallback.positionId.trim()) {
+            throw new common_1.ConflictException(`${label} ${failure}：改派職位未設定。`);
+        }
+        const holderMemberIds = await this.readActivePositionMemberIds(manager, fallback.positionId);
+        if (holderMemberIds.length === 0) {
+            throw new common_1.ConflictException(`${label} ${failure}：${failureReason}，且改派職位「${await this.readPositionName(manager, fallback.positionId)}」目前沒有任何有效成員。請聯絡流程管理員調整主管規則或模板 fallback。`);
+        }
+        const assignees = fallback.allowInitiatorSelfApproval
+            ? holderMemberIds
+            : holderMemberIds.filter((memberId) => memberId !== instance.initiatorMemberId);
+        if (assignees.length === 0) {
+            throw new common_1.ConflictException(`${label} ${failure}：${failureReason}，且改派職位的有效成員只有申請人本人，此節點未允許申請人自簽。`);
+        }
+        return assignees;
+    }
     resolveFallbackAssignee(instance, fallback, label, subject, failureReason) {
         const failure = subject === '通知對象' ? '無法建立通知' : '無法建立待簽任務';
         if (!fallback || fallback.type === 'NONE') {
             throw new common_1.ConflictException(`${label} ${failure}：${failureReason}，且未設定改派固定人。請聯絡流程管理員調整主管規則或模板 fallback。`);
         }
+        // A template saved by a newer engine can carry a fallback type this
+        // engine does not know. Refuse it by name instead of reading `memberId`
+        // off a shape it does not have, which surfaced as an opaque TypeError.
+        const unsupportedType = (0, workflow_1.readUnsupportedApproverFallbackType)(fallback);
+        if (unsupportedType !== null) {
+            throw new common_1.ConflictException(`${label} ${failure}：${failureReason}，且此引擎版本不支援改派類型「${unsupportedType}」。請升級 BPMCore 後再發佈或執行此流程。`);
+        }
         if (!fallback.memberId.trim()) {
             throw new common_1.ConflictException(`${label} ${failure}：改派固定人未設定。`);
         }
@@ -3271,9 +3922,7 @@ let WorkflowEngineService = class WorkflowEngineService {
             scopeType: organization_enums_1.ManagerResolutionScopeTypeEnum.ORG_UNIT,
         })), date, readOrgUnitDepthMap(orgUnits), preferClosestOrgUnit);
         if (!managerMemberIds.length) {
-            return [
-                this.resolveFallbackAssignee(instance, fallback, label, subject, `找不到指定組織的主管規則`),
-            ];
+            return this.resolveFallbackAssignees(manager, instance, fallback, label, subject, `找不到指定組織的主管規則`);
         }
         return managerMemberIds;
     }
@@ -3782,7 +4431,7 @@ let WorkflowEngineService = class WorkflowEngineService {
     }
 };
 exports.WorkflowEngineService = WorkflowEngineService;
-exports.WorkflowEngineService = WorkflowEngineService = tslib_1.__decorate([
+exports.WorkflowEngineService = WorkflowEngineService = WorkflowEngineService_1 = tslib_1.__decorate([
     (0, common_1.Injectable)(),
     tslib_1.__param(0, (0, typeorm_1.InjectRepository)(approval_instance_entity_1.ApprovalInstanceEntity)),
     tslib_1.__param(1, (0, typeorm_1.InjectRepository)(workflow_token_entity_1.WorkflowTokenEntity)),
@@ -3991,8 +4640,12 @@ function readDelegationSteps(value) {
         if (!from || !to || !reason) {
             return null;
         }
+        const actorMemberId = readStringValue(step.actorMemberId);
+        const comment = readStringValue(step.comment);
         return {
             from,
+            ...(actorMemberId ? { actorMemberId } : {}),
+            ...(comment ? { comment } : {}),
             reason,
             ruleId: readStringValue(step.ruleId),
             to,
@@ -4372,6 +5025,22 @@ function readDecisionPolicySnapshot(task) {
     }
     return { type: 'SINGLE' };
 }
+/**
+ * Stages where several seats decide together. A holder's transfer on one of
+ * them moves that seat in place; SINGLE and SEQUENTIAL keep the replacement
+ * task path.
+ */
+function isGroupDecisionPolicy(policy) {
+    return (policy.type === 'PARALLEL_ALL' ||
+        policy.type === 'PARALLEL_ANY' ||
+        policy.type === 'QUORUM');
+}
+/** Candidate states in which the seat is no longer part of the task. */
+const SEAT_LEFT_STATUSES = [
+    workflow_engine_enums_1.TaskCandidateStatusEnum.CANCELLED,
+    workflow_engine_enums_1.TaskCandidateStatusEnum.SUPERSEDED,
+    workflow_engine_enums_1.TaskCandidateStatusEnum.TRANSFERRED,
+];
 function shouldCompleteTaskAfterDecision({ action, candidates, decisionPolicy, }) {
     if (action !== workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED) {
         return true;
@@ -4381,7 +5050,11 @@ function shouldCompleteTaskAfterDecision({ action, candidates, decisionPolicy, }
         return true;
     }
     const completedCount = candidates.filter((candidate) => candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.COMPLETED).length;
-    const totalCount = Math.max(candidates.length, 1);
+    // A seat that has left the task (transferred away, cancelled, superseded)
+    // no longer belongs to the stage. Counting it kept a PARALLEL_ALL or
+    // SEQUENTIAL stage from ever reaching "every seat decided" once a seat had
+    // been reassigned.
+    const totalCount = Math.max(candidates.filter((candidate) => !SEAT_LEFT_STATUSES.includes(candidate.status)).length, 1);
     if (decisionPolicy.type === 'PARALLEL_ALL' ||
         decisionPolicy.type === 'SEQUENTIAL') {
         return completedCount >= totalCount;
@@ -4612,6 +5285,9 @@ function readInstanceFinalStateLabel(finalState) {
     if (finalState === workflow_engine_enums_1.ApprovalInstanceStateEnum.REJECTED) {
         return '拒絕';
     }
+    if (finalState === workflow_engine_enums_1.ApprovalInstanceStateEnum.EXPIRED) {
+        return '逾期終止';
+    }
     return '取消';
 }
 function readManagerMemberIdFromInitiatorSnapshot(initiatorMetadataSnapshot, levelsUp) {
@@ -5013,6 +5689,14 @@ function endSentence(message) {
 // has no manager, or `null` when it can: like the runtime, it must exist, name
 // a member, and not be the initiator unless the node allows self-approval.
 function readDryRunFallbackProblem(initiatorMemberId, fallback) {
+    if (fallback && (0, workflow_1.readUnsupportedApproverFallbackType)(fallback) !== null) {
+        return 'UNSUPPORTED';
+    }
+    if (fallback?.type === 'POSITION') {
+        // The holders are only known at run time, so the dry run cannot tell
+        // whether the position is empty; it only rules out a blank position.
+        return fallback.positionId.trim() === '' ? 'BLANK_POSITION' : null;
+    }
     if (!fallback || fallback.type !== 'DIRECT') {
         return 'NOT_SET';
     }
@@ -5025,9 +5709,15 @@ function readDryRunFallbackProblem(initiatorMemberId, fallback) {
         : null;
 }
 function readDryRunFallbackMemberIds(input, fallback) {
-    return readDryRunFallbackProblem(input.initiatorMemberId, fallback) ===
-        null && fallback?.type === 'DIRECT'
-        ? [fallback.memberId.trim()]
+    if (readDryRunFallbackProblem(input.initiatorMemberId, fallback) !== null) {
+        return [];
+    }
+    if (fallback?.type === 'DIRECT') {
+        return [fallback.memberId.trim()];
+    }
+    // Same placeholder a POSITION node gets in a dry run; the label names it.
+    return fallback?.type === 'POSITION'
+        ? [`position:${fallback.positionId.trim()}`]
         : [];
 }
 function readDryRunNodeName(node) {
@@ -5071,6 +5761,12 @@ function readDryRunUnresolvedApproverMessage(resolver, nodeName, initiatorMember
     if (fallbackProblem === 'IS_INITIATOR') {
         return `簽核節點「${nodeName}」找不到主管，且改派固定人是申請人本人，此節點未允許申請人自簽`;
     }
+    if (fallbackProblem === 'BLANK_POSITION') {
+        return `簽核節點「${nodeName}」找不到主管，且改派職位未設定`;
+    }
+    if (fallbackProblem === 'UNSUPPORTED') {
+        return `簽核節點「${nodeName}」找不到主管，且此引擎版本不支援該改派設定，請升級 BPMCore 後再試`;
+    }
     return `簽核節點「${nodeName}」依申請人的組織找不到主管，請確認試跑時的申請人資料`;
 }
 function createDryRunStep(input) {