@rytass/bpm-core-nestjs-module 0.2.0 → 0.3.0

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

@@ -22,6 +22,8 @@ const approval_template_version_entity_1 = require("../template/approval-templat
 const approval_template_entity_1 = require("../template/approval-template.entity");
 const template_enums_1 = require("../template/template.enums");
 const activity_log_entity_1 = require("./activity-log.entity");
+const adhoc_directive_entity_1 = require("./adhoc-directive.entity");
+const adhoc_enums_1 = require("./adhoc.enums");
 const approval_instance_entity_1 = require("./approval-instance.entity");
 const task_decision_entity_1 = require("./task-decision.entity");
 const task_candidate_entity_1 = require("./task-candidate.entity");
@@ -41,7 +43,7 @@ const WORKFLOW_READ_ALL_PERMISSIONS = new Set([
     'workflow.read_all',
 ]);
 let WorkflowEngineService = class WorkflowEngineService {
-    constructor(approvalInstanceRepository, workflowTokenRepository, taskRepository, taskCandidateRepository, taskDecisionRepository, notificationRepository, activityLogRepository, approvalTemplateRepository, approvalTemplateVersionRepository, formDefinitionVersionRepository, attachmentService, conditionService, delegationService, notificationService, signatureService, serviceTaskDispatcher = new workflow_service_task_dispatcher_token_1.DefaultWorkflowServiceTaskDispatcher()) {
+    constructor(approvalInstanceRepository, workflowTokenRepository, taskRepository, taskCandidateRepository, taskDecisionRepository, notificationRepository, activityLogRepository, adhocDirectiveRepository, approvalTemplateRepository, approvalTemplateVersionRepository, formDefinitionVersionRepository, attachmentService, conditionService, delegationService, notificationService, signatureService, serviceTaskDispatcher = new workflow_service_task_dispatcher_token_1.DefaultWorkflowServiceTaskDispatcher()) {
         this.approvalInstanceRepository = approvalInstanceRepository;
         this.workflowTokenRepository = workflowTokenRepository;
         this.taskRepository = taskRepository;
@@ -49,6 +51,7 @@ let WorkflowEngineService = class WorkflowEngineService {
         this.taskDecisionRepository = taskDecisionRepository;
         this.notificationRepository = notificationRepository;
         this.activityLogRepository = activityLogRepository;
+        this.adhocDirectiveRepository = adhocDirectiveRepository;
         this.approvalTemplateRepository = approvalTemplateRepository;
         this.approvalTemplateVersionRepository = approvalTemplateVersionRepository;
         this.formDefinitionVersionRepository = formDefinitionVersionRepository;
@@ -187,19 +190,7 @@ let WorkflowEngineService = class WorkflowEngineService {
                 task.status !== workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS) {
                 throw new common_1.ConflictException(`Task ${task.id} is not pending`);
             }
-            const taskCandidates = await taskCandidateRepository.find({
-                where: { taskId: task.id },
-            });
-            const actorCandidate = taskCandidates.find((candidate) => candidate.memberId === input.decidedByMemberId);
-            const isDirectAssignee = task.assigneeMemberId === input.decidedByMemberId;
-            if (!isDirectAssignee && !actorCandidate) {
-                throw new common_1.ConflictException(`Task ${task.id} is assigned to another member`);
-            }
-            if (actorCandidate &&
-                actorCandidate.status !== workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING &&
-                actorCandidate.status !== workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED) {
-                throw new common_1.ConflictException(`Task ${task.id} was already decided by this member`);
-            }
+            const { actorCandidate, taskCandidates } = await this.readTaskActorContext(manager, task, input.decidedByMemberId);
             if (input.action !== workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED &&
                 input.action !== workflow_engine_enums_1.TaskDecisionActionEnum.REJECTED &&
                 input.action !== workflow_engine_enums_1.TaskDecisionActionEnum.RETURNED &&
@@ -332,6 +323,13 @@ let WorkflowEngineService = class WorkflowEngineService {
             });
             if (input.action === workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED &&
                 shouldCompleteTask) {
+                // Ad-hoc gate: the token may only advance once every task bound to
+                // this token+node (the original task plus any ad-hoc countersign /
+                // pre-approval tasks) has reached a terminal state. Nodes without
+                // ad-hoc tasks keep the original single-task behaviour.
+                if (await this.hasOpenTasksForTokenNode(manager, claimedTask.tokenId, claimedTask.nodeId)) {
+                    return decision;
+                }
                 const token = await tokenRepository.findOne({
                     where: { id: claimedTask.tokenId },
                 });
@@ -346,6 +344,7 @@ let WorkflowEngineService = class WorkflowEngineService {
                     consumedAt: null,
                     status: workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE,
                 });
+                await this.dispatchAdhocStageNotifications(manager, instance, claimedTask.nodeId, 'APPROVED');
                 await this.advanceTokenToOutgoingNodes(manager, instance, activeToken, readWorkflowNodeOrThrow(instance.workflowSnapshot, claimedTask.nodeId));
                 await this.processRunningInstance(manager, instance);
                 return decision;
@@ -357,6 +356,9 @@ let WorkflowEngineService = class WorkflowEngineService {
                 await this.returnInstanceToNode(manager, instance, completedTask, returnToNodeId, decidedAt);
                 return decision;
             }
+            if (await this.handleAdhocPreApprovalRejection(manager, instance, completedTask, decidedAt, decisionComment)) {
+                return decision;
+            }
             await this.rejectInstance(manager, instance, completedTask, decidedAt);
             return decision;
         });
@@ -391,6 +393,8 @@ let WorkflowEngineService = class WorkflowEngineService {
                 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);
             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,
@@ -453,6 +457,567 @@ let WorkflowEngineService = class WorkflowEngineService {
             return runtimeInstance;
         });
     }
+    async requestAdhocCountersign({ comment, requestedByMemberId, target, taskId, }) {
+        return this.approvalInstanceRepository.manager.transaction(async (manager) => {
+            const { instance, node, task } = await this.loadAdhocOperationContext(manager, taskId, requestedByMemberId, { requireAllowAddSigner: true });
+            const targetValue = buildAdhocTargetValue(target);
+            // Rejects WEBHOOK targets — countersigners must be members.
+            buildAdhocApproverResolver(targetValue);
+            const directiveRepository = manager.getRepository(adhoc_directive_entity_1.AdhocDirectiveEntity);
+            const directive = await directiveRepository.save(directiveRepository.create({
+                channels: null,
+                comment: comment?.trim() || null,
+                consumedAt: null,
+                createdByMemberId: requestedByMemberId,
+                instanceId: instance.id,
+                onReject: null,
+                originNodeId: task.nodeId,
+                originTaskId: task.id,
+                status: adhoc_enums_1.AdhocDirectiveStatusEnum.PENDING,
+                targetKind: targetValue.kind,
+                targetValue: { ...targetValue },
+                type: adhoc_enums_1.AdhocDirectiveTypeEnum.COUNTERSIGN,
+            }));
+            await this.recordAdhocDirectiveActivity(manager, directive, workflow_engine_enums_1.ActivityLogEventTypeEnum.ADHOC_DIRECTIVE_CREATED, requestedByMemberId, { nodeLabel: node.data.label });
+            return directive;
+        });
+    }
+    async requestAdhocPreApproval({ comment, onReject, requestedByMemberId, target, taskId, }) {
+        return this.approvalInstanceRepository.manager.transaction(async (manager) => {
+            const { instance, node, task } = await this.loadAdhocOperationContext(manager, taskId, requestedByMemberId, { requireAllowAddSigner: true });
+            const targetValue = buildAdhocTargetValue(target);
+            // Rejects WEBHOOK targets — pre-approvers must be members.
+            buildAdhocApproverResolver(targetValue);
+            const now = new Date();
+            const directiveRepository = manager.getRepository(adhoc_directive_entity_1.AdhocDirectiveEntity);
+            const directive = await directiveRepository.save(directiveRepository.create({
+                channels: null,
+                comment: comment?.trim() || null,
+                consumedAt: now,
+                createdByMemberId: requestedByMemberId,
+                instanceId: instance.id,
+                onReject,
+                originNodeId: task.nodeId,
+                originTaskId: task.id,
+                status: adhoc_enums_1.AdhocDirectiveStatusEnum.CONSUMED,
+                targetKind: targetValue.kind,
+                targetValue: { ...targetValue },
+                type: adhoc_enums_1.AdhocDirectiveTypeEnum.PRE_APPROVAL,
+            }));
+            const adhocTask = await this.createAdhocTaskForDirective(manager, instance, task.tokenId, node, directive, now);
+            await this.recordAdhocDirectiveActivity(manager, directive, workflow_engine_enums_1.ActivityLogEventTypeEnum.ADHOC_DIRECTIVE_CREATED, requestedByMemberId, { adhocTaskId: adhocTask.id, nodeLabel: node.data.label, onReject });
+            return adhocTask;
+        });
+    }
+    async configureAdhocNotification({ channels, requestedByMemberId, target, taskId, type, }) {
+        return this.approvalInstanceRepository.manager.transaction(async (manager) => {
+            const { instance, node, task } = await this.loadAdhocOperationContext(manager, taskId, requestedByMemberId, { requireAllowAddSigner: false });
+            const targetValue = buildAdhocTargetValue(target);
+            const directiveRepository = manager.getRepository(adhoc_directive_entity_1.AdhocDirectiveEntity);
+            const directive = await directiveRepository.save(directiveRepository.create({
+                channels: channels?.length ? [...channels] : null,
+                comment: null,
+                consumedAt: null,
+                createdByMemberId: requestedByMemberId,
+                instanceId: instance.id,
+                onReject: null,
+                originNodeId: task.nodeId,
+                originTaskId: task.id,
+                status: adhoc_enums_1.AdhocDirectiveStatusEnum.PENDING,
+                targetKind: targetValue.kind,
+                targetValue: { ...targetValue },
+                type,
+            }));
+            await this.recordAdhocDirectiveActivity(manager, directive, workflow_engine_enums_1.ActivityLogEventTypeEnum.ADHOC_DIRECTIVE_CREATED, requestedByMemberId, { nodeLabel: node.data.label });
+            return directive;
+        });
+    }
+    async cancelAdhocDirective({ cancelledByMemberId, directiveId, }) {
+        return this.approvalInstanceRepository.manager.transaction(async (manager) => {
+            const directiveRepository = manager.getRepository(adhoc_directive_entity_1.AdhocDirectiveEntity);
+            const directive = await directiveRepository.findOne({
+                where: { id: directiveId },
+            });
+            if (!directive) {
+                throw new common_1.NotFoundException(`Ad-hoc directive ${directiveId} was not found`);
+            }
+            await manager.query('SELECT pg_advisory_xact_lock(hashtext($1))', [
+                directive.instanceId,
+            ]);
+            if (directive.createdByMemberId !== cancelledByMemberId) {
+                throw new common_1.ConflictException(`Ad-hoc directive ${directive.id} can only be cancelled by its creator`);
+            }
+            if (directive.status !== adhoc_enums_1.AdhocDirectiveStatusEnum.PENDING) {
+                throw new common_1.ConflictException(`Ad-hoc directive ${directive.id} is not pending`);
+            }
+            const cancelledDirective = await directiveRepository.save({
+                ...directive,
+                status: adhoc_enums_1.AdhocDirectiveStatusEnum.CANCELLED,
+            });
+            await this.recordAdhocDirectiveActivity(manager, cancelledDirective, workflow_engine_enums_1.ActivityLogEventTypeEnum.ADHOC_DIRECTIVE_CANCELLED, cancelledByMemberId);
+            return cancelledDirective;
+        });
+    }
+    async listAdhocDirectives(instanceId, scope) {
+        await this.getApprovalInstance(instanceId, scope);
+        return this.adhocDirectiveRepository.find({
+            order: { createdAt: 'ASC' },
+            where: { instanceId },
+        });
+    }
+    async readTaskActorContext(manager, task, actingMemberId) {
+        const taskCandidates = await manager
+            .getRepository(task_candidate_entity_1.TaskCandidateEntity)
+            .find({ where: { taskId: task.id } });
+        const actorCandidate = taskCandidates.find((candidate) => candidate.memberId === actingMemberId) ?? null;
+        const isDirectAssignee = task.assigneeMemberId === actingMemberId;
+        if (!isDirectAssignee && !actorCandidate) {
+            throw new common_1.ConflictException(`Task ${task.id} is assigned to another member`);
+        }
+        if (actorCandidate &&
+            actorCandidate.status !== workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING &&
+            actorCandidate.status !== workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED) {
+            throw new common_1.ConflictException(`Task ${task.id} was already decided by this member`);
+        }
+        return { actorCandidate, taskCandidates };
+    }
+    async loadAdhocOperationContext(manager, taskId, actingMemberId, options) {
+        const task = await manager
+            .getRepository(task_entity_1.TaskEntity)
+            .findOne({ where: { id: taskId } });
+        if (!task) {
+            throw new common_1.NotFoundException(`Task ${taskId} was not found`);
+        }
+        await manager.query('SELECT pg_advisory_xact_lock(hashtext($1))', [
+            task.instanceId,
+        ]);
+        if (task.status !== workflow_engine_enums_1.TaskStatusEnum.PENDING &&
+            task.status !== workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS) {
+            throw new common_1.ConflictException(`Task ${task.id} is not pending`);
+        }
+        await this.readTaskActorContext(manager, task, actingMemberId);
+        const instance = await manager
+            .getRepository(approval_instance_entity_1.ApprovalInstanceEntity)
+            .findOne({ where: { id: task.instanceId } });
+        if (!instance) {
+            throw new common_1.NotFoundException(`Approval instance ${task.instanceId} was not found`);
+        }
+        if (instance.state !== workflow_engine_enums_1.ApprovalInstanceStateEnum.RUNNING) {
+            throw new common_1.ConflictException(`Approval instance ${instance.id} is 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`);
+        }
+        if (options.requireAllowAddSigner && !node.data.allowAddSigner) {
+            throw new common_1.ForbiddenException(`簽核節點「${node.data.label}」does not allow ad-hoc signers`);
+        }
+        return { instance, node, task };
+    }
+    async recordAdhocDirectiveActivity(manager, directive, eventType, actorMemberId, extraPayload = {}) {
+        const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+        await activityRepository.save(activityRepository.create({
+            actorMemberId,
+            eventType,
+            instanceId: directive.instanceId,
+            nodeId: directive.originNodeId,
+            payload: {
+                ...extraPayload,
+                directiveId: directive.id,
+                directiveStatus: directive.status,
+                directiveType: directive.type,
+                targetKind: directive.targetKind,
+            },
+            taskId: directive.originTaskId,
+        }));
+    }
+    async createAdhocTaskForDirective(manager, instance, tokenId, node, directive, now) {
+        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 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 primaryCandidate = candidates[0];
+        const task = await taskRepository.save(taskRepository.create({
+            adhocDirectiveId: directive.id,
+            adhocOriginTaskId: directive.originTaskId,
+            adhocType: directive.type,
+            assigneeMemberId: candidates.length === 1 ? primaryCandidate.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: { type: 'SINGLE' },
+            delegationChain: candidates.length === 1 ? primaryCandidate.delegationChain : [],
+            instanceId: instance.id,
+            isAdhoc: true,
+            nodeId: node.id,
+            openedAt: null,
+            originalAssigneeMemberId: candidates.length === 1 ? primaryCandidate.originalMemberId : null,
+            slaDueAt: null,
+            status: workflow_engine_enums_1.TaskStatusEnum.PENDING,
+            tokenId,
+        }));
+        const savedCandidates = await taskCandidateRepository.save(candidates.map((candidate) => taskCandidateRepository.create({
+            claimedAt: null,
+            createdAt: now,
+            decidedAt: null,
+            delegationChain: candidate.delegationChain,
+            memberId: candidate.memberId,
+            originalMemberId: candidate.originalMemberId,
+            sourceType: candidate.sourceType,
+            status: workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING,
+            taskId: task.id,
+        })));
+        task.candidateMemberIds = savedCandidates.map((candidate) => candidate.memberId);
+        await activityRepository.save(activityRepository.create({
+            actorMemberId: directive.createdByMemberId,
+            eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TASK_CREATED,
+            instanceId: instance.id,
+            nodeId: node.id,
+            payload: {
+                adhocDirectiveId: directive.id,
+                adhocType: directive.type,
+                assigneeMemberId: task.assigneeMemberId,
+                assignmentType: task.assignmentType,
+                candidateMemberIds: savedCandidates.map((candidate) => candidate.memberId),
+                originTaskId: directive.originTaskId,
+                tokenId,
+            },
+            taskId: task.id,
+        }));
+        await savedCandidates.reduce(async (previous, candidate) => {
+            await previous;
+            await this.notificationService.createTaskAssignedNotification({
+                instance,
+                manager,
+                node,
+                task: Object.assign(new task_entity_1.TaskEntity(), task, {
+                    assigneeMemberId: candidate.memberId,
+                    delegationChain: candidate.delegationChain,
+                    originalAssigneeMemberId: candidate.originalMemberId,
+                }),
+            });
+        }, Promise.resolve());
+        return task;
+    }
+    async spawnCountersignTasksForNode(manager, instance, token, node, now) {
+        const directiveRepository = manager.getRepository(adhoc_directive_entity_1.AdhocDirectiveEntity);
+        const directives = await directiveRepository.find({
+            order: { createdAt: 'ASC' },
+            where: {
+                instanceId: instance.id,
+                status: adhoc_enums_1.AdhocDirectiveStatusEnum.PENDING,
+                type: adhoc_enums_1.AdhocDirectiveTypeEnum.COUNTERSIGN,
+            },
+        });
+        if (directives.length === 0) {
+            return;
+        }
+        await directives.reduce(async (previous, directive) => {
+            await previous;
+            try {
+                await this.createAdhocTaskForDirective(manager, instance, token.id, node, directive, now);
+                await directiveRepository.save({
+                    ...directive,
+                    consumedAt: now,
+                    status: adhoc_enums_1.AdhocDirectiveStatusEnum.CONSUMED,
+                });
+            }
+            catch (error) {
+                // A countersign target that no longer resolves must not block the
+                // main flow — cancel the directive and record the failure.
+                await directiveRepository.save({
+                    ...directive,
+                    status: adhoc_enums_1.AdhocDirectiveStatusEnum.CANCELLED,
+                });
+                await this.recordAdhocDirectiveActivity(manager, directive, workflow_engine_enums_1.ActivityLogEventTypeEnum.ADHOC_DIRECTIVE_CANCELLED, null, {
+                    error: error instanceof Error
+                        ? error.message
+                        : 'Countersign target resolution failed',
+                });
+            }
+        }, Promise.resolve());
+    }
+    async hasOpenTasksForTokenNode(manager, tokenId, nodeId) {
+        const tasks = await manager.getRepository(task_entity_1.TaskEntity).find({
+            where: { nodeId, tokenId },
+        });
+        return tasks.some((task) => task.tokenId === tokenId &&
+            task.nodeId === nodeId &&
+            (task.status === workflow_engine_enums_1.TaskStatusEnum.PENDING ||
+                task.status === workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS));
+    }
+    async handleAdhocPreApprovalRejection(manager, instance, task, decidedAt, decisionComment) {
+        if (!task.isAdhoc ||
+            task.adhocType !== adhoc_enums_1.AdhocDirectiveTypeEnum.PRE_APPROVAL ||
+            !task.adhocDirectiveId) {
+            return false;
+        }
+        const directive = await manager
+            .getRepository(adhoc_directive_entity_1.AdhocDirectiveEntity)
+            .findOne({ where: { id: task.adhocDirectiveId } });
+        if (directive?.onReject !==
+            adhoc_enums_1.AdhocPreApprovalRejectBehaviorEnum.RETURN_TO_ORIGIN) {
+            return false;
+        }
+        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
+            ? await taskRepository.findOne({ where: { id: task.adhocOriginTaskId } })
+            : 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
+        // missing, or already closed without a resolvable assignee), fall back to
+        // the default rejection path instead of leaving the token stuck WAITING
+        // with no open task.
+        if (!originTask || (!originTaskIsOpen && !originTask.assigneeMemberId)) {
+            return false;
+        }
+        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.
+            const reopenedTask = await taskRepository.save(taskRepository.create({
+                assigneeMemberId: originTask.assigneeMemberId,
+                assignmentType: workflow_engine_enums_1.TaskAssignmentTypeEnum.DIRECT_MEMBER,
+                completedAt: null,
+                createdAt: decidedAt,
+                decisionPolicySnapshot: { type: 'SINGLE' },
+                delegationChain: originTask.delegationChain,
+                instanceId: instance.id,
+                nodeId: originTask.nodeId,
+                openedAt: null,
+                originalAssigneeMemberId: originTask.originalAssigneeMemberId,
+                slaDueAt: null,
+                status: workflow_engine_enums_1.TaskStatusEnum.PENDING,
+                tokenId: originTask.tokenId,
+            }));
+            await taskCandidateRepository.save(taskCandidateRepository.create({
+                claimedAt: null,
+                createdAt: decidedAt,
+                decidedAt: null,
+                delegationChain: originTask.delegationChain,
+                memberId: originTask.assigneeMemberId,
+                originalMemberId: originTask.originalAssigneeMemberId ?? originTask.assigneeMemberId,
+                sourceType: 'DIRECT',
+                status: workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING,
+                taskId: reopenedTask.id,
+            }));
+            await activityRepository.save(activityRepository.create({
+                actorMemberId: task.assigneeMemberId,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TASK_CREATED,
+                instanceId: instance.id,
+                nodeId: originTask.nodeId,
+                payload: {
+                    adhocDirectiveId: directive.id,
+                    assigneeMemberId: originTask.assigneeMemberId,
+                    reopenedFromTaskId: originTask.id,
+                    rejectedAdhocTaskId: task.id,
+                    tokenId: originTask.tokenId,
+                },
+                taskId: reopenedTask.id,
+            }));
+            if (node.type === 'userTask') {
+                await this.notificationService.createTaskAssignedNotification({
+                    instance,
+                    manager,
+                    node,
+                    task: reopenedTask,
+                });
+            }
+        }
+        const recipientMemberIds = await this.readOpenTaskRecipientMemberIds(manager, originTask);
+        if (recipientMemberIds.length > 0) {
+            await this.notificationService.createAdhocWorkflowNotifications({
+                channels: null,
+                instance,
+                manager,
+                message: `案件「${instance.title}」的臨時加簽已被拒絕${decisionComment ? `：${decisionComment}` : '。'}`,
+                payload: {
+                    adhocTaskId: task.id,
+                    directiveId: directive.id,
+                    nodeId: task.nodeId,
+                    originTaskId: originTask.id,
+                    type: 'PRE_APPROVAL_RETURNED',
+                },
+                recipientMemberIds,
+            });
+        }
+        await activityRepository.save(activityRepository.create({
+            actorMemberId: task.assigneeMemberId,
+            eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.ADHOC_PRE_APPROVAL_RETURNED,
+            instanceId: instance.id,
+            nodeId: task.nodeId,
+            payload: {
+                comment: decisionComment,
+                directiveId: directive.id,
+                originTaskId: originTask.id,
+                rejectedAdhocTaskId: task.id,
+            },
+            taskId: task.id,
+        }));
+        return true;
+    }
+    async readOpenTaskRecipientMemberIds(manager, task) {
+        if (task.assigneeMemberId) {
+            return [task.assigneeMemberId];
+        }
+        const candidates = await manager
+            .getRepository(task_candidate_entity_1.TaskCandidateEntity)
+            .find({ where: { taskId: task.id } });
+        return uniqueTexts(candidates
+            .filter((candidate) => candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING ||
+            candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED)
+            .map((candidate) => candidate.memberId));
+    }
+    async dispatchAdhocStageNotifications(manager, instance, nodeId, outcome) {
+        const directiveRepository = manager.getRepository(adhoc_directive_entity_1.AdhocDirectiveEntity);
+        const directives = await directiveRepository.find({
+            order: { createdAt: 'ASC' },
+            where: {
+                instanceId: instance.id,
+                originNodeId: nodeId,
+                status: adhoc_enums_1.AdhocDirectiveStatusEnum.PENDING,
+                type: adhoc_enums_1.AdhocDirectiveTypeEnum.STAGE_NOTIFY,
+            },
+        });
+        if (directives.length === 0) {
+            return;
+        }
+        const node = readWorkflowNodeOrThrow(instance.workflowSnapshot, nodeId);
+        const nodeLabel = node.data.label;
+        const outcomeLabel = readAdhocStageOutcomeLabel(outcome);
+        const consumedAt = new Date();
+        await directives.reduce(async (previous, directive) => {
+            await previous;
+            await this.dispatchAdhocDirectiveNotification(manager, instance, directive, `案件「${instance.title}」的階段「${nodeLabel}」已${outcomeLabel}。`, {
+                nodeId,
+                nodeLabel,
+                outcome,
+                type: adhoc_enums_1.AdhocDirectiveTypeEnum.STAGE_NOTIFY,
+            });
+            await directiveRepository.save({
+                ...directive,
+                consumedAt,
+                status: adhoc_enums_1.AdhocDirectiveStatusEnum.CONSUMED,
+            });
+        }, Promise.resolve());
+    }
+    async dispatchAdhocCompletionNotifications(manager, instance, finalState) {
+        const directiveRepository = manager.getRepository(adhoc_directive_entity_1.AdhocDirectiveEntity);
+        const directives = await directiveRepository.find({
+            order: { createdAt: 'ASC' },
+            where: {
+                instanceId: instance.id,
+                status: adhoc_enums_1.AdhocDirectiveStatusEnum.PENDING,
+                type: adhoc_enums_1.AdhocDirectiveTypeEnum.COMPLETION_NOTIFY,
+            },
+        });
+        if (directives.length === 0) {
+            return;
+        }
+        const finalStateLabel = readInstanceFinalStateLabel(finalState);
+        const consumedAt = new Date();
+        await directives.reduce(async (previous, directive) => {
+            await previous;
+            await this.dispatchAdhocDirectiveNotification(manager, instance, directive, `案件「${instance.title}」已結案（${finalStateLabel}）。`, {
+                finalState,
+                type: adhoc_enums_1.AdhocDirectiveTypeEnum.COMPLETION_NOTIFY,
+            });
+            await directiveRepository.save({
+                ...directive,
+                consumedAt,
+                status: adhoc_enums_1.AdhocDirectiveStatusEnum.CONSUMED,
+            });
+        }, Promise.resolve());
+    }
+    async dispatchAdhocDirectiveNotification(manager, instance, directive, message, payload) {
+        const targetValue = readAdhocTargetValue(directive);
+        const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+        if (targetValue.kind === adhoc_enums_1.AdhocTargetKindEnum.WEBHOOK) {
+            const result = await executeAdhocWebhookDispatch(this.serviceTaskDispatcher, targetValue, {
+                ...payload,
+                instanceId: instance.id,
+                instanceTitle: instance.title,
+                message,
+                triggeredAt: new Date().toISOString(),
+            });
+            await activityRepository.save(activityRepository.create({
+                actorMemberId: null,
+                eventType: result.ok
+                    ? workflow_engine_enums_1.ActivityLogEventTypeEnum.SERVICE_TASK_EXECUTED
+                    : workflow_engine_enums_1.ActivityLogEventTypeEnum.SERVICE_TASK_FAILED,
+                instanceId: instance.id,
+                nodeId: directive.originNodeId,
+                payload: {
+                    action: 'ADHOC_WEBHOOK',
+                    directiveId: directive.id,
+                    error: result.error,
+                    ok: result.ok,
+                    status: result.status,
+                    url: targetValue.webhookUrl,
+                },
+                taskId: null,
+            }));
+            return;
+        }
+        try {
+            const recipients = await this.resolveApproverResolver(manager, instance, buildAdhocApproverResolver(targetValue), '臨時通知對象');
+            await this.notificationService.createAdhocWorkflowNotifications({
+                channels: directive.channels,
+                instance,
+                manager,
+                message,
+                payload: { ...payload, directiveId: directive.id },
+                recipientMemberIds: recipients.map((recipient) => recipient.memberId),
+            });
+        }
+        catch (error) {
+            // Notification target resolution must never block the workflow
+            // transition that triggered it — record the failure instead.
+            await activityRepository.save(activityRepository.create({
+                actorMemberId: null,
+                eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.SERVICE_TASK_FAILED,
+                instanceId: instance.id,
+                nodeId: directive.originNodeId,
+                payload: {
+                    action: 'ADHOC_NOTIFY',
+                    directiveId: directive.id,
+                    error: error instanceof Error
+                        ? error.message
+                        : 'Ad-hoc notification dispatch failed',
+                },
+                taskId: null,
+            }));
+        }
+    }
+    async cancelPendingAdhocDirectives(manager, instanceId, types) {
+        const directiveRepository = manager.getRepository(adhoc_directive_entity_1.AdhocDirectiveEntity);
+        const directives = await directiveRepository.find({
+            where: {
+                instanceId,
+                status: adhoc_enums_1.AdhocDirectiveStatusEnum.PENDING,
+                ...(types ? { type: (0, typeorm_2.In)([...types]) } : {}),
+            },
+        });
+        if (directives.length === 0) {
+            return;
+        }
+        await directiveRepository.save(directives.map((directive) => ({
+            ...directive,
+            status: adhoc_enums_1.AdhocDirectiveStatusEnum.CANCELLED,
+        })));
+    }
     dryRunApprovalWorkflow(input) {
         const workflowDefinition = parseWorkflowDefinition(input.workflowDefinitionJson);
         const formData = parseJsonObject(input.formDataJson, 'formDataJson');
@@ -966,7 +1531,16 @@ let WorkflowEngineService = class WorkflowEngineService {
         const decisions = await this.taskDecisionRepository.find({
             where: { taskId: (0, typeorm_2.In)(taskIds) },
         });
-        return decisions.some((decision) => decision.decidedByMemberId === memberId);
+        if (decisions.some((decision) => decision.decidedByMemberId === memberId)) {
+            return true;
+        }
+        // Members who received any notification for this instance (e.g. ad-hoc
+        // stage / completion notify recipients, CC'd service-task recipients) may
+        // open the instance they were notified about.
+        const notification = await this.notificationRepository.findOne({
+            where: { instanceId: instance.id, recipientMemberId: memberId },
+        });
+        return Boolean(notification);
     }
     async processActiveToken(manager, instance, token) {
         const node = readWorkflowNodeOrThrow(instance.workflowSnapshot, token.currentNodeId);
@@ -1047,6 +1621,8 @@ let WorkflowEngineService = class WorkflowEngineService {
             instance: completedInstance,
             manager,
         });
+        await this.dispatchAdhocCompletionNotifications(manager, completedInstance, workflow_engine_enums_1.ApprovalInstanceStateEnum.APPROVED);
+        await this.cancelPendingAdhocDirectives(manager, instance.id, null);
     }
     async isNodeEntryReady(manager, instance, token, node) {
         if (node.type === 'startEvent') {
@@ -1281,6 +1857,8 @@ let WorkflowEngineService = class WorkflowEngineService {
                     manager,
                 });
             }
+            await this.dispatchAdhocCompletionNotifications(manager, completedInstance, instanceState);
+            await this.cancelPendingAdhocDirectives(manager, instance.id, null);
         }
         await activityRepository.save(activityRepository.create({
             actorMemberId: null,
@@ -1302,6 +1880,7 @@ let WorkflowEngineService = class WorkflowEngineService {
         const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
         const existingTask = await taskRepository.findOne({
             where: {
+                isAdhoc: false,
                 nodeId: node.id,
                 tokenId: token.id,
             },
@@ -1377,6 +1956,9 @@ let WorkflowEngineService = class WorkflowEngineService {
                 }),
             });
         }, Promise.resolve());
+        // Pending ad-hoc countersign directives attach to the next user task
+        // created after they were requested — spawn their parallel tasks now.
+        await this.spawnCountersignTasksForNode(manager, instance, token, node, now);
     }
     async markTaskCandidateDecision({ action, candidate, candidates, decidedAt, manager, task, }) {
         const taskCandidateRepository = manager.getRepository(task_candidate_entity_1.TaskCandidateEntity);
@@ -1530,12 +2112,19 @@ let WorkflowEngineService = class WorkflowEngineService {
     }
     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`);
+        }
+        return uniqueCandidates;
+    }
+    async applyDelegationToResolvedCandidates(instance, nodeId, resolvedCandidates) {
         const context = {
             formData: instance.formData,
             initiatorMemberId: instance.initiatorMemberId,
             initiatorMetadataSnapshot: instance.initiatorMetadataSnapshot,
             instanceId: instance.id,
-            nodeId: node.id,
+            nodeId,
             state: instance.state,
             templateId: instance.templateId,
             templateVersionId: instance.templateVersionId,
@@ -1550,11 +2139,7 @@ let WorkflowEngineService = class WorkflowEngineService {
                 sourceType: candidate.sourceType,
             };
         }));
-        const uniqueCandidates = uniqueRuntimeCandidates(delegatedCandidates);
-        if (uniqueCandidates.length === 0) {
-            throw new common_1.ConflictException(`簽核節點「${node.data.label}」 did not resolve to any member id`);
-        }
-        return uniqueCandidates;
+        return uniqueRuntimeCandidates(delegatedCandidates);
     }
     async resolveApproverResolver(manager, instance, resolver, label) {
         if (resolver.type === 'DIRECT') {
@@ -1851,27 +2436,25 @@ let WorkflowEngineService = class WorkflowEngineService {
         }));
     }
     async rejectInstance(manager, instance, task, rejectedAt) {
-        const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
         const instanceRepository = manager.getRepository(approval_instance_entity_1.ApprovalInstanceEntity);
-        const activeTokens = await tokenRepository.find({
-            where: { instanceId: instance.id },
+        // Dispatch pending ad-hoc notifications for the rejecting node before the
+        // remaining directives are cancelled by the terminal cleanup below.
+        await this.dispatchAdhocStageNotifications(manager, instance, task.nodeId, 'REJECTED');
+        // Consume open tokens and cancel any still-open tasks (parallel branches,
+        // ad-hoc countersign / pre-approval tasks) so nothing actionable lingers
+        // on a rejected instance.
+        await this.consumeOpenRuntimeState(manager, instance, rejectedAt, workflow_engine_enums_1.TaskStatusEnum.CANCELLED);
+        await this.notificationService.supersedeInstanceTaskNotifications({
+            instanceId: instance.id,
+            manager,
         });
-        const consumedTokens = activeTokens
-            .filter((token) => token.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.ACTIVE ||
-            token.status === workflow_engine_enums_1.WorkflowTokenStatusEnum.WAITING)
-            .map((token) => ({
-            ...token,
-            consumedAt: rejectedAt,
-            status: workflow_engine_enums_1.WorkflowTokenStatusEnum.CONSUMED,
-        }));
-        if (consumedTokens.length) {
-            await tokenRepository.save(consumedTokens);
-        }
-        await instanceRepository.save({
+        const rejectedInstance = await instanceRepository.save({
             ...instance,
             completedAt: rejectedAt,
             state: workflow_engine_enums_1.ApprovalInstanceStateEnum.REJECTED,
         });
+        await this.dispatchAdhocCompletionNotifications(manager, rejectedInstance, workflow_engine_enums_1.ApprovalInstanceStateEnum.REJECTED);
+        await this.cancelPendingAdhocDirectives(manager, instance.id, null);
         await manager.getRepository(activity_log_entity_1.ActivityLogEntity).save(manager.getRepository(activity_log_entity_1.ActivityLogEntity).create({
             actorMemberId: task.assigneeMemberId,
             eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.TOKEN_ADVANCED,
@@ -1892,6 +2475,14 @@ let WorkflowEngineService = class WorkflowEngineService {
         const tokenRepository = manager.getRepository(workflow_token_entity_1.WorkflowTokenEntity);
         const instanceRepository = manager.getRepository(approval_instance_entity_1.ApprovalInstanceEntity);
         const activityRepository = manager.getRepository(activity_log_entity_1.ActivityLogEntity);
+        // The returning node's stage has ended (outcome: RETURNED) — dispatch its
+        // pending ad-hoc stage notifications, then drop flow-affecting ad-hoc
+        // directives so they cannot replay after the return/resubmit cycle.
+        await this.dispatchAdhocStageNotifications(manager, instance, task.nodeId, 'RETURNED');
+        await this.cancelPendingAdhocDirectives(manager, instance.id, [
+            adhoc_enums_1.AdhocDirectiveTypeEnum.COUNTERSIGN,
+            adhoc_enums_1.AdhocDirectiveTypeEnum.PRE_APPROVAL,
+        ]);
         await this.consumeOpenRuntimeState(manager, instance, returnedAt, workflow_engine_enums_1.TaskStatusEnum.CANCELLED);
         const returnedInstance = await instanceRepository.save({
             ...instance,
@@ -2121,11 +2712,12 @@ exports.WorkflowEngineService = WorkflowEngineService = tslib_1.__decorate([
     tslib_1.__param(4, (0, typeorm_1.InjectRepository)(task_decision_entity_1.TaskDecisionEntity)),
     tslib_1.__param(5, (0, typeorm_1.InjectRepository)(notification_entity_1.NotificationEntity)),
     tslib_1.__param(6, (0, typeorm_1.InjectRepository)(activity_log_entity_1.ActivityLogEntity)),
-    tslib_1.__param(7, (0, typeorm_1.InjectRepository)(approval_template_entity_1.ApprovalTemplateEntity)),
-    tslib_1.__param(8, (0, typeorm_1.InjectRepository)(approval_template_version_entity_1.ApprovalTemplateVersionEntity)),
-    tslib_1.__param(9, (0, typeorm_1.InjectRepository)(form_definition_version_entity_1.FormDefinitionVersionEntity)),
-    tslib_1.__param(15, (0, common_1.Optional)()),
-    tslib_1.__param(15, (0, common_1.Inject)(workflow_service_task_dispatcher_token_1.BPM_WORKFLOW_SERVICE_TASK_DISPATCHER)),
+    tslib_1.__param(7, (0, typeorm_1.InjectRepository)(adhoc_directive_entity_1.AdhocDirectiveEntity)),
+    tslib_1.__param(8, (0, typeorm_1.InjectRepository)(approval_template_entity_1.ApprovalTemplateEntity)),
+    tslib_1.__param(9, (0, typeorm_1.InjectRepository)(approval_template_version_entity_1.ApprovalTemplateVersionEntity)),
+    tslib_1.__param(10, (0, typeorm_1.InjectRepository)(form_definition_version_entity_1.FormDefinitionVersionEntity)),
+    tslib_1.__param(16, (0, common_1.Optional)()),
+    tslib_1.__param(16, (0, common_1.Inject)(workflow_service_task_dispatcher_token_1.BPM_WORKFLOW_SERVICE_TASK_DISPATCHER)),
     tslib_1.__metadata("design:paramtypes", [typeorm_2.Repository,
         typeorm_2.Repository,
         typeorm_2.Repository,
@@ -2136,6 +2728,7 @@ exports.WorkflowEngineService = WorkflowEngineService = tslib_1.__decorate([
         typeorm_2.Repository,
         typeorm_2.Repository,
         typeorm_2.Repository,
+        typeorm_2.Repository,
         attachment_service_1.AttachmentService,
         condition_service_1.ConditionService,
         delegation_service_1.DelegationService,
@@ -2540,6 +3133,152 @@ async function executeWebhookServiceAction(serviceTaskDispatcher, action, payloa
         };
     }
 }
+async function executeAdhocWebhookDispatch(serviceTaskDispatcher, target, payload) {
+    if (!target.webhookUrl) {
+        return { error: 'Webhook URL is missing', ok: false, status: null };
+    }
+    try {
+        return await serviceTaskDispatcher.dispatchWebhook({
+            headers: target.webhookHeaders,
+            payload,
+            url: target.webhookUrl,
+        });
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : 'Unknown webhook error',
+            ok: false,
+            status: null,
+        };
+    }
+}
+function buildAdhocTargetValue(input) {
+    if (input.kind === adhoc_enums_1.AdhocTargetKindEnum.MEMBER) {
+        const memberIds = uniqueTexts([...(input.memberIds ?? [])]);
+        if (memberIds.length === 0) {
+            throw new common_1.BadRequestException('memberIds is required for a MEMBER ad-hoc target');
+        }
+        return { kind: input.kind, memberIds };
+    }
+    if (input.kind === adhoc_enums_1.AdhocTargetKindEnum.POSITION) {
+        const positionId = input.positionId?.trim();
+        if (!positionId) {
+            throw new common_1.BadRequestException('positionId is required for a POSITION ad-hoc target');
+        }
+        return { kind: input.kind, positionId };
+    }
+    if (input.kind === adhoc_enums_1.AdhocTargetKindEnum.ORG_UNIT_MEMBER) {
+        const orgUnitId = input.orgUnitId?.trim();
+        if (!orgUnitId) {
+            throw new common_1.BadRequestException('orgUnitId is required for an ORG_UNIT_MEMBER ad-hoc target');
+        }
+        return {
+            includeDescendants: Boolean(input.includeDescendants),
+            kind: input.kind,
+            orgUnitId,
+        };
+    }
+    const webhookUrl = input.webhookUrl?.trim();
+    if (!webhookUrl) {
+        throw new common_1.BadRequestException('webhookUrl is required for a WEBHOOK ad-hoc target');
+    }
+    return {
+        kind: input.kind,
+        webhookHeaders: input.webhookHeadersJson
+            ? parseAdhocWebhookHeaders(input.webhookHeadersJson)
+            : undefined,
+        webhookUrl,
+    };
+}
+function parseAdhocWebhookHeaders(json) {
+    try {
+        const parsed = JSON.parse(json);
+        if (!isRecord(parsed)) {
+            throw new common_1.BadRequestException('webhookHeadersJson must be a JSON object of string values');
+        }
+        return Object.entries(parsed).reduce((accumulator, [key, value]) => ({
+            ...accumulator,
+            ...(typeof value === 'string' ? { [key]: value } : {}),
+        }), {});
+    }
+    catch (error) {
+        if (error instanceof common_1.BadRequestException) {
+            throw error;
+        }
+        throw new common_1.BadRequestException('webhookHeadersJson is not valid JSON');
+    }
+}
+function readAdhocTargetValue(directive) {
+    const value = directive.targetValue;
+    const kind = directive.targetKind;
+    if (kind === adhoc_enums_1.AdhocTargetKindEnum.MEMBER) {
+        return {
+            kind,
+            memberIds: Array.isArray(value.memberIds)
+                ? value.memberIds.filter((memberId) => typeof memberId === 'string')
+                : [],
+        };
+    }
+    if (kind === adhoc_enums_1.AdhocTargetKindEnum.POSITION) {
+        return {
+            kind,
+            positionId: typeof value.positionId === 'string' ? value.positionId : '',
+        };
+    }
+    if (kind === adhoc_enums_1.AdhocTargetKindEnum.ORG_UNIT_MEMBER) {
+        return {
+            includeDescendants: Boolean(value.includeDescendants),
+            kind,
+            orgUnitId: typeof value.orgUnitId === 'string' ? value.orgUnitId : '',
+        };
+    }
+    return {
+        kind,
+        webhookHeaders: isRecord(value.webhookHeaders)
+            ? Object.entries(value.webhookHeaders).reduce((accumulator, [key, headerValue]) => ({
+                ...accumulator,
+                ...(typeof headerValue === 'string'
+                    ? { [key]: headerValue }
+                    : {}),
+            }), {})
+            : undefined,
+        webhookUrl: typeof value.webhookUrl === 'string' ? value.webhookUrl : '',
+    };
+}
+function buildAdhocApproverResolver(target) {
+    if (target.kind === adhoc_enums_1.AdhocTargetKindEnum.MEMBER) {
+        return { memberIds: target.memberIds ?? [], type: 'DIRECT' };
+    }
+    if (target.kind === adhoc_enums_1.AdhocTargetKindEnum.POSITION) {
+        return { positionId: target.positionId ?? '', type: 'POSITION' };
+    }
+    if (target.kind === adhoc_enums_1.AdhocTargetKindEnum.ORG_UNIT_MEMBER) {
+        return {
+            includeDescendants: target.includeDescendants,
+            orgUnitId: target.orgUnitId ?? '',
+            type: 'ORG_UNIT_MEMBER',
+        };
+    }
+    throw new common_1.BadRequestException('WEBHOOK ad-hoc targets cannot be used as approvers');
+}
+function readAdhocStageOutcomeLabel(outcome) {
+    if (outcome === 'APPROVED') {
+        return '通過';
+    }
+    if (outcome === 'REJECTED') {
+        return '拒絕';
+    }
+    return '退回';
+}
+function readInstanceFinalStateLabel(finalState) {
+    if (finalState === workflow_engine_enums_1.ApprovalInstanceStateEnum.APPROVED) {
+        return '核准';
+    }
+    if (finalState === workflow_engine_enums_1.ApprovalInstanceStateEnum.REJECTED) {
+        return '拒絕';
+    }
+    return '取消';
+}
 function readManagerMemberIdFromInitiatorSnapshot(initiatorMetadataSnapshot, levelsUp) {
     const managerChain = initiatorMetadataSnapshot.managerChain;
     if (Array.isArray(managerChain)) {