@rytass/bpm-core-nestjs-module 0.13.4 → 0.14.0

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

@@ -23,6 +23,7 @@ const condition_service_1 = require("../condition/condition.service");
 const manager_resolution_entity_1 = require("../organization/manager-resolution.entity");
 const membership_entity_1 = require("../organization/membership.entity");
 const org_unit_entity_1 = require("../organization/org-unit.entity");
+const position_entity_1 = require("../organization/position.entity");
 const organization_enums_1 = require("../organization/organization.enums");
 const approval_template_version_entity_1 = require("../template/approval-template-version.entity");
 const approval_template_entity_1 = require("../template/approval-template.entity");
@@ -41,6 +42,8 @@ const workflow_service_task_dispatcher_token_1 = require("./workflow-service-tas
 const workflow_token_entity_1 = require("./workflow-token.entity");
 const bpm_root_options_1 = require("../bpm/bpm-root-options");
 const MAX_PROCESSING_STEPS = 500;
+// Guards ORG_MANAGER_CHAIN against misconfigured manager rules that never end.
+const ORG_MANAGER_CHAIN_MAX_HOPS = 20;
 const DEFAULT_APPROVAL_HISTORY_TASK_LIMIT = 50;
 const SYSTEM_DRY_RUN_INSTANCE_ID = 'dry-run-instance';
 /**
@@ -313,6 +316,14 @@ let WorkflowEngineService = class WorkflowEngineService {
                 taskNode.data.allowTransfer === false) {
                 throw new common_1.ForbiddenException(`Workflow node ${task.nodeId} does not allow transfer`);
             }
+            // Only guards a human picking the target; SLA escalation passes a
+            // `transferReason` and is deliberately left alone.
+            if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.TRANSFERRED &&
+                options.transferReason === undefined &&
+                isInitiatorExcluded(taskNode) &&
+                transferToMemberId === instance.initiatorMemberId) {
+                throw new common_1.ConflictException(`簽核節點「${taskNode.data.label}」不允許申請人自簽，不能將任務轉交給申請人本人`);
+            }
             const returnToNodeId = input.action === workflow_engine_enums_1.TaskDecisionActionEnum.RETURNED
                 ? readReturnTargetNodeId(instance.workflowSnapshot, task.nodeId, input.returnToNodeId)
                 : null;
@@ -422,6 +433,17 @@ let WorkflowEngineService = class WorkflowEngineService {
                 supersedeOthers: taskEnded,
                 taskId: completedTask.id,
             });
+            if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED &&
+                !shouldCompleteTask) {
+                await this.activateNextSequentialCandidate({
+                    candidates: nextCandidateRows,
+                    instance,
+                    manager,
+                    node: taskNode,
+                    previousMemberId: input.decidedByMemberId,
+                    task: completedTask,
+                });
+            }
             if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED &&
                 shouldCompleteTask) {
                 // Ad-hoc gate: the token may only advance once every task bound to
@@ -592,6 +614,13 @@ let WorkflowEngineService = class WorkflowEngineService {
             const targetValue = buildAdhocTargetValue(target);
             // Rejects WEBHOOK targets — countersigners must be members.
             buildAdhocApproverResolver(targetValue);
+            // The countersign task is only created when a later user task is
+            // reached, against that node's own setting. This checks the target
+            // against the node being decided now, as an early rejection for the
+            // common case; it is not a guarantee about the node it attaches to.
+            if (isInitiatorExcluded(node)) {
+                await this.resolveAdhocTaskCandidates(manager, instance, node, '臨時會簽', targetValue);
+            }
             const directiveRepository = manager.getRepository(adhoc_directive_entity_1.AdhocDirectiveEntity);
             const directive = await directiveRepository.save(directiveRepository.create({
                 channels: null,
@@ -707,6 +736,9 @@ let WorkflowEngineService = class WorkflowEngineService {
         if (!isDirectAssignee && !actorCandidate) {
             throw new common_1.ConflictException(`Task ${task.id} is assigned to another member`);
         }
+        if (actorCandidate?.status === workflow_engine_enums_1.TaskCandidateStatusEnum.WAITING) {
+            throw new common_1.ConflictException(`Task ${task.id} is not this member's turn yet`);
+        }
         if (actorCandidate &&
             actorCandidate.status !== workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING &&
             actorCandidate.status !== workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED) {
@@ -771,11 +803,7 @@ let WorkflowEngineService = class WorkflowEngineService {
         const label = directive.type === adhoc_enums_1.AdhocDirectiveTypeEnum.COUNTERSIGN
             ? '臨時會簽'
             : '臨時加簽';
-        const resolvedCandidates = await this.resolveApproverResolver(manager, instance, buildAdhocApproverResolver(readAdhocTargetValue(directive)), `${label}「${node.data.label}」`);
-        const candidates = await this.applyDelegationToResolvedCandidates(instance, node.id, resolvedCandidates);
-        if (candidates.length === 0) {
-            throw new common_1.ConflictException(`${label}「${node.data.label}」 did not resolve to any member id`);
-        }
+        const candidates = await this.resolveAdhocTaskCandidates(manager, instance, node, label, readAdhocTargetValue(directive));
         const primaryCandidate = candidates[0];
         const task = await taskRepository.save(taskRepository.create({
             adhocDirectiveId: directive.id,
@@ -821,6 +849,7 @@ let WorkflowEngineService = class WorkflowEngineService {
             taskId: task.id,
         })));
         task.candidateMemberIds = savedCandidates.map((candidate) => candidate.memberId);
+        task.openCandidateMemberIds = task.candidateMemberIds;
         await activityRepository.save(activityRepository.create({
             actorMemberId: directive.createdByMemberId,
             eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TASK_CREATED,
@@ -852,6 +881,17 @@ let WorkflowEngineService = class WorkflowEngineService {
         }, Promise.resolve());
         return task;
     }
+    async resolveAdhocTaskCandidates(manager, instance, node, label, targetValue) {
+        const resolvedCandidates = await this.resolveApproverResolver(manager, instance, buildAdhocApproverResolver(targetValue), `${label}「${node.data.label}」`);
+        const delegatedCandidates = await this.delegateResolvedCandidates(instance, node.id, resolvedCandidates);
+        const candidates = selectNodeCandidates(delegatedCandidates, isInitiatorExcluded(node), instance.initiatorMemberId);
+        if (candidates.length > 0) {
+            return candidates;
+        }
+        throw new common_1.ConflictException(delegatedCandidates.length > 0
+            ? `${label}「${node.data.label}」 無法建立任務：指定對象只有申請人本人，此節點不允許申請人簽核。`
+            : `${label}「${node.data.label}」 did not resolve to any member id`);
+    }
     async spawnCountersignTasksForNode(manager, instance, token, node, now) {
         const directiveRepository = manager.getRepository(adhoc_directive_entity_1.AdhocDirectiveEntity);
         const directives = await directiveRepository.find({
@@ -915,9 +955,18 @@ let WorkflowEngineService = class WorkflowEngineService {
         const taskRepository = manager.getRepository(task_entity_1.TaskEntity);
         const taskCandidateRepository = manager.getRepository(task_candidate_entity_1.TaskCandidateEntity);
         const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
-        const originTask = task.adhocOriginTaskId
+        const adhocOriginTask = task.adhocOriginTaskId
             ? await taskRepository.findOne({ where: { id: task.adhocOriginTaskId } })
             : null;
+        // transferTask re-points an open pre-approval when its origin is
+        // transferred, but a pre-approval whose origin was transferred by a release
+        // that did not do that yet still points at the TRANSFERRED row, and so does
+        // the pointer on `task` when a transfer commits after decideTask read it
+        // and before it took the instance lock. Following the transfer here hands
+        // the decision to whoever holds the stage now in both cases.
+        const originTask = adhocOriginTask
+            ? await this.readTransferSuccessorTask(manager, adhocOriginTask)
+            : null;
         const originTaskIsOpen = originTask?.status === workflow_engine_enums_1.TaskStatusEnum.PENDING ||
             originTask?.status === workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS;
         // Safety: when there is nobody to hand the decision back to (origin task
@@ -927,21 +976,43 @@ let WorkflowEngineService = class WorkflowEngineService {
         if (!originTask || (!originTaskIsOpen && !originTask.assigneeMemberId)) {
             return false;
         }
+        const originCandidates = readDecisionPolicySnapshot(originTask).type === 'SEQUENTIAL'
+            ? await taskCandidateRepository.find({
+                where: { taskId: originTask.id },
+            })
+            : [];
+        const isSequentialOrigin = isOrderedSequentialTask(originTask, originCandidates);
         const node = readWorkflowNodeOrThrow(instance.workflowSnapshot, task.nodeId);
         if (!originTaskIsOpen && originTask.assigneeMemberId) {
             // The origin approver already decided — reopen a fresh decision task so
-            // the stage can be re-decided after the rejected pre-approval.
+            // the stage can be re-decided after the rejected pre-approval. A
+            // SEQUENTIAL task's assignee rotates and ends on the last signer, so it
+            // goes back to whoever asked for the pre-approval instead.
+            const requesterCandidate = isSequentialOrigin
+                ? await this.readSequentialRequesterCandidate(manager, originTask, originCandidates, directive.createdByMemberId)
+                : undefined;
+            // A sequential origin always reopens for the requester, even when the
+            // successor of a transferred task has no row for them.
+            const reopenedAssigneeMemberId = isSequentialOrigin
+                ? directive.createdByMemberId
+                : originTask.assigneeMemberId;
+            const reopenedOriginalMemberId = isSequentialOrigin
+                ? (requesterCandidate?.originalMemberId ?? directive.createdByMemberId)
+                : originTask.originalAssigneeMemberId;
+            const reopenedDelegationChain = isSequentialOrigin
+                ? (requesterCandidate?.delegationChain ?? [])
+                : originTask.delegationChain;
             const reopenedTask = await taskRepository.save(taskRepository.create({
-                assigneeMemberId: originTask.assigneeMemberId,
+                assigneeMemberId: reopenedAssigneeMemberId,
                 assignmentType: workflow_engine_enums_1.TaskAssignmentTypeEnum.DIRECT_MEMBER,
                 completedAt: null,
                 createdAt: decidedAt,
                 decisionPolicySnapshot: { type: 'SINGLE' },
-                delegationChain: originTask.delegationChain,
+                delegationChain: reopenedDelegationChain,
                 instanceId: instance.id,
                 nodeId: originTask.nodeId,
                 openedAt: null,
-                originalAssigneeMemberId: originTask.originalAssigneeMemberId,
+                originalAssigneeMemberId: reopenedOriginalMemberId,
                 slaDueAt: null,
                 status: workflow_engine_enums_1.TaskStatusEnum.PENDING,
                 tokenId: originTask.tokenId,
@@ -950,9 +1021,9 @@ let WorkflowEngineService = class WorkflowEngineService {
                 claimedAt: null,
                 createdAt: decidedAt,
                 decidedAt: null,
-                delegationChain: originTask.delegationChain,
-                memberId: originTask.assigneeMemberId,
-                originalMemberId: originTask.originalAssigneeMemberId ?? originTask.assigneeMemberId,
+                delegationChain: reopenedDelegationChain,
+                memberId: reopenedAssigneeMemberId,
+                originalMemberId: reopenedOriginalMemberId ?? reopenedAssigneeMemberId,
                 sourceType: 'DIRECT',
                 status: workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING,
                 taskId: reopenedTask.id,
@@ -964,7 +1035,7 @@ let WorkflowEngineService = class WorkflowEngineService {
                 nodeId: originTask.nodeId,
                 payload: {
                     adhocDirectiveId: directive.id,
-                    assigneeMemberId: originTask.assigneeMemberId,
+                    assigneeMemberId: reopenedAssigneeMemberId,
                     reopenedFromTaskId: originTask.id,
                     rejectedAdhocTaskId: task.id,
                     tokenId: originTask.tokenId,
@@ -980,7 +1051,14 @@ let WorkflowEngineService = class WorkflowEngineService {
                 });
             }
         }
-        const recipientMemberIds = await this.readOpenTaskRecipientMemberIds(manager, originTask);
+        // On a SEQUENTIAL task the requester has already signed and the task has
+        // moved on to the next signer, so they are told as well. On any other task
+        // the requester is the origin holder (or handed the stage away by a
+        // transfer) and only whoever holds the task now is told.
+        const recipientMemberIds = uniqueTexts([
+            ...(isSequentialOrigin ? [directive.createdByMemberId] : []),
+            ...(await this.readOpenTaskRecipientMemberIds(manager, originTask)),
+        ]);
         if (recipientMemberIds.length > 0) {
             await this.notificationService.createAdhocWorkflowNotifications({
                 channels: null,
@@ -1012,6 +1090,89 @@ let WorkflowEngineService = class WorkflowEngineService {
         }));
         return true;
     }
+    /**
+     * Follows a TRANSFERRED task to the task that replaced it, repeatedly, and
+     * returns the last one reached. A transfer leaves no pointer on either task
+     * row; the link is the `transferredFromTaskId` in the payload of the
+     * TASK_CREATED activity written for the replacement. When the trail stops
+     * (no such activity, or its task is gone) the last task reached is returned,
+     * so a caller sees the transferred row exactly as it did before.
+     */
+    async readTransferSuccessorTask(manager, task) {
+        if (task.status !== workflow_engine_enums_1.TaskStatusEnum.TRANSFERRED) {
+            return task;
+        }
+        const taskRepository = manager.getRepository(task_entity_1.TaskEntity);
+        const taskCreatedActivities = await manager
+            .getRepository(activity_log_entity_1.ActivityLogEntity)
+            .find({
+            where: {
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TASK_CREATED,
+                instanceId: task.instanceId,
+                nodeId: task.nodeId,
+            },
+        });
+        const successorTaskIdByTransferredTaskId = new Map(taskCreatedActivities.flatMap((activity) => {
+            const transferredFromTaskId = activity.payload['transferredFromTaskId'];
+            return typeof transferredFromTaskId === 'string' && activity.taskId
+                ? [[transferredFromTaskId, activity.taskId]]
+                : [];
+        }));
+        const followTransfer = async (currentTask, visitedTaskIds) => {
+            const successorTaskId = currentTask.status === workflow_engine_enums_1.TaskStatusEnum.TRANSFERRED
+                ? successorTaskIdByTransferredTaskId.get(currentTask.id)
+                : undefined;
+            if (!successorTaskId || visitedTaskIds.has(successorTaskId)) {
+                return currentTask;
+            }
+            const successorTask = await taskRepository.findOne({
+                where: { id: successorTaskId },
+            });
+            return successorTask
+                ? followTransfer(successorTask, new Set([...visitedTaskIds, successorTaskId]))
+                : currentTask;
+        };
+        return followTransfer(task, new Set([task.id]));
+    }
+    /**
+     * The requester's candidate row on a SEQUENTIAL origin task. A task that was
+     * transferred mid-order continues as a replacement that carries only the
+     * candidates still to sign, so a requester who already signed is found on an
+     * earlier task of the transfer chain instead.
+     */
+    async readSequentialRequesterCandidate(manager, originTask, originCandidates, requesterMemberId) {
+        const ownCandidate = originCandidates.find((candidate) => candidate.memberId === requesterMemberId);
+        if (ownCandidate) {
+            return ownCandidate;
+        }
+        const taskCreatedActivities = await manager
+            .getRepository(activity_log_entity_1.ActivityLogEntity)
+            .find({
+            where: {
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TASK_CREATED,
+                instanceId: originTask.instanceId,
+                nodeId: originTask.nodeId,
+            },
+        });
+        const transferredFromTaskIdByTaskId = new Map(taskCreatedActivities.flatMap((activity) => {
+            const transferredFromTaskId = activity.payload['transferredFromTaskId'];
+            return typeof transferredFromTaskId === 'string' && activity.taskId
+                ? [[activity.taskId, transferredFromTaskId]]
+                : [];
+        }));
+        const searchEarlierTasks = async (currentTaskId, visitedTaskIds) => {
+            const earlierTaskId = transferredFromTaskIdByTaskId.get(currentTaskId);
+            if (!earlierTaskId || visitedTaskIds.has(earlierTaskId)) {
+                return undefined;
+            }
+            const earlierCandidate = (await manager
+                .getRepository(task_candidate_entity_1.TaskCandidateEntity)
+                .find({ where: { taskId: earlierTaskId } })).find((candidate) => candidate.memberId === requesterMemberId);
+            return (earlierCandidate ??
+                searchEarlierTasks(earlierTaskId, new Set([...visitedTaskIds, earlierTaskId])));
+        };
+        return searchEarlierTasks(originTask.id, new Set([originTask.id]));
+    }
     async readOpenTaskRecipientMemberIds(manager, task) {
         if (task.assigneeMemberId) {
             return [task.assigneeMemberId];
@@ -1229,10 +1390,12 @@ let WorkflowEngineService = class WorkflowEngineService {
         }
         const nextVisitedNodeIds = new Set([...input.visitedNodeIds, visitKey]);
         const entryConditionMet = this.conditionService.evaluateBoolean(entryCondition, buildDryRunExpressionContext(input, input.lastDecision), `workflow.nodes.${node.id}.data.entryCondition`);
-        const assigneeMemberId = entryConditionMet && node.type === 'userTask'
-            ? this.resolveDryRunAssigneeMemberId(input, node.data.approverResolver, `workflow.nodes.${node.id}.data.approverResolver`)
+        const assignment = entryConditionMet && node.type === 'userTask'
+            ? this.resolveDryRunAssignment(input, node)
             : null;
-        const nextLastDecision = entryConditionMet && node.type === 'userTask'
+        const assigneeMemberId = assignment?.assigneeMemberId ?? null;
+        const skippedByExclusion = assignment?.outcome === 'SKIPPED';
+        const nextLastDecision = entryConditionMet && node.type === 'userTask' && !skippedByExclusion
             ? {
                 action: workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED,
                 assigneeMemberId,
@@ -1248,19 +1411,24 @@ let WorkflowEngineService = class WorkflowEngineService {
                 edgeReason: readDryRunEdgeReason(input.incomingEdge),
                 entryCondition,
                 entryConditionMet,
-                message: readDryRunStepMessage(node, entryConditionMet),
+                message: assignment?.message ?? readDryRunStepMessage(node, entryConditionMet),
                 node,
-                status: readDryRunStepStatus(node, entryConditionMet),
+                status: assignment?.outcome ?? readDryRunStepStatus(node, entryConditionMet),
                 stepIndex: input.steps.length,
             }),
         ];
+        // The initiator is the only approver and the node cannot proceed: this
+        // branch ends here, as it would fail at runtime.
+        if (assignment?.outcome === 'STOPPED') {
+            return nextSteps;
+        }
         // A NOTIFY node is an asynchronous branch: at runtime it consumes its
         // token and never advances, so its branch ends here rather than failing
         // for want of an outgoing edge it is not allowed to have.
         if ((0, workflow_graph_1.isAsyncNotifyServiceTask)(node)) {
             return nextSteps;
         }
-        if (!entryConditionMet || node.type === 'endEvent') {
+        if (!entryConditionMet || skippedByExclusion || node.type === 'endEvent') {
             if (node.type === 'endEvent') {
                 return nextSteps;
             }
@@ -1315,6 +1483,80 @@ let WorkflowEngineService = class WorkflowEngineService {
         }
         return (0, workflow_condition_evaluator_1.evaluateWorkflowEdgeCondition)(edge, { formData: input.formData });
     }
+    /**
+     * The dry-run assignee of a user task. Only resolvers whose dry run yields
+     * real member ids (DIRECT, DYNAMIC_FORM, EXPRESSION and ORG_MANAGER, which
+     * reads the initiator snapshot) can be checked against the initiator; the
+     * others resolve to placeholders and are left as they are.
+     */
+    resolveDryRunAssignment(input, node) {
+        const resolver = node.data.approverResolver;
+        const label = `workflow.nodes.${node.id}.data.approverResolver`;
+        const excludeInitiator = node.data.excludeInitiator;
+        const memberIds = excludeInitiator
+            ? this.readDryRunMemberIds(input, resolver, label)
+            : null;
+        if (!excludeInitiator || !memberIds?.includes(input.initiatorMemberId)) {
+            return {
+                assigneeMemberId: this.resolveDryRunAssigneeMemberId(input, resolver, label),
+                message: null,
+                outcome: null,
+            };
+        }
+        const remainingMemberId = memberIds.find((memberId) => memberId !== input.initiatorMemberId);
+        if (remainingMemberId !== undefined) {
+            return {
+                assigneeMemberId: remainingMemberId,
+                message: null,
+                outcome: null,
+            };
+        }
+        if (excludeInitiator.whenEmpty === 'SKIP_NODE') {
+            return {
+                assigneeMemberId: null,
+                message: '簽核人只有申請人本人，依設定略過節點。',
+                outcome: 'SKIPPED',
+            };
+        }
+        // Level 1 is the initiator when they head their unit; like the runtime,
+        // fall through to the next level of the snapshot's manager chain.
+        const managerMemberId = excludeInitiator.whenEmpty === 'INITIATOR_MANAGER'
+            ? [1, 2]
+                .map((levelsUp) => readManagerMemberIdFromInitiatorSnapshot(input.initiatorMetadataSnapshot, levelsUp))
+                .find((memberId) => typeof memberId === 'string' &&
+                memberId.trim() !== '' &&
+                memberId.trim() !== input.initiatorMemberId)
+            : undefined;
+        if (managerMemberId !== undefined) {
+            return {
+                assigneeMemberId: managerMemberId.trim(),
+                message: null,
+                outcome: null,
+            };
+        }
+        return {
+            assigneeMemberId: null,
+            message: excludeInitiator.whenEmpty === 'INITIATOR_MANAGER'
+                ? '簽核人只有申請人本人，此節點不允許申請人自簽，且找不到申請人的主管可改派。'
+                : '簽核人只有申請人本人，此節點不允許申請人自簽。',
+            outcome: 'STOPPED',
+        };
+    }
+    readDryRunMemberIds(input, resolver, label) {
+        if (resolver.type === 'DIRECT') {
+            return readMemberIdsFromValue(resolver.memberIds, label);
+        }
+        if (resolver.type === 'DYNAMIC_FORM') {
+            return readMemberIdsFromValue(readValueAtPath(input.formData, resolver.formPath), `${label}.formPath`);
+        }
+        if (resolver.type === 'EXPRESSION') {
+            return readMemberIdsFromValue(this.conditionService.evaluateValue(resolver.expression, buildDryRunExpressionContext(input, null), `${label}.expression`), `${label}.expression`);
+        }
+        if (resolver.type === 'ORG_MANAGER') {
+            return readMemberIdsFromValue(readManagerMemberIdFromInitiatorSnapshot(input.initiatorMetadataSnapshot, resolver.levelsUp), label);
+        }
+        return null;
+    }
     resolveDryRunAssigneeMemberId(input, resolver, label) {
         if (resolver.type === 'DIRECT') {
             return readMemberIdFromValue(resolver.memberIds, label);
@@ -1337,6 +1579,9 @@ let WorkflowEngineService = class WorkflowEngineService {
         if (resolver.type === 'ORG_UNIT_MANAGER') {
             return `orgUnitManager:${resolver.orgUnitId}`;
         }
+        if (resolver.type === 'ORG_MANAGER_CHAIN') {
+            return `orgManagerChain:${resolver.minPositionLevel}`;
+        }
         return readMemberIdFromValue(readManagerMemberIdFromInitiatorSnapshot(input.initiatorMetadataSnapshot, resolver.levelsUp), label);
     }
     async getApprovalInstance(id, scope) {
@@ -1627,7 +1872,11 @@ let WorkflowEngineService = class WorkflowEngineService {
     async listTaskCandidates(taskId, scope) {
         await this.assertTaskReadable(taskId, scope);
         return this.taskCandidateRepository.find({
-            order: { createdAt: 'ASC', id: 'ASC' },
+            order: {
+                sequence: { direction: 'ASC', nulls: 'LAST' },
+                createdAt: 'ASC',
+                id: 'ASC',
+            },
             where: { taskId },
         });
     }
@@ -1636,7 +1885,11 @@ let WorkflowEngineService = class WorkflowEngineService {
             return tasks;
         }
         const candidates = await this.taskCandidateRepository.find({
-            order: { createdAt: 'ASC', id: 'ASC' },
+            order: {
+                sequence: { direction: 'ASC', nulls: 'LAST' },
+                createdAt: 'ASC',
+                id: 'ASC',
+            },
             where: { taskId: (0, typeorm_2.In)(tasks.map((task) => task.id)) },
         });
         const candidatesByTaskId = candidates.reduce((currentMap, candidate) => {
@@ -1645,8 +1898,20 @@ let WorkflowEngineService = class WorkflowEngineService {
             nextMap.set(candidate.taskId, [...memberIds, candidate.memberId]);
             return nextMap;
         }, new Map());
+        const openCandidatesByTaskId = candidates
+            .filter((candidate) => candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING ||
+            candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED)
+            .reduce((currentMap, candidate) => {
+            const nextMap = new Map(currentMap);
+            nextMap.set(candidate.taskId, [
+                ...(nextMap.get(candidate.taskId) ?? []),
+                candidate.memberId,
+            ]);
+            return nextMap;
+        }, new Map());
         return tasks.map((task) => Object.assign(new task_entity_1.TaskEntity(), task, {
             candidateMemberIds: candidatesByTaskId.get(task.id) ?? [],
+            openCandidateMemberIds: openCandidatesByTaskId.get(task.id) ?? [],
         }));
     }
     async readDefaultInitiatorMetadataSnapshot(memberId) {
@@ -1882,13 +2147,23 @@ let WorkflowEngineService = class WorkflowEngineService {
         return this.conditionService.evaluateBoolean(entryCondition, buildWorkflowExpressionContext(instance), `workflow.nodes.${node.id}.data.entryCondition`);
     }
     async skipNodeByEntryCondition(manager, instance, token, node) {
+        await this.skipNode(manager, instance, token, node, {
+            skippedByEntryCondition: true,
+        });
+    }
+    async skipNodeByInitiatorExclusion(manager, instance, token, node) {
+        await this.skipNode(manager, instance, token, node, {
+            skippedByInitiatorExclusion: true,
+        });
+    }
+    async skipNode(manager, instance, token, node, reason) {
         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.TOKEN_ADVANCED,
             instanceId: instance.id,
             nodeId: node.id,
             payload: {
-                skippedByEntryCondition: true,
+                ...reason,
                 tokenId: token.id,
             },
             taskId: null,
@@ -2087,42 +2362,64 @@ let WorkflowEngineService = class WorkflowEngineService {
             return;
         }
         const candidates = await this.resolveRuntimeTaskCandidates(manager, instance, node);
+        // The initiator was the only approver and the node asks to be skipped in
+        // that case: no task, the token moves on. Pending countersign directives
+        // stay pending for the next user task that actually gets created.
+        if (candidates === null) {
+            await this.skipNodeByInitiatorExclusion(manager, instance, token, node);
+            return;
+        }
         const primaryCandidate = candidates[0];
+        // Legacy snapshots may carry no policy at all; they behave as before.
+        const decisionPolicy = node.data.decisionPolicy;
+        const isSequential = decisionPolicy?.type === 'SEQUENTIAL' && candidates.length > 1;
+        // A sequential task is held by exactly one candidate at a time, so it
+        // carries that candidate as its assignee from the start.
+        const assignedCandidate = candidates.length === 1 || isSequential ? primaryCandidate : null;
         const now = new Date();
         const slaDueAt = await this.slaScheduleService.resolveTaskSlaDueAt({
             node,
             now,
         });
         const task = await taskRepository.save(taskRepository.create({
-            assigneeMemberId: candidates.length === 1 ? primaryCandidate.memberId : null,
+            assigneeMemberId: assignedCandidate?.memberId ?? null,
             assignmentType: candidates.length === 1
                 ? workflow_engine_enums_1.TaskAssignmentTypeEnum.DIRECT_MEMBER
                 : workflow_engine_enums_1.TaskAssignmentTypeEnum.CANDIDATE_GROUP,
             completedAt: null,
             createdAt: now,
-            decisionPolicySnapshot: node.data.decisionPolicy,
-            delegationChain: candidates.length === 1 ? primaryCandidate.delegationChain : [],
+            decisionPolicySnapshot: isInitiatorExcluded(node)
+                ? capDecisionPolicyToCandidateCount(decisionPolicy, candidates.length)
+                : decisionPolicy,
+            delegationChain: assignedCandidate?.delegationChain ?? [],
             instanceId: instance.id,
             nodeId: node.id,
             openedAt: null,
-            originalAssigneeMemberId: candidates.length === 1 ? primaryCandidate.originalMemberId : null,
+            originalAssigneeMemberId: assignedCandidate?.originalMemberId ?? null,
             slaDueAt,
             status: workflow_engine_enums_1.TaskStatusEnum.PENDING,
             tokenId: token.id,
         }));
-        const savedCandidates = await taskCandidateRepository.save(candidates.map((candidate) => taskCandidateRepository.create({
+        const savedCandidates = await taskCandidateRepository.save(candidates.map((candidate, index) => taskCandidateRepository.create({
             claimedAt: null,
             createdAt: now,
             decidedAt: null,
             delegationChain: candidate.delegationChain,
             memberId: candidate.memberId,
             originalMemberId: candidate.originalMemberId,
+            sequence: isSequential ? index : null,
             sourceType: candidate.sourceType,
-            status: workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING,
+            status: isSequential && index > 0
+                ? workflow_engine_enums_1.TaskCandidateStatusEnum.WAITING
+                : workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING,
             taskId: task.id,
         })));
+        // Display summary of everyone on the task, including the ones whose turn
+        // has not come; who may act now is `status`, not membership of this list.
         task.candidateMemberIds = savedCandidates.map((candidate) => candidate.memberId);
         const singleCandidate = savedCandidates.length === 1 ? savedCandidates[0] : null;
+        const openCandidates = savedCandidates.filter((candidate) => candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING);
+        task.openCandidateMemberIds = openCandidates.map((candidate) => candidate.memberId);
         await tokenRepository.save({
             ...token,
             status: workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING,
@@ -2134,14 +2431,21 @@ let WorkflowEngineService = class WorkflowEngineService {
             nodeId: node.id,
             payload: {
                 assignmentType: task.assignmentType,
-                assigneeMemberId: singleCandidate?.memberId ?? null,
-                candidateMemberIds: savedCandidates.map((candidate) => candidate.memberId),
-                originalAssigneeMemberId: singleCandidate?.originalMemberId ?? null,
+                assigneeMemberId: (isSequential ? openCandidates[0] : singleCandidate)?.memberId ??
+                    null,
+                candidateMemberIds: openCandidates.map((candidate) => candidate.memberId),
+                originalAssigneeMemberId: (isSequential ? openCandidates[0] : singleCandidate)
+                    ?.originalMemberId ?? null,
+                ...(isSequential
+                    ? {
+                        sequentialCandidateMemberIds: savedCandidates.map((candidate) => candidate.memberId),
+                    }
+                    : {}),
                 tokenId: token.id,
             },
             taskId: task.id,
         }));
-        await savedCandidates.reduce(async (previous, candidate) => {
+        await openCandidates.reduce(async (previous, candidate) => {
             await previous;
             await this.notificationService.createTaskAssignedNotification({
                 instance,
@@ -2158,6 +2462,111 @@ let WorkflowEngineService = class WorkflowEngineService {
         // created after they were requested — spawn their parallel tasks now.
         await this.spawnCountersignTasksForNode(manager, instance, token, node, now);
     }
+    /**
+     * Hands a SEQUENTIAL task to the lowest-`sequence` candidate still WAITING.
+     * A task without a WAITING candidate (every other policy, and SEQUENTIAL
+     * tasks created before candidates were ordered) is left alone.
+     */
+    async activateNextSequentialCandidate({ candidates, instance, manager, node, previousMemberId, task, }) {
+        if (readDecisionPolicySnapshot(task).type !== 'SEQUENTIAL') {
+            return;
+        }
+        const nextCandidate = [...candidates]
+            .filter((candidate) => candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.WAITING &&
+            candidate.sequence !== null)
+            .sort((left, right) => (left.sequence ?? 0) - (right.sequence ?? 0))[0];
+        if (!nextCandidate) {
+            return;
+        }
+        const now = new Date();
+        // Delegation was resolved when the task was created; the candidate may have
+        // gained a delegate while waiting, so resolve it again for the new turn.
+        const delegation = await this.resolveActivationDelegation({
+            candidate: nextCandidate,
+            candidates,
+            excludesInitiator: isInitiatorExcluded(node),
+            instance,
+            nodeId: task.nodeId,
+        });
+        const activatedCandidate = await manager
+            .getRepository(task_candidate_entity_1.TaskCandidateEntity)
+            .save(Object.assign(new task_candidate_entity_1.TaskCandidateEntity(), nextCandidate, delegation, {
+            status: workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING,
+        }));
+        const activatedTask = await manager.getRepository(task_entity_1.TaskEntity).save({
+            ...task,
+            assigneeMemberId: activatedCandidate.memberId,
+            delegationChain: activatedCandidate.delegationChain,
+            openedAt: null,
+            originalAssigneeMemberId: activatedCandidate.originalMemberId,
+            // The new holder gets the node's full SLA window, not what is left of
+            // the previous holder's; the warning is measured from this moment.
+            slaDueAt: await this.slaScheduleService.resolveTaskSlaDueAt({
+                node,
+                now,
+            }),
+            slaStartedAt: now,
+            status: workflow_engine_enums_1.TaskStatusEnum.PENDING,
+        });
+        const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+        await activityRepository.save(activityRepository.create({
+            actorMemberId: null,
+            eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TASK_CANDIDATE_ACTIVATED,
+            instanceId: instance.id,
+            nodeId: task.nodeId,
+            // Carries the same recipient fields as TASK_CREATED so a consumer can
+            // route this event exactly like a task assignment.
+            payload: {
+                assigneeMemberId: activatedCandidate.memberId,
+                assignmentType: activatedTask.assignmentType,
+                candidateMemberId: activatedCandidate.memberId,
+                candidateMemberIds: [activatedCandidate.memberId],
+                originalAssigneeMemberId: activatedCandidate.originalMemberId,
+                originalMemberId: activatedCandidate.originalMemberId,
+                previousMemberId,
+                sequence: activatedCandidate.sequence,
+                tokenId: task.tokenId,
+            },
+            taskId: task.id,
+        }));
+        await this.notificationService.createTaskAssignedNotification({
+            instance,
+            manager,
+            node,
+            task: activatedTask,
+        });
+    }
+    /**
+     * Re-resolves the delegation of a candidate whose turn has come. When the
+     * delegate already holds another candidate row on the task, the stored values
+     * are kept: (task_id, member_id) is unique, and that member signs from the
+     * row they already have. On a node that excludes the initiator the stored
+     * values are kept as well when the new delegation path would run through the
+     * initiator: creation already filtered such paths out, and a delegation added
+     * while the candidate waited must not bring them back.
+     */
+    async resolveActivationDelegation({ candidate, candidates, excludesInitiator, instance, nodeId, }) {
+        const stored = {
+            delegationChain: candidate.delegationChain,
+            memberId: candidate.memberId,
+        };
+        const resolution = await this.delegationService.resolveAssignee(candidate.originalMemberId, this.buildDelegationContext(instance, nodeId));
+        const collides = candidates.some((other) => other.id !== candidate.id &&
+            other.memberId === resolution.finalAssigneeMemberId);
+        if (collides ||
+            (excludesInitiator &&
+                isInitiatorOnCandidatePath({
+                    delegationChain: resolution.delegationChain,
+                    memberId: resolution.finalAssigneeMemberId,
+                    originalMemberId: candidate.originalMemberId,
+                }, instance.initiatorMemberId))) {
+            return stored;
+        }
+        return {
+            delegationChain: resolution.delegationChain,
+            memberId: resolution.finalAssigneeMemberId,
+        };
+    }
     async markTaskCandidateDecision({ action, candidate, candidates, decidedAt, manager, task, }) {
         const taskCandidateRepository = manager.getRepository(task_candidate_entity_1.TaskCandidateEntity);
         if (!candidate && candidates.length === 0 && task.assigneeMemberId) {
@@ -2191,7 +2600,8 @@ let WorkflowEngineService = class WorkflowEngineService {
             }
             if (shouldCancelOpenCandidates &&
                 (currentCandidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING ||
-                    currentCandidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED)) {
+                    currentCandidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED ||
+                    currentCandidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.WAITING)) {
                 return Object.assign(new task_candidate_entity_1.TaskCandidateEntity(), currentCandidate, {
                     decidedAt,
                     status: workflow_engine_enums_1.TaskCandidateStatusEnum.CANCELLED,
@@ -2230,13 +2640,37 @@ let WorkflowEngineService = class WorkflowEngineService {
             delegationChain: nextDelegationChain,
             status: workflow_engine_enums_1.TaskStatusEnum.TRANSFERRED,
         });
+        // Candidates still waiting for their turn move with the task; without this
+        // the replacement SINGLE task would silently drop them from the chain.
+        // A waiting candidate who is also the transfer target takes the active slot
+        // and is not asked a second time later in the order.
+        const waitingCandidates = readDecisionPolicySnapshot(task).type === 'SEQUENTIAL' &&
+            actorCandidate?.sequence != null
+            ? (await taskCandidateRepository.find({ where: { taskId: task.id } }))
+                .filter((candidate) => candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.WAITING)
+                .sort((left, right) => (left.sequence ?? 0) - (right.sequence ?? 0))
+            : [];
+        const isSequentialTransfer = waitingCandidates.length > 0;
+        const carriedCandidates = waitingCandidates.filter((candidate) => candidate.memberId !== transferToMemberId);
         const nextTask = await taskRepository.save(taskRepository.create({
+            // A transferred ad-hoc task stays the same ad-hoc task for its new
+            // holder: the pre-approval rejection path (RETURN_TO_ORIGIN) reads these
+            // off the task being decided, so without them a rejection after a
+            // transfer rejected the whole instance instead.
+            adhocDirectiveId: task.adhocDirectiveId,
+            adhocOriginTaskId: task.adhocOriginTaskId,
+            adhocType: task.adhocType,
             assigneeMemberId: transferToMemberId,
-            assignmentType: workflow_engine_enums_1.TaskAssignmentTypeEnum.DIRECT_MEMBER,
+            assignmentType: isSequentialTransfer
+                ? task.assignmentType
+                : workflow_engine_enums_1.TaskAssignmentTypeEnum.DIRECT_MEMBER,
             completedAt: null,
-            decisionPolicySnapshot: { type: 'SINGLE' },
+            decisionPolicySnapshot: isSequentialTransfer
+                ? task.decisionPolicySnapshot
+                : { type: 'SINGLE' },
             delegationChain: nextDelegationChain,
             instanceId: task.instanceId,
+            isAdhoc: task.isAdhoc,
             nodeId: task.nodeId,
             openedAt: null,
             originalAssigneeMemberId: task.originalAssigneeMemberId,
@@ -2244,6 +2678,29 @@ let WorkflowEngineService = class WorkflowEngineService {
             status: workflow_engine_enums_1.TaskStatusEnum.PENDING,
             tokenId: task.tokenId,
         }));
+        // A pre-approval the previous holder requested still points at the task
+        // being transferred. Its RETURN_TO_ORIGIN rejection hands the decision back
+        // through adhocOriginTaskId, so leaving it on the TRANSFERRED row reopened
+        // a task for the member who had just transferred the stage away. Only open
+        // pre-approvals move; closed ones keep pointing at the task they ran
+        // against, and countersign tasks keep agreeing with directive.originTaskId
+        // because nothing reads their pointer. A pre-approval is always created on
+        // the origin task's instance and node, so those narrow the lookup to the
+        // idx_tasks_instance_node index (adhoc_origin_task_id has none).
+        const openPreApprovalsOnTransferredTask = (await taskRepository.find({
+            where: {
+                adhocOriginTaskId: task.id,
+                adhocType: adhoc_enums_1.AdhocDirectiveTypeEnum.PRE_APPROVAL,
+                instanceId: task.instanceId,
+                nodeId: task.nodeId,
+            },
+        })).filter((adhocTask) => adhocTask.status === workflow_engine_enums_1.TaskStatusEnum.PENDING ||
+            adhocTask.status === workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS);
+        if (openPreApprovalsOnTransferredTask.length > 0) {
+            await taskRepository.save(openPreApprovalsOnTransferredTask.map((adhocTask) => Object.assign(new task_entity_1.TaskEntity(), adhocTask, {
+                adhocOriginTaskId: nextTask.id,
+            })));
+        }
         await taskCandidateRepository.save([
             ...(actorCandidate
                 ? [
@@ -2261,10 +2718,28 @@ let WorkflowEngineService = class WorkflowEngineService {
                 delegationChain: nextDelegationChain,
                 memberId: transferToMemberId,
                 originalMemberId: task.originalAssigneeMemberId ?? transferToMemberId,
+                sequence: isSequentialTransfer
+                    ? (actorCandidate?.sequence ?? null)
+                    : null,
                 sourceType: 'DIRECT',
                 status: workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING,
                 taskId: nextTask.id,
             }),
+            ...carriedCandidates.map((candidate) => taskCandidateRepository.create({
+                claimedAt: null,
+                createdAt: candidate.createdAt,
+                decidedAt: null,
+                delegationChain: candidate.delegationChain,
+                memberId: candidate.memberId,
+                originalMemberId: candidate.originalMemberId,
+                sequence: candidate.sequence,
+                sourceType: candidate.sourceType,
+                status: workflow_engine_enums_1.TaskCandidateStatusEnum.WAITING,
+                taskId: nextTask.id,
+            })),
+            ...waitingCandidates.map((candidate) => Object.assign(new task_candidate_entity_1.TaskCandidateEntity(), candidate, {
+                status: workflow_engine_enums_1.TaskCandidateStatusEnum.SUPERSEDED,
+            })),
         ]);
         await activityRepository.save([
             activityRepository.create({
@@ -2289,8 +2764,19 @@ let WorkflowEngineService = class WorkflowEngineService {
                 nodeId: task.nodeId,
                 payload: {
                     assigneeMemberId: transferToMemberId,
+                    ...(isSequentialTransfer
+                        ? { candidateMemberIds: [transferToMemberId] }
+                        : {}),
                     delegationChain: nextDelegationChain,
                     originalAssigneeMemberId: task.originalAssigneeMemberId,
+                    ...(isSequentialTransfer
+                        ? {
+                            sequentialCandidateMemberIds: [
+                                transferToMemberId,
+                                ...carriedCandidates.map((candidate) => candidate.memberId),
+                            ],
+                        }
+                        : {}),
                     tokenId: task.tokenId,
                     transferredFromTaskId: task.id,
                 },
@@ -2308,16 +2794,51 @@ let WorkflowEngineService = class WorkflowEngineService {
             });
         }
     }
+    /**
+     * Resolves who gets the node's task. `null` means the node asked to be
+     * skipped (`excludeInitiator.whenEmpty = SKIP_NODE`) because the initiator
+     * was the only approver — the sole caller creates no task and advances the
+     * token instead.
+     */
     async resolveRuntimeTaskCandidates(manager, instance, node) {
-        const resolvedCandidates = await this.resolveApproverResolver(manager, instance, node.data.approverResolver, `簽核節點「${node.data.label}」`);
-        const uniqueCandidates = await this.applyDelegationToResolvedCandidates(instance, node.id, resolvedCandidates);
-        if (uniqueCandidates.length === 0) {
-            throw new common_1.ConflictException(`簽核節點「${node.data.label}」 did not resolve to any member id`);
+        const label = `簽核節點「${node.data.label}」`;
+        const resolvedCandidates = await this.resolveApproverResolver(manager, instance, node.data.approverResolver, label);
+        const delegatedCandidates = await this.delegateResolvedCandidates(instance, node.id, resolvedCandidates);
+        const excludeInitiator = node.data.excludeInitiator;
+        const uniqueCandidates = selectNodeCandidates(delegatedCandidates, isInitiatorExcluded(node), instance.initiatorMemberId);
+        if (uniqueCandidates.length > 0) {
+            return uniqueCandidates;
+        }
+        // Only the initiator was left — what the node does about it is configured.
+        // Nothing resolved to begin with is the ordinary failure below.
+        if (!excludeInitiator || delegatedCandidates.length === 0) {
+            throw new common_1.ConflictException(`${label} did not resolve to any member id`);
+        }
+        if (excludeInitiator.whenEmpty === 'SKIP_NODE') {
+            return null;
+        }
+        if (excludeInitiator.whenEmpty === 'INITIATOR_MANAGER') {
+            const managerCandidates = await this.resolveInitiatorManagerReplacements(manager, instance, node);
+            if (managerCandidates.length > 0) {
+                return managerCandidates;
+            }
+            throw new common_1.ConflictException(`${label} 無法建立待簽任務：解析出的簽核人只剩申請人本人，此節點不允許申請人自簽，且找不到申請人的主管可改派。`);
         }
-        return uniqueCandidates;
+        throw new common_1.ConflictException(`${label} 無法建立待簽任務：解析出的簽核人只剩申請人本人（含委派後的代理人），且此節點不允許申請人自簽。`);
+    }
+    async resolveInitiatorManagerReplacements(manager, instance, node) {
+        // The initiator's own direct manager: the closest org unit only, and the
+        // initiator himself (a unit head) is skipped so resolution falls through
+        // to the next tier instead of ending on him.
+        const managerMemberIds = await this.resolveDirectManagerMemberIds(manager, instance.initiatorMemberId, toDateOnlyString(new Date()), true, instance.initiatorMemberId);
+        const delegatedCandidates = await this.delegateResolvedCandidates(instance, node.id, managerMemberIds.map((memberId) => ({
+            memberId,
+            sourceType: 'EXCLUDE_INITIATOR_MANAGER',
+        })));
+        return selectNodeCandidates(delegatedCandidates, true, instance.initiatorMemberId);
     }
-    async applyDelegationToResolvedCandidates(instance, nodeId, resolvedCandidates) {
-        const context = {
+    buildDelegationContext(instance, nodeId) {
+        return {
             formData: instance.formData,
             initiatorMemberId: instance.initiatorMemberId,
             initiatorMetadataSnapshot: instance.initiatorMetadataSnapshot,
@@ -2328,6 +2849,11 @@ let WorkflowEngineService = class WorkflowEngineService {
             templateVersionId: instance.templateVersionId,
             title: instance.title,
         };
+    }
+    // Not deduplicated: a node that excludes the initiator filters first, so a
+    // first-seen entry that must be dropped cannot shadow a legitimate one.
+    async delegateResolvedCandidates(instance, nodeId, resolvedCandidates) {
+        const context = this.buildDelegationContext(instance, nodeId);
         const delegatedCandidates = await Promise.all(resolvedCandidates.map(async (candidate) => {
             const delegationResolution = await this.delegationService.resolveAssignee(candidate.memberId, context);
             return {
@@ -2337,7 +2863,7 @@ let WorkflowEngineService = class WorkflowEngineService {
                 sourceType: candidate.sourceType,
             };
         }));
-        return uniqueRuntimeCandidates(delegatedCandidates);
+        return delegatedCandidates;
     }
     async resolveApproverResolver(manager, instance, resolver, label) {
         if (resolver.type === 'DIRECT') {
@@ -2361,6 +2887,9 @@ let WorkflowEngineService = class WorkflowEngineService {
         if (resolver.type === 'ORG_UNIT_MANAGER') {
             return this.resolveOrgUnitManagerCandidates(manager, instance, resolver.orgUnitId, resolver.fallback, label, resolver.preferClosestOrgUnit === true).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
         }
+        if (resolver.type === 'ORG_MANAGER_CHAIN') {
+            return this.resolveOrgManagerChainCandidates(manager, instance, resolver.minPositionLevel, resolver.fallback, label).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
+        }
         return this.resolveInitiatorManagerCandidates(manager, instance, resolver.levelsUp, resolver.fallback, label, resolver.preferClosestOrgUnit === true).then((memberIds) => memberIds.map((memberId) => ({ memberId, sourceType: resolver.type })));
     }
     async resolvePositionCandidates(manager, positionId, label) {
@@ -2392,6 +2921,72 @@ let WorkflowEngineService = class WorkflowEngineService {
             this.resolveFallbackAssignee(instance, fallback, label, `找不到發起人的第 ${normalizedLevelsUp} 層主管`),
         ];
     }
+    /**
+     * Walks up the initiator's manager chain, nearest manager first, until a
+     * manager whose position level reaches `minPositionLevel` is added. The
+     * list is returned nearest manager first.
+     */
+    async resolveOrgManagerChainCandidates(manager, instance, minPositionLevel, fallback, label) {
+        const date = toDateOnlyString(new Date());
+        const visitedMemberIds = new Set([instance.initiatorMemberId]);
+        const chain = [];
+        let currentMemberId = instance.initiatorMemberId;
+        let lastAddedLevel = null;
+        for (let hop = 0; hop < ORG_MANAGER_CHAIN_MAX_HOPS; hop += 1) {
+            // A chain is a single path, so it always uses closest-org-unit semantics
+            // (merging ancestor-unit rules could only produce ties). The member is
+            // excluded from his own candidates: a unit head belongs to the unit he
+            // heads, so without this his unit rule would name himself and the walk
+            // could never climb past him.
+            const directManagerMemberIds = await this.resolveDirectManagerMemberIds(manager, currentMemberId, date, true, currentMemberId);
+            if (directManagerMemberIds.length === 0) {
+                break;
+            }
+            if (directManagerMemberIds.length > 1) {
+                // Picking one silently would route the document by accident.
+                throw new common_1.ConflictException(`${label} 無法沿主管鏈簽核：成員 ${currentMemberId} 的主管規則在同一優先順序出現多位主管（${directManagerMemberIds.join('、')}），無法決定簽核路徑。請聯絡流程管理員調整主管規則。`);
+            }
+            const [managerMemberId] = directManagerMemberIds;
+            if (visitedMemberIds.has(managerMemberId)) {
+                break;
+            }
+            visitedMemberIds.add(managerMemberId);
+            currentMemberId = managerMemberId;
+            const level = await this.readMemberPositionLevel(manager, managerMemberId, date);
+            if (level === null ||
+                (lastAddedLevel !== null && level <= lastAddedLevel)) {
+                continue;
+            }
+            chain.push(managerMemberId);
+            lastAddedLevel = level;
+            if (level >= minPositionLevel) {
+                return chain;
+            }
+        }
+        const fallbackMemberId = this.resolveFallbackAssignee(instance, fallback, label, `沿主管鏈找不到職等達 ${minPositionLevel} 的主管`);
+        return chain.includes(fallbackMemberId)
+            ? chain
+            : [...chain, fallbackMemberId];
+    }
+    /** Highest position level over the member's active memberships, or `null`. */
+    async readMemberPositionLevel(manager, memberId, date) {
+        const memberships = await manager.getRepository(membership_entity_1.MembershipEntity).find({
+            where: { memberId },
+        });
+        const positionIds = uniqueTexts(memberships
+            .filter((membership) => isDateRangeActive(membership, date))
+            .map((membership) => membership.positionId)
+            .filter((positionId) => Boolean(positionId)));
+        if (positionIds.length === 0) {
+            return null;
+        }
+        const positions = await manager.getRepository(position_entity_1.PositionEntity).find({
+            where: { id: (0, typeorm_2.In)([...positionIds]) },
+        });
+        return positions.length === 0
+            ? null
+            : Math.max(...positions.map((position) => position.level));
+    }
     resolveFallbackAssignee(instance, fallback, label, failureReason) {
         if (!fallback || fallback.type === 'NONE') {
             throw new common_1.ConflictException(`${label} 無法建立待簽任務：${failureReason}，且未設定改派固定人。請聯絡流程管理員調整主管規則或模板 fallback。`);
@@ -2416,7 +3011,7 @@ let WorkflowEngineService = class WorkflowEngineService {
         const nextLevelGroups = await Promise.all(directManagerMemberIds.map((managerMemberId) => this.resolveManagerMemberIdsAtLevel(manager, managerMemberId, date, remainingLevels - 1, preferClosestOrgUnit)));
         return uniqueTexts(nextLevelGroups.flat());
     }
-    async resolveDirectManagerMemberIds(manager, memberId, date, preferClosestOrgUnit) {
+    async resolveDirectManagerMemberIds(manager, memberId, date, preferClosestOrgUnit, excludedManagerMemberId) {
         const memberships = await manager.getRepository(membership_entity_1.MembershipEntity).find({
             where: { memberId },
         });
@@ -2437,7 +3032,7 @@ let WorkflowEngineService = class WorkflowEngineService {
                 scopeType: organization_enums_1.ManagerResolutionScopeTypeEnum.POSITION,
             })),
         ];
-        return this.resolveManagerResolutionCandidates(manager, candidatePairs, date, readOrgUnitDepthMap(orgUnits), preferClosestOrgUnit);
+        return this.resolveManagerResolutionCandidates(manager, candidatePairs, date, readOrgUnitDepthMap(orgUnits), preferClosestOrgUnit, excludedManagerMemberId);
     }
     async resolveOrgUnitManagerCandidates(manager, instance, orgUnitId, fallback, label, preferClosestOrgUnit) {
         const date = toDateOnlyString(new Date());
@@ -2469,7 +3064,7 @@ let WorkflowEngineService = class WorkflowEngineService {
         const byId = new Map([...directOrgUnits, ...ancestorGroups.flat()].map((orgUnit) => [orgUnit.id, orgUnit]));
         return [...byId.values()];
     }
-    async resolveManagerResolutionCandidates(manager, candidatePairs, date, orgUnitDepths, preferClosestOrgUnit) {
+    async resolveManagerResolutionCandidates(manager, candidatePairs, date, orgUnitDepths, preferClosestOrgUnit, excludedManagerMemberId) {
         const scopeIds = candidatePairs.map((pair) => pair.scopeId);
         if (!scopeIds.length) {
             return [];
@@ -2491,6 +3086,10 @@ let WorkflowEngineService = class WorkflowEngineService {
             .filter((resolution) => candidatePairs.some((pair) => pair.scopeId === resolution.scopeId &&
             pair.scopeType === resolution.scopeType))
             .filter((resolution) => isDateRangeActive(resolution, date))
+            // Dropped before the top-priority tier is chosen, so resolution falls
+            // through to the next tier instead of ending on the excluded member.
+            .filter((resolution) => excludedManagerMemberId === undefined ||
+            resolution.managerMemberId !== excludedManagerMemberId)
             .sort((left, right) => compareManagerResolution(left, right, depthLookup));
         return uniqueTexts(readTopPriorityResolutions(active, depthLookup).map((resolution) => resolution.managerMemberId));
     }
@@ -2893,7 +3492,8 @@ let WorkflowEngineService = class WorkflowEngineService {
         }
         const candidateRepository = manager.getRepository(task_candidate_entity_1.TaskCandidateEntity);
         const candidates = (await candidateRepository.find({ where: { taskId: (0, typeorm_2.In)([...taskIds]) } })).filter((candidate) => candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING ||
-            candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED);
+            candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED ||
+            candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.WAITING);
         if (candidates.length === 0) {
             return;
         }
@@ -3310,6 +3910,43 @@ function uniqueRuntimeCandidates(candidates) {
         return true;
     });
 }
+// A task signs in order only when its snapshot says so and its candidates carry
+// a sequence; a SEQUENTIAL task from before ordering existed behaves as before.
+function isOrderedSequentialTask(task, candidates) {
+    return (readDecisionPolicySnapshot(task).type === 'SEQUENTIAL' &&
+        candidates.some((candidate) => candidate.sequence !== null));
+}
+// Every read of the setting goes through here so an explicit `null` behaves
+// exactly like an absent setting.
+function isInitiatorExcluded(node) {
+    return Boolean(node.data.excludeInitiator);
+}
+// A delegate acting for the initiator is still the initiator approving their
+// own document, so the initiator anywhere on the delegation path (the
+// pre-delegation member, any hop, or the final assignee) drops the candidate.
+function isInitiatorOnCandidatePath(candidate, initiatorMemberId) {
+    return (candidate.memberId === initiatorMemberId ||
+        candidate.originalMemberId === initiatorMemberId ||
+        candidate.delegationChain.some((step) => step.from === initiatorMemberId || step.to === initiatorMemberId));
+}
+// The initiator filter runs on the delegated list before the dedupe, so a
+// legitimate approver is never shadowed by an excluded entry for the same
+// final assignee. Without the exclusion this is the plain dedupe.
+function selectNodeCandidates(delegatedCandidates, excludeInitiator, initiatorMemberId) {
+    return uniqueRuntimeCandidates(excludeInitiator
+        ? delegatedCandidates.filter((candidate) => !isInitiatorOnCandidatePath(candidate, initiatorMemberId))
+        : delegatedCandidates);
+}
+// A COUNT threshold above the people left would never be reached once the
+// initiator is gone, so it is capped at who remains ("everyone else").
+// PERCENTAGE is computed from the actual candidate count and needs nothing.
+function capDecisionPolicyToCandidateCount(policy, candidateCount) {
+    return policy?.type === 'QUORUM' &&
+        policy.thresholdType === 'COUNT' &&
+        policy.threshold > candidateCount
+        ? { ...policy, threshold: Math.max(candidateCount, 1) }
+        : policy;
+}
 function uniqueTasksById(tasks) {
     const seen = new Set();
     return tasks.filter((task) => {