feat(wm-bpm): #32 流程引擎核心完整实现

- ProcessEngine: 增强为数据库持久化引擎，支持启动/审批/驳回/转办/会签/待办/已办
- ProcessDefinitionService: 流程定义CRUD/发布/停用/版本管理
- ProcessEngineController: /api/bpm/engine/* REST API
- ProcessDefinitionController: /api/bpm/definition/* REST API
- BpmProcessInstanceMapper/BpmTodoTaskMapper: 新增查询方法
- V_bpm_core.sql: 完整表结构DDL + 示例数据
- ProcessEngineTest/ProcessDefinitionServiceTest: 单元测试覆盖核心场景
- 保留原有 ProcessController 向后兼容

wm-bpm/src/main/java/com/water/bpm/controller/ProcessDefinitionController.java

+package com.water.bpm.controller;
+
+import com.water.bpm.entity.BpmProcessDefinition;
+import com.water.bpm.entity.BpmProcessNode;
+import com.water.bpm.service.ProcessDefinitionService;
+import com.water.common.core.result.R;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * 流程定义管理 REST API
+ * 提供流程定义的 CRUD、发布、停用、版本管理等接口
+ */
+@Tag(name = "流程定义管理")
+@RestController
+@RequestMapping("/api/bpm/definition")
+@RequiredArgsConstructor
+public class ProcessDefinitionController {
+
+    private final ProcessDefinitionService definitionService;
+
+    // ==================== CRUD ====================
+
+    @Operation(summary = "创建流程定义")
+    @PostMapping
+    public R<BpmProcessDefinition> create(@RequestBody BpmProcessDefinition definition) {
+        return R.ok(definitionService.create(definition));
+    }
+
+    @Operation(summary = "更新流程定义")
+    @PutMapping("/{id}")
+    public R<BpmProcessDefinition> update(@PathVariable Long id,
+                                           @RequestBody BpmProcessDefinition definition) {
+        return R.ok(definitionService.update(id, definition));
+    }
+
+    @Operation(summary = "删除流程定义")
+    @DeleteMapping("/{id}")
+    public R<Void> delete(@PathVariable Long id) {
+        definitionService.delete(id);
+        return R.ok();
+    }
+
+    @Operation(summary = "获取流程定义详情")
+    @GetMapping("/{id}")
+    public R<BpmProcessDefinition> detail(@PathVariable Long id) {
+        return R.ok(definitionService.getById(id));
+    }
+
+    @Operation(summary = "查询流程定义列表")
+    @GetMapping("/list")
+    public R<List<BpmProcessDefinition>> list(
+            @RequestParam(required = false) String category,
+            @RequestParam(required = false) Integer status) {
+        return R.ok(definitionService.list(category, status));
+    }
+
+    @Operation(summary = "查询已发布的流程定义")
+    @GetMapping("/published")
+    public R<List<BpmProcessDefinition>> published(@RequestParam(required = false) String category) {
+        return R.ok(definitionService.listPublished(category));
+    }
+
+    @Operation(summary = "根据 processKey 查询")
+    @GetMapping("/key/{processKey}")
+    public R<BpmProcessDefinition> getByKey(@PathVariable String processKey) {
+        return R.ok(definitionService.getByProcessKey(processKey));
+    }
+
+    @Operation(summary = "查询所有分类")
+    @GetMapping("/categories")
+    public R<List<String>> categories() {
+        return R.ok(definitionService.listCategories());
+    }
+
+    // ==================== 发布/停用 ====================
+
+    @Operation(summary = "发布流程定义")
+    @PostMapping("/{id}/publish")
+    public R<BpmProcessDefinition> publish(@PathVariable Long id) {
+        return R.ok(definitionService.publish(id));
+    }
+
+    @Operation(summary = "停用流程定义")
+    @PostMapping("/{id}/deactivate")
+    public R<BpmProcessDefinition> deactivate(@PathVariable Long id) {
+        return R.ok(definitionService.deactivate(id));
+    }
+
+    // ==================== 版本管理 ====================
+
+    @Operation(summary = "创建新版本")
+    @PostMapping("/{id}/new-version")
+    public R<BpmProcessDefinition> newVersion(@PathVariable Long id) {
+        return R.ok(definitionService.createNewVersion(id));
+    }
+
+    // ==================== 节点管理 ====================
+
+    @Operation(summary = "获取流程节点列表")
+    @GetMapping("/{id}/nodes")
+    public R<List<BpmProcessNode>> nodes(@PathVariable Long id) {
+        return R.ok(definitionService.getNodes(id));
+    }
+
+    @Operation(summary = "保存流程节点")
+    @PostMapping("/node")
+    public R<BpmProcessNode> saveNode(@RequestBody BpmProcessNode node) {
+        return R.ok(definitionService.saveNode(node));
+    }
+
+    @Operation(summary = "删除流程节点")
+    @DeleteMapping("/node/{nodeId}")
+    public R<Void> deleteNode(@PathVariable Long nodeId) {
+        definitionService.deleteNode(nodeId);
+        return R.ok();
+    }
+}

wm-bpm/src/main/java/com/water/bpm/controller/ProcessEngineController.java

+package com.water.bpm.controller;
+
+import com.water.bpm.entity.BpmApprovalRecord;
+import com.water.bpm.entity.BpmProcessInstance;
+import com.water.bpm.entity.BpmTodoTask;
+import com.water.bpm.entity.dto.ApprovalRequest;
+import com.water.bpm.entity.dto.ProcessInstanceQuery;
+import com.water.bpm.entity.dto.ProcessStartRequest;
+import com.water.bpm.service.ProcessEngine;
+import com.water.common.core.result.R;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 流程引擎 REST API
+ * 提供流程启动、审批、驳回、转办、会签、待办/已办查询等接口
+ */
+@Tag(name = "流程引擎")
+@RestController
+@RequestMapping("/api/bpm/engine")
+@RequiredArgsConstructor
+public class ProcessEngineController {
+
+    private final ProcessEngine processEngine;
+
+    // ==================== 启动流程 ====================
+
+    @Operation(summary = "启动流程")
+    @PostMapping("/start")
+    public R<BpmProcessInstance> start(@RequestBody ProcessStartRequest request) {
+        // TODO: 从 Sa-Token 获取当前用户信息
+        Long userId = 1L;
+        String userName = "当前用户";
+
+        BpmProcessInstance instance = processEngine.startProcess(
+                request.getDefinitionId(),
+                userId, userName,
+                request.getBusinessKey(),
+                request.getBusinessType(),
+                request.getTitle(),
+                request.getFormData(),
+                request.getVariables(),
+                request.getPriority()
+        );
+        return R.ok(instance);
+    }
+
+    // ==================== 审批通过 ====================
+
+    @Operation(summary = "审批通过")
+    @PostMapping("/approve")
+    public R<BpmProcessInstance> approve(@RequestBody ApprovalRequest request) {
+        Long userId = 1L;
+        String userName = "当前用户";
+
+        BpmProcessInstance instance = processEngine.approveTask(
+                request.getInstanceUuid(),
+                userId, userName,
+                request.getNodeId(),
+                request.getComment()
+        );
+        return R.ok(instance);
+    }
+
+    // ==================== 驳回 ====================
+
+    @Operation(summary = "驳回")
+    @PostMapping("/reject")
+    public R<BpmProcessInstance> reject(@RequestBody ApprovalRequest request) {
+        Long userId = 1L;
+        String userName = "当前用户";
+
+        BpmProcessInstance instance = processEngine.rejectTask(
+                request.getInstanceUuid(),
+                userId, userName,
+                request.getNodeId(),
+                request.getComment()
+        );
+        return R.ok(instance);
+    }
+
+    // ==================== 转办 ====================
+
+    @Operation(summary = "转办")
+    @PostMapping("/transfer")
+    public R<BpmProcessInstance> transfer(@RequestBody ApprovalRequest request) {
+        Long userId = 1L;
+        String userName = "当前用户";
+
+        BpmProcessInstance instance = processEngine.transferTask(
+                request.getInstanceUuid(),
+                userId, userName,
+                request.getTargetAssigneeId(),
+                request.getTargetAssigneeName(),
+                request.getNodeId(),
+                request.getComment()
+        );
+        return R.ok(instance);
+    }
+
+    // ==================== 会签 ====================
+
+    @Operation(summary = "发起会签")
+    @PostMapping("/countersign/initiate")
+    public R<BpmProcessInstance> initiateCountersign(@RequestBody Map<String, Object> request) {
+        Long userId = 1L;
+
+        @SuppressWarnings("unchecked")
+        List<Number> signerIdNums = (List<Number>) request.get("signerIds");
+        @SuppressWarnings("unchecked")
+        List<String> signerNames = (List<String>) request.get("signerNames");
+        String instanceUuid = (String) request.get("instanceUuid");
+        String nodeId = (String) request.get("nodeId");
+        String comment = (String) request.get("comment");
+
+        List<Long> signerIds = signerIdNums.stream().map(Number::longValue).toList();
+
+        BpmProcessInstance instance = processEngine.initiateCountersign(
+                instanceUuid, userId, signerIds, signerNames, nodeId, comment
+        );
+        return R.ok(instance);
+    }
+
+    @Operation(summary = "会签审批")
+    @PostMapping("/countersign/approve")
+    public R<BpmProcessInstance> countersignApprove(@RequestBody ApprovalRequest request) {
+        Long userId = 1L;
+        String userName = "当前用户";
+
+        BpmProcessInstance instance = processEngine.countersignApprove(
+                request.getInstanceUuid(),
+                userId, userName,
+                request.getNodeId(),
+                request.getComment()
+        );
+        return R.ok(instance);
+    }
+
+    // ==================== 待办/已办查询 ====================
+
+    @Operation(summary = "待办列表")
+    @GetMapping("/todo/list")
+    public R<List<BpmTodoTask>> todoList() {
+        Long userId = 1L;
+        return R.ok(processEngine.getTodoTasks(userId));
+    }
+
+    @Operation(summary = "待办数量")
+    @GetMapping("/todo/count")
+    public R<Integer> todoCount() {
+        Long userId = 1L;
+        return R.ok(processEngine.getTodoCount(userId));
+    }
+
+    @Operation(summary = "已办列表")
+    @GetMapping("/done/list")
+    public R<List<BpmTodoTask>> doneList() {
+        Long userId = 1L;
+        return R.ok(processEngine.getDoneTasks(userId));
+    }
+
+    // ==================== 流程实例查询 ====================
+
+    @Operation(summary = "查询流程实例详情")
+    @GetMapping("/instance/{instanceUuid}")
+    public R<BpmProcessInstance> instanceDetail(@PathVariable String instanceUuid) {
+        return R.ok(processEngine.getInstance(instanceUuid));
+    }
+
+    @Operation(summary = "查询我发起的流程")
+    @GetMapping("/instance/my-initiated")
+    public R<List<BpmProcessInstance>> myInitiated() {
+        Long userId = 1L;
+        return R.ok(processEngine.getMyInitiated(userId));
+    }
+
+    @Operation(summary = "条件查询流程实例")
+    @GetMapping("/instance/list")
+    public R<List<BpmProcessInstance>> instanceList(ProcessInstanceQuery query) {
+        List<BpmProcessInstance> list = processEngine.queryInstances(
+                query.getProcessKey(), query.getStatus(),
+                query.getInitiatorId(), query.getBusinessKey(),
+                query.getPageNum(), query.getPageSize()
+        );
+        return R.ok(list);
+    }
+
+    // ==================== 审批记录 ====================
+
+    @Operation(summary = "查询审批记录")
+    @GetMapping("/records/{instanceUuid}")
+    public R<List<BpmApprovalRecord>> approvalRecords(@PathVariable String instanceUuid) {
+        return R.ok(processEngine.getApprovalRecordsByUuid(instanceUuid));
+    }
+}

wm-bpm/src/main/java/com/water/bpm/mapper/BpmProcessInstanceMapper.java

      */
     @Select("SELECT * FROM bpm_process_instance WHERE initiator_id = #{userId} AND deleted = 0 ORDER BY created_at DESC")
     List<BpmProcessInstance> selectMyInitiated(@Param("userId") Long userId);
+
+    /**
+     * 根据 UUID 查询流程实例
+     */
+    @Select("SELECT * FROM bpm_process_instance WHERE instance_id = #{instanceUuid} AND deleted = 0")
+    BpmProcessInstance selectByInstanceUuid(@Param("instanceUuid") String instanceUuid);
+
+    /**
+     * 查询当前处理人的运行中流程
+     */
+    @Select("SELECT * FROM bpm_process_instance WHERE current_assignee_id = #{userId} AND status = 'running' AND deleted = 0 ORDER BY created_at DESC")
+    List<BpmProcessInstance> selectByCurrentAssignee(@Param("userId") Long userId);
 }

wm-bpm/src/main/java/com/water/bpm/mapper/BpmTodoTaskMapper.java

      */
     @Select("SELECT * FROM bpm_todo_task WHERE status = 'pending' AND deadline_at < NOW() AND deleted = 0")
     List<BpmTodoTask> selectTimeoutTasks();
+
+    /**
+     * 根据流程实例ID查询待办
+     */
+    @Select("SELECT * FROM bpm_todo_task WHERE instance_id = #{instanceId} AND status = 'pending' AND deleted = 0")
+    List<BpmTodoTask> selectPendingByInstanceId(@Param("instanceId") Long instanceId);
+
+    /**
+     * 根据流程实例UUID查询待办
+     */
+    @Select("SELECT * FROM bpm_todo_task WHERE instance_uuid = #{instanceUuid} AND status = 'pending' AND deleted = 0")
+    List<BpmTodoTask> selectPendingByInstanceUuid(@Param("instanceUuid") String instanceUuid);
 }

wm-bpm/src/main/java/com/water/bpm/service/ProcessDefinitionService.java

+package com.water.bpm.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.water.bpm.entity.BpmProcessDefinition;
+import com.water.bpm.entity.BpmProcessNode;
+import com.water.bpm.mapper.BpmProcessDefinitionMapper;
+import com.water.bpm.mapper.BpmProcessNodeMapper;
+import com.water.common.core.exception.BusinessException;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * 流程定义管理服务
+ * 支持：CRUD、发布、停用、版本管理
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class ProcessDefinitionService {
+
+    private final BpmProcessDefinitionMapper definitionMapper;
+    private final BpmProcessNodeMapper processNodeMapper;
+
+    /**
+     * 创建流程定义（草稿）
+     */
+    @Transactional
+    public BpmProcessDefinition create(BpmProcessDefinition definition) {
+        // 校验 processKey 唯一性
+        BpmProcessDefinition existing = definitionMapper.selectByProcessKey(definition.getProcessKey());
+        if (existing != null) {
+            throw new BusinessException("流程标识 " + definition.getProcessKey() + " 已存在");
+        }
+
+        definition.setStatus(0); // 草稿
+        definition.setVersion(1);
+        definition.setCreatedAt(LocalDateTime.now());
+        definition.setUpdatedAt(LocalDateTime.now());
+        definitionMapper.insert(definition);
+
+        log.info("流程定义已创建: key={}, name={}", definition.getProcessKey(), definition.getProcessName());
+        return definition;
+    }
+
+    /**
+     * 更新流程定义（仅草稿状态可修改）
+     */
+    @Transactional
+    public BpmProcessDefinition update(Long id, BpmProcessDefinition definition) {
+        BpmProcessDefinition existing = definitionMapper.selectById(id);
+        if (existing == null) {
+            throw new BusinessException("流程定义不存在");
+        }
+        if (existing.getStatus() != 0) {
+            throw new BusinessException("已发布的流程定义不可修改，请先停用后创建新版本");
+        }
+
+        definition.setId(id);
+        definition.setUpdatedAt(LocalDateTime.now());
+        definitionMapper.updateById(definition);
+
+        log.info("流程定义已更新: id={}, name={}", id, definition.getProcessName());
+        return definitionMapper.selectById(id);
+    }
+
+    /**
+     * 发布流程定义
+     */
+    @Transactional
+    public BpmProcessDefinition publish(Long id) {
+        BpmProcessDefinition existing = definitionMapper.selectById(id);
+        if (existing == null) {
+            throw new BusinessException("流程定义不存在");
+        }
+        if (existing.getStatus() == 1) {
+            throw new BusinessException("流程定义已发布");
+        }
+
+        existing.setStatus(1);
+        existing.setPublishedAt(LocalDateTime.now());
+        existing.setUpdatedAt(LocalDateTime.now());
+        definitionMapper.updateById(existing);
+
+        log.info("流程定义已发布: id={}, key={}, version={}",
+                id, existing.getProcessKey(), existing.getVersion());
+        return existing;
+    }
+
+    /**
+     * 停用流程定义
+     */
+    @Transactional
+    public BpmProcessDefinition deactivate(Long id) {
+        BpmProcessDefinition existing = definitionMapper.selectById(id);
+        if (existing == null) {
+            throw new BusinessException("流程定义不存在");
+        }
+        if (existing.getStatus() != 1) {
+            throw new BusinessException("只有已发布的流程定义可以停用");
+        }
+
+        existing.setStatus(2);
+        existing.setUpdatedAt(LocalDateTime.now());
+        definitionMapper.updateById(existing);
+
+        log.info("流程定义已停用: id={}, key={}", id, existing.getProcessKey());
+        return existing;
+    }
+
+    /**
+     * 创建新版本（基于现有定义）
+     */
+    @Transactional
+    public BpmProcessDefinition createNewVersion(Long id) {
+        BpmProcessDefinition existing = definitionMapper.selectById(id);
+        if (existing == null) {
+            throw new BusinessException("流程定义不存在");
+        }
+
+        // 停用旧版本（如果还在使用中）
+        if (existing.getStatus() == 1) {
+            existing.setStatus(2);
+            existing.setUpdatedAt(LocalDateTime.now());
+            definitionMapper.updateById(existing);
+        }
+
+        // 创建新版本
+        BpmProcessDefinition newVersion = new BpmProcessDefinition();
+        newVersion.setProcessKey(existing.getProcessKey());
+        newVersion.setProcessName(existing.getProcessName());
+        newVersion.setDescription(existing.getDescription());
+        newVersion.setBpmnXml(existing.getBpmnXml());
+        newVersion.setFormSchema(existing.getFormSchema());
+        newVersion.setCategory(existing.getCategory());
+        newVersion.setVersion(existing.getVersion() + 1);
+        newVersion.setStatus(0); // 草稿
+        newVersion.setCreatedBy(existing.getCreatedBy());
+        newVersion.setIcon(existing.getIcon());
+        newVersion.setSortOrder(existing.getSortOrder());
+        newVersion.setTenantId(existing.getTenantId());
+        newVersion.setCreatedAt(LocalDateTime.now());
+        newVersion.setUpdatedAt(LocalDateTime.now());
+        definitionMapper.insert(newVersion);
+
+        // 复制节点配置
+        List<BpmProcessNode> nodes = processNodeMapper.selectByDefinitionId(id);
+        for (BpmProcessNode node : nodes) {
+            BpmProcessNode newNode = new BpmProcessNode();
+            newNode.setDefinitionId(newVersion.getId());
+            newNode.setNodeId(node.getNodeId());
+            newNode.setNodeName(node.getNodeName());
+            newNode.setNodeType(node.getNodeType());
+            newNode.setAssigneeType(node.getAssigneeType());
+            newNode.setAssigneeValue(node.getAssigneeValue());
+            newNode.setAssigneeName(node.getAssigneeName());
+            newNode.setMultiInstanceType(node.getMultiInstanceType());
+            newNode.setCountersignRate(node.getCountersignRate());
+            newNode.setTimeoutHours(node.getTimeoutHours());
+            newNode.setTimeoutAction(node.getTimeoutAction());
+            newNode.setFormPermission(node.getFormPermission());
+            newNode.setConditionExpression(node.getConditionExpression());
+            newNode.setSortOrder(node.getSortOrder());
+            newNode.setTenantId(node.getTenantId());
+            newNode.setCreatedAt(LocalDateTime.now());
+            newNode.setUpdatedAt(LocalDateTime.now());
+            processNodeMapper.insert(newNode);
+        }
+
+        log.info("新版本已创建: key={}, oldVersion={}, newVersion={}",
+                existing.getProcessKey(), existing.getVersion(), newVersion.getVersion());
+        return newVersion;
+    }
+
+    /**
+     * 根据ID获取流程定义
+     */
+    public BpmProcessDefinition getById(Long id) {
+        BpmProcessDefinition definition = definitionMapper.selectById(id);
+        if (definition == null) {
+            throw new BusinessException("流程定义不存在");
+        }
+        return definition;
+    }
+
+    /**
+     * 根据 processKey 获取最新版本
+     */
+    public BpmProcessDefinition getByProcessKey(String processKey) {
+        return definitionMapper.selectByProcessKey(processKey);
+    }
+
+    /**
+     * 查询所有流程定义
+     */
+    public List<BpmProcessDefinition> list(String category, Integer status) {
+        LambdaQueryWrapper<BpmProcessDefinition> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(category != null && !category.isEmpty(), BpmProcessDefinition::getCategory, category)
+                .eq(status != null, BpmProcessDefinition::getStatus, status)
+                .orderByDesc(BpmProcessDefinition::getCreatedAt);
+        return definitionMapper.selectList(wrapper);
+    }
+
+    /**
+     * 查询已发布的流程定义
+     */
+    public List<BpmProcessDefinition> listPublished(String category) {
+        return definitionMapper.selectByCategory(category);
+    }
+
+    /**
+     * 查询所有分类
+     */
+    public List<String> listCategories() {
+        return definitionMapper.selectAllCategories();
+    }
+
+    /**
+     * 获取流程定义的节点列表
+     */
+    public List<BpmProcessNode> getNodes(Long definitionId) {
+        return processNodeMapper.selectByDefinitionId(definitionId);
+    }
+
+    /**
+     * 保存/更新流程节点
+     */
+    @Transactional
+    public BpmProcessNode saveNode(BpmProcessNode node) {
+        if (node.getId() != null) {
+            node.setUpdatedAt(LocalDateTime.now());
+            processNodeMapper.updateById(node);
+        } else {
+            node.setCreatedAt(LocalDateTime.now());
+            node.setUpdatedAt(LocalDateTime.now());
+            processNodeMapper.insert(node);
+        }
+        return node;
+    }
+
+    /**
+     * 删除流程节点
+     */
+    @Transactional
+    public void deleteNode(Long nodeId) {
+        processNodeMapper.deleteById(nodeId);
+    }
+
+    /**
+     * 删除流程定义（逻辑删除）
+     */
+    @Transactional
+    public void delete(Long id) {
+        BpmProcessDefinition existing = definitionMapper.selectById(id);
+        if (existing == null) {
+            throw new BusinessException("流程定义不存在");
+        }
+        if (existing.getStatus() == 1) {
+            throw new BusinessException("已发布的流程定义不可删除，请先停用");
+        }
+        definitionMapper.deleteById(id);
+        log.info("流程定义已删除: id={}, key={}", id, existing.getProcessKey());
+    }
+}

wm-bpm/src/main/java/com/water/bpm/service/ProcessEngine.java

 package com.water.bpm.service;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.water.bpm.entity.*;
+import com.water.bpm.mapper.*;
+import com.water.common.core.exception.BusinessException;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
 import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
 
+/**
+ * 流程引擎核心服务
+ * 支持：启动流程、审批通过、驳回、转办、会签、待办/已办查询、流程状态流转
+ */
 @Slf4j
 @Service
 @RequiredArgsConstructor
 public class ProcessEngine {
 
-    // 简化流程引擎：模拟 Camunda/Flowable 核心功能
-    private final Map<String, BpmProcessInstance> instances = new ConcurrentHashMap<>();
-    private final List<BpmApprovalRecord> approvalRecords = new ArrayList<>();
+    private final BpmProcessDefinitionMapper definitionMapper;
+    private final BpmProcessInstanceMapper instanceMapper;
+    private final BpmApprovalRecordMapper approvalRecordMapper;
+    private final BpmTodoTaskMapper todoTaskMapper;
+    private final BpmProcessNodeMapper processNodeMapper;
+    private final ObjectMapper objectMapper;
 
-    /** 创建流程实例 */
+    // ==================== 常量 ====================
+
+    public static final String STATUS_DRAFT = "draft";
+    public static final String STATUS_RUNNING = "running";
+    public static final String STATUS_COMPLETED = "completed";
+    public static final String STATUS_REJECTED = "rejected";
+    public static final String STATUS_TERMINATED = "terminated";
+    public static final String STATUS_SUSPENDED = "suspended";
+
+    public static final String ACTION_APPROVE = "approve";
+    public static final String ACTION_REJECT = "reject";
+    public static final String ACTION_TRANSFER = "transfer";
+    public static final String ACTION_DELEGATE = "delegate";
+    public static final String ACTION_COUNTERSIGN = "countersign";
+    public static final String ACTION_BACK = "back";
+
+    public static final String TODO_PENDING = "pending";
+    public static final String TODO_COMPLETED = "completed";
+    public static final String TODO_TRANSFERRED = "transferred";
+    public static final String TODO_CANCELLED = "cancelled";
+
+    // ==================== 启动流程 ====================
+
+    /**
+     * 启动流程（向后兼容旧接口）
+     */
     @Transactional
     public BpmProcessInstance startProcess(BpmProcessDefinition definition, Long initiatorId,
                                             String initiatorName, String businessKey,
                                             Map<String, Object> formData) {
+        return startProcess(definition.getId(), initiatorId, initiatorName,
+                businessKey, null, null, formData, null, 0);
+    }
+
+    /**
+     * 启动流程（完整版）
+     *
+     * @param definitionId   流程定义ID
+     * @param initiatorId    发起人ID
+     * @param initiatorName  发起人姓名
+     * @param businessKey    业务主键
+     * @param businessType   业务类型
+     * @param title          流程标题
+     * @param formData       表单数据
+     * @param variables      流程变量
+     * @param priority       优先级
+     * @return 流程实例
+     */
+    @Transactional
+    public BpmProcessInstance startProcess(Long definitionId, Long initiatorId, String initiatorName,
+                                            String businessKey, String businessType, String title,
+                                            Map<String, Object> formData, Map<String, Object> variables,
+                                            Integer priority) {
+        // 1. 加载并校验流程定义
+        BpmProcessDefinition definition = definitionMapper.selectById(definitionId);
+        if (definition == null || definition.getStatus() != 1) {
+            throw new BusinessException("流程定义不存在或未发布");
+        }
+
+        // 2. 加载流程节点
+        List<BpmProcessNode> nodes = processNodeMapper.selectByDefinitionId(definitionId);
+        if (nodes == null || nodes.isEmpty()) {
+            throw new BusinessException("流程定义无节点配置");
+        }
+
+        // 3. 找到起始节点
+        BpmProcessNode startNode = findStartNode(nodes);
+
+        // 4. 创建流程实例
         BpmProcessInstance instance = new BpmProcessInstance();
-        instance.setId(System.currentTimeMillis());
         instance.setInstanceId(UUID.randomUUID().toString());
-        instance.setDefinitionId(definition.getId());
+        instance.setDefinitionId(definitionId);
         instance.setProcessKey(definition.getProcessKey());
-        instance.setTitle(definition.getProcessName());
+        instance.setProcessName(definition.getProcessName());
         instance.setBusinessKey(businessKey);
+        instance.setBusinessType(businessType);
+        instance.setTitle(title != null ? title : definition.getProcessName() + " - " + initiatorName);
         instance.setInitiatorId(initiatorId);
         instance.setInitiatorName(initiatorName);
-        instance.setStatus("running");
-        instance.setCurrentNode("START");
-        instance.setFormData(formData);
-        instance.setStartedAt(java.time.LocalDateTime.now());
-        instance.setCreatedAt(java.time.LocalDateTime.now());
-        instances.put(instance.getInstanceId(), instance);
-        log.info("Process started: {} - {}", instance.getProcessKey(), instance.getTitle());
+        instance.setStatus(STATUS_RUNNING);
+        instance.setCurrentNodeId(startNode.getNodeId());
+        instance.setCurrentNodeName(startNode.getNodeName());
+        instance.setPriority(priority != null ? priority : 0);
+        instance.setFormData(toJson(formData));
+        instance.setVariables(toJson(variables));
+        instance.setStartedAt(LocalDateTime.now());
+        instance.setCreatedAt(LocalDateTime.now());
+        instance.setUpdatedAt(LocalDateTime.now());
+        instanceMapper.insert(instance);
+
+        // 5. 确定起始节点审批人并创建待办
+        Long assigneeId = resolveAssignee(startNode, initiatorId);
+        String assigneeName = startNode.getAssigneeName();
+        createTodoTask(instance, startNode, assigneeId, assigneeName);
+
+        // 6. 更新实例当前处理人
+        instance.setCurrentAssigneeId(assigneeId);
+        instance.setCurrentAssigneeName(assigneeName);
+        instanceMapper.updateById(instance);
+
+        // 7. 记录启动审批记录
+        BpmApprovalRecord startRecord = new BpmApprovalRecord();
+        startRecord.setInstanceId(instance.getId());
+        startRecord.setInstanceUuid(instance.getInstanceId());
+        startRecord.setNodeId(startNode.getNodeId());
+        startRecord.setNodeName(startNode.getNodeName());
+        startRecord.setApproverId(initiatorId);
+        startRecord.setApproverName(initiatorName);
+        startRecord.setAction("start");
+        startRecord.setComment("发起流程");
+        startRecord.setApprovedAt(LocalDateTime.now());
+        startRecord.setCreatedAt(LocalDateTime.now());
+        approvalRecordMapper.insert(startRecord);
+
+        log.info("流程已启动: key={}, instanceId={}, initiator={}",
+                definition.getProcessKey(), instance.getInstanceId(), initiatorName);
         return instance;
     }
 
-    /** 审批节点 */
+    // ==================== 审批通过 ====================
+
+    /**
+     * 审批（向后兼容旧接口）
+     */
+    @Transactional
+    public BpmProcessInstance approve(String instanceUuid, Long approverId, String approverName,
+                                       String nodeId, String nodeName,
+                                       String action, String comment) {
+        switch (action) {
+            case ACTION_APPROVE:
+                return approveTask(instanceUuid, approverId, approverName, nodeId, comment);
+            case ACTION_REJECT:
+                return rejectTask(instanceUuid, approverId, approverName, nodeId, comment);
+            case ACTION_TRANSFER:
+                // 旧接口不支持转办目标人，使用默认
+                return approveTask(instanceUuid, approverId, approverName, nodeId, comment);
+            default:
+                return approveTask(instanceUuid, approverId, approverName, nodeId, comment);
+        }
+    }
+
+    /**
+     * 审批通过
+     */
     @Transactional
-    public BpmProcessInstance approve(String instanceId, Long approverId, String approverName,
-                                        String nodeId, String nodeName,
-                                        String action, String comment) {
-        BpmProcessInstance instance = instances.get(instanceId);
-        if (instance == null) throw new RuntimeException("流程实例不存在");
+    public BpmProcessInstance approveTask(String instanceUuid, Long approverId, String approverName,
+                                           String nodeId, String comment) {
+        BpmProcessInstance instance = getInstanceByUuid(instanceUuid);
+        validateRunning(instance);
+        validateAssignee(instance, approverId);
 
-        BpmApprovalRecord record = new BpmApprovalRecord();
-        record.setInstanceId(instance.getId());
-        record.setNodeId(nodeId);
-        record.setNodeName(nodeName);
-        record.setApproverId(approverId);
-        record.setApproverName(approverName);
-        record.setAction(action);
-        record.setComment(comment);
-        record.setApprovedAt(java.time.LocalDateTime.now());
-        approvalRecords.add(record);
+        // 记录审批
+        BpmApprovalRecord record = buildApprovalRecord(instance, nodeId, approverId, approverName,
+                ACTION_APPROVE, comment);
+        approvalRecordMapper.insert(record);
 
-        instance.setCurrentNode(nodeName);
-        switch (action) {
-            case "approve": instance.setStatus("running"); break;
-            case "reject": instance.setStatus("rejected"); instance.setCompletedAt(java.time.LocalDateTime.now()); break;
-            default: instance.setStatus("running");
+        // 完成当前待办
+        completeTodoTasks(instance.getId(), approverId);
+
+        // 流转到下一节点
+        List<BpmProcessNode> nodes = processNodeMapper.selectByDefinitionId(instance.getDefinitionId());
+        BpmProcessNode currentNode = findNodeById(nodes, nodeId != null ? nodeId : instance.getCurrentNodeId());
+        BpmProcessNode nextNode = findNextNode(nodes, currentNode);
+
+        if (nextNode == null || "end".equals(nextNode.getNodeType())) {
+            // 流程结束
+            completeInstance(instance);
+        } else {
+            // 流转到下一节点
+            Long nextAssigneeId = resolveAssignee(nextNode, instance.getInitiatorId());
+            String nextAssigneeName = nextNode.getAssigneeName();
+
+            instance.setCurrentNodeId(nextNode.getNodeId());
+            instance.setCurrentNodeName(nextNode.getNodeName());
+            instance.setCurrentAssigneeId(nextAssigneeId);
+            instance.setCurrentAssigneeName(nextAssigneeName);
+            instance.setUpdatedAt(LocalDateTime.now());
+            instanceMapper.updateById(instance);
+
+            createTodoTask(instance, nextNode, nextAssigneeId, nextAssigneeName);
+        }
+
+        log.info("审批通过: instanceUuid={}, approver={}, nodeId={}", instanceUuid, approverName, nodeId);
+        return instance;
+    }
+
+    // ==================== 驳回 ====================
+
+    /**
+     * 驳回
+     */
+    @Transactional
+    public BpmProcessInstance rejectTask(String instanceUuid, Long approverId, String approverName,
+                                          String nodeId, String comment) {
+        BpmProcessInstance instance = getInstanceByUuid(instanceUuid);
+        validateRunning(instance);
+        validateAssignee(instance, approverId);
+
+        // 记录驳回
+        BpmApprovalRecord record = buildApprovalRecord(instance, nodeId, approverId, approverName,
+                ACTION_REJECT, comment);
+        approvalRecordMapper.insert(record);
+
+        // 取消所有待办
+        cancelTodoTasks(instance.getId());
+
+        // 更新实例状态
+        instance.setStatus(STATUS_REJECTED);
+        instance.setCompletedAt(LocalDateTime.now());
+        instance.setDurationSeconds(ChronoUnit.SECONDS.between(instance.getStartedAt(), LocalDateTime.now()));
+        instance.setUpdatedAt(LocalDateTime.now());
+        instanceMapper.updateById(instance);
+
+        log.info("审批驳回: instanceUuid={}, approver={}, reason={}", instanceUuid, approverName, comment);
+        return instance;
+    }
+
+    // ==================== 转办 ====================
+
+    /**
+     * 转办：将审批权转给其他人，原审批人不再审批
+     */
+    @Transactional
+    public BpmProcessInstance transferTask(String instanceUuid, Long currentApproverId, String currentApproverName,
+                                            Long targetAssigneeId, String targetAssigneeName,
+                                            String nodeId, String comment) {
+        BpmProcessInstance instance = getInstanceByUuid(instanceUuid);
+        validateRunning(instance);
+        validateAssignee(instance, currentApproverId);
+
+        if (targetAssigneeId == null || targetAssigneeId.equals(currentApproverId)) {
+            throw new BusinessException("转办目标人不能为空或与当前审批人相同");
+        }
+
+        // 记录转办
+        BpmApprovalRecord record = buildApprovalRecord(instance, nodeId, currentApproverId, currentApproverName,
+                ACTION_TRANSFER, comment);
+        record.setTargetAssigneeId(targetAssigneeId);
+        record.setTargetAssigneeName(targetAssigneeName);
+        approvalRecordMapper.insert(record);
+
+        // 关闭当前待办（标记为转办）
+        List<BpmTodoTask> currentTodos = todoTaskMapper.selectPendingByUserId(currentApproverId);
+        for (BpmTodoTask todo : currentTodos) {
+            if (todo.getInstanceId().equals(instance.getId())) {
+                todo.setStatus(TODO_TRANSFERRED);
+                todo.setCompletedAt(LocalDateTime.now());
+                todo.setUpdatedAt(LocalDateTime.now());
+                todoTaskMapper.updateById(todo);
+            }
+        }
+
+        // 创建新的待办给目标人
+        List<BpmProcessNode> nodes = processNodeMapper.selectByDefinitionId(instance.getDefinitionId());
+        BpmProcessNode currentNode = findNodeById(nodes, nodeId != null ? nodeId : instance.getCurrentNodeId());
+        createTodoTask(instance, currentNode, targetAssigneeId, targetAssigneeName);
+
+        // 更新实例当前处理人
+        instance.setCurrentAssigneeId(targetAssigneeId);
+        instance.setCurrentAssigneeName(targetAssigneeName);
+        instance.setUpdatedAt(LocalDateTime.now());
+        instanceMapper.updateById(instance);
+
+        log.info("任务转办: instanceUuid={}, from={} to={}",
+                instanceUuid, currentApproverName, targetAssigneeName);
+        return instance;
+    }
+
+    // ==================== 会签 ====================
+
+    /**
+     * 发起会签：多人审批，全部通过才继续流转
+     */
+    @Transactional
+    public BpmProcessInstance initiateCountersign(String instanceUuid, Long initiatorId,
+                                                    List<Long> signerIds, List<String> signerNames,
+                                                    String nodeId, String comment) {
+        BpmProcessInstance instance = getInstanceByUuid(instanceUuid);
+        validateRunning(instance);
+
+        if (signerIds == null || signerIds.size() < 2) {
+            throw new BusinessException("会签至少需要2个审批人");
+        }
+
+        // 记录会签发起
+        BpmApprovalRecord record = buildApprovalRecord(instance, nodeId, initiatorId,
+                null, ACTION_COUNTERSIGN, comment);
+        record.setCountersignTotal(signerIds.size());
+        record.setCountersignApproved(0);
+        record.setCountersignResult("all");
+        approvalRecordMapper.insert(record);
+
+        // 关闭当前待办
+        cancelTodoTasks(instance.getId());
+
+        // 为每个会签人创建待办
+        List<BpmProcessNode> nodes = processNodeMapper.selectByDefinitionId(instance.getDefinitionId());
+        BpmProcessNode currentNode = findNodeById(nodes, nodeId != null ? nodeId : instance.getCurrentNodeId());
+
+        for (int i = 0; i < signerIds.size(); i++) {
+            Long signerId = signerIds.get(i);
+            String signerName = (signerNames != null && i < signerNames.size()) ? signerNames.get(i) : "审批人" + (i + 1);
+            createTodoTask(instance, currentNode, signerId, signerName);
+        }
+
+        // 更新实例（当前处理人设为第一个会签人作为代表）
+        instance.setCurrentAssigneeId(signerIds.get(0));
+        instance.setCurrentAssigneeName(signerNames != null && !signerNames.isEmpty() ? signerNames.get(0) : "会签中");
+        instance.setUpdatedAt(LocalDateTime.now());
+        instanceMapper.updateById(instance);
+
+        log.info("会签发起: instanceUuid={}, signers={}", instanceUuid, signerNames);
+        return instance;
+    }
+
+    /**
+     * 会签审批（单个会签人审批通过）
+     */
+    @Transactional
+    public BpmProcessInstance countersignApprove(String instanceUuid, Long signerId, String signerName,
+                                                   String nodeId, String comment) {
+        BpmProcessInstance instance = getInstanceByUuid(instanceUuid);
+        validateRunning(instance);
+
+        // 校验该会签人是否有待办
+        List<BpmTodoTask> signerTodos = todoTaskMapper.selectPendingByUserId(signerId);
+        boolean hasTodo = signerTodos.stream()
+                .anyMatch(t -> t.getInstanceId().equals(instance.getId()));
+        if (!hasTodo) {
+            throw new BusinessException("该审批人无此任务的审批权限");
+        }
+
+        // 记录会签审批
+        BpmApprovalRecord record = buildApprovalRecord(instance, nodeId, signerId, signerName,
+                ACTION_APPROVE, comment);
+        approvalRecordMapper.insert(record);
+
+        // 完成该会签人的待办
+        completeTodoTasks(instance.getId(), signerId);
+
+        // 检查是否所有会签人都已审批
+        List<BpmTodoTask> remainingTodos = todoTaskMapper.selectPendingByInstanceId(instance.getId());
+        if (remainingTodos.isEmpty()) {
+            // 所有会签人完成，流转到下一节点
+            List<BpmProcessNode> nodes = processNodeMapper.selectByDefinitionId(instance.getDefinitionId());
+            BpmProcessNode currentNode = findNodeById(nodes, nodeId != null ? nodeId : instance.getCurrentNodeId());
+            BpmProcessNode nextNode = findNextNode(nodes, currentNode);
+
+            if (nextNode == null || "end".equals(nextNode.getNodeType())) {
+                completeInstance(instance);
+            } else {
+                Long nextAssigneeId = resolveAssignee(nextNode, instance.getInitiatorId());
+                String nextAssigneeName = nextNode.getAssigneeName();
+
+                instance.setCurrentNodeId(nextNode.getNodeId());
+                instance.setCurrentNodeName(nextNode.getNodeName());
+                instance.setCurrentAssigneeId(nextAssigneeId);
+                instance.setCurrentAssigneeName(nextAssigneeName);
+                instance.setUpdatedAt(LocalDateTime.now());
+                instanceMapper.updateById(instance);
+
+                createTodoTask(instance, nextNode, nextAssigneeId, nextAssigneeName);
+            }
+
+            log.info("会签完成: instanceUuid={}", instanceUuid);
+        } else {
+            log.info("会签进行中: instanceUuid={}, remaining={}", instanceUuid, remainingTodos.size());
         }
-        log.info("Approval: {} - {}: {}", instanceId, action, comment);
+
         return instance;
     }
 
-    /** 完成流程 */
+    // ==================== 完成流程（向后兼容） ====================
+
+    /**
+     * 完成流程
+     */
     @Transactional
-    public void completeProcess(String instanceId) {
-        BpmProcessInstance instance = instances.get(instanceId);
+    public void completeProcess(String instanceUuid) {
+        BpmProcessInstance instance = getInstanceByUuid(instanceUuid);
         if (instance != null) {
-            instance.setStatus("completed");
-            instance.setCompletedAt(java.time.LocalDateTime.now());
+            completeInstance(instance);
         }
     }
 
-    /** 查询待办 */
+    // ==================== 待办/已办查询 ====================
+
+    /**
+     * 查询待办（向后兼容旧接口）
+     */
     public List<BpmProcessInstance> getTodoList(Long userId) {
-        return instances.values().stream()
-                .filter(i -> "running".equals(i.getStatus()) && i.getInitiatorId().equals(userId))
-                .toList();
+        List<BpmTodoTask> todos = todoTaskMapper.selectPendingByUserId(userId);
+        if (todos.isEmpty()) {
+            return Collections.emptyList();
+        }
+        List<Long> instanceIds = todos.stream()
+                .map(BpmTodoTask::getInstanceId)
+                .distinct()
+                .collect(Collectors.toList());
+        if (instanceIds.isEmpty()) {
+            return Collections.emptyList();
+        }
+        return instanceMapper.selectBatchIds(instanceIds);
+    }
+
+    /**
+     * 查询待办任务列表（返回任务详情）
+     */
+    public List<BpmTodoTask> getTodoTasks(Long userId) {
+        return todoTaskMapper.selectPendingByUserId(userId);
+    }
+
+    /**
+     * 查询已办任务列表
+     */
+    public List<BpmTodoTask> getDoneTasks(Long userId) {
+        return todoTaskMapper.selectDoneByUserId(userId);
+    }
+
+    /**
+     * 查询待办数量
+     */
+    public Integer getTodoCount(Long userId) {
+        return todoTaskMapper.countPendingByUserId(userId);
+    }
+
+    /**
+     * 查询流程实例（通过UUID）
+     */
+    public BpmProcessInstance getInstance(String instanceUuid) {
+        return getInstanceByUuid(instanceUuid);
+    }
+
+    /**
+     * 查询流程实例（通过数据库ID）
+     */
+    public BpmProcessInstance getInstanceById(Long id) {
+        BpmProcessInstance instance = instanceMapper.selectById(id);
+        if (instance == null) {
+            throw new BusinessException("流程实例不存在");
+        }
+        return instance;
+    }
+
+    /**
+     * 查询我发起的流程
+     */
+    public List<BpmProcessInstance> getMyInitiated(Long userId) {
+        return instanceMapper.selectMyInitiated(userId);
+    }
+
+    /**
+     * 查询流程审批记录
+     */
+    public List<BpmApprovalRecord> getApprovalRecords(Long instanceId) {
+        return approvalRecordMapper.selectByInstanceId(instanceId);
+    }
+
+    /**
+     * 查询流程审批记录（通过UUID）
+     */
+    public List<BpmApprovalRecord> getApprovalRecordsByUuid(String instanceUuid) {
+        return approvalRecordMapper.selectByInstanceUuid(instanceUuid);
+    }
+
+    /**
+     * 条件查询流程实例
+     */
+    public List<BpmProcessInstance> queryInstances(String processKey, String status,
+                                                     Long initiatorId, String businessKey,
+                                                     Integer pageNum, Integer pageSize) {
+        LambdaQueryWrapper<BpmProcessInstance> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(processKey != null, BpmProcessInstance::getProcessKey, processKey)
+                .eq(status != null, BpmProcessInstance::getStatus, status)
+                .eq(initiatorId != null, BpmProcessInstance::getInitiatorId, initiatorId)
+                .eq(businessKey != null, BpmProcessInstance::getBusinessKey, businessKey)
+                .orderByDesc(BpmProcessInstance::getCreatedAt);
+
+        if (pageNum != null && pageSize != null) {
+            wrapper.last("LIMIT " + pageSize + " OFFSET " + (pageNum - 1) * pageSize);
+        }
+        return instanceMapper.selectList(wrapper);
+    }
+
+    // ==================== 内部辅助方法 ====================
+
+    private BpmProcessInstance getInstanceByUuid(String instanceUuid) {
+        LambdaQueryWrapper<BpmProcessInstance> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(BpmProcessInstance::getInstanceId, instanceUuid);
+        BpmProcessInstance instance = instanceMapper.selectOne(wrapper);
+        if (instance == null) {
+            throw new BusinessException("流程实例不存在");
+        }
+        return instance;
     }
 
-    /** 查询流程实例 */
-    public BpmProcessInstance getInstance(String instanceId) {
-        return instances.get(instanceId);
+    private void validateRunning(BpmProcessInstance instance) {
+        if (!STATUS_RUNNING.equals(instance.getStatus())) {
+            throw new BusinessException("流程实例不在运行中，当前状态: " + instance.getStatus());
+        }
+    }
+
+    private void validateAssignee(BpmProcessInstance instance, Long approverId) {
+        if (instance.getCurrentAssigneeId() != null &&
+                !instance.getCurrentAssigneeId().equals(approverId)) {
+            throw new BusinessException("当前审批人无权操作此任务");
+        }
+    }
+
+    private void completeInstance(BpmProcessInstance instance) {
+        instance.setStatus(STATUS_COMPLETED);
+        instance.setCompletedAt(LocalDateTime.now());
+        if (instance.getStartedAt() != null) {
+            instance.setDurationSeconds(ChronoUnit.SECONDS.between(instance.getStartedAt(), LocalDateTime.now()));
+        }
+        instance.setUpdatedAt(LocalDateTime.now());
+        instanceMapper.updateById(instance);
+
+        // 关闭所有待办
+        cancelTodoTasks(instance.getId());
+    }
+
+    private BpmProcessNode findStartNode(List<BpmProcessNode> nodes) {
+        return nodes.stream()
+                .filter(n -> "start".equals(n.getNodeType()))
+                .findFirst()
+                .orElse(nodes.stream()
+                        .min(Comparator.comparingInt(n -> n.getSortOrder() != null ? n.getSortOrder() : 0))
+                        .orElseThrow(() -> new BusinessException("无法找到起始节点")));
+    }
+
+    private BpmProcessNode findNextNode(List<BpmProcessNode> nodes, BpmProcessNode currentNode) {
+        if (currentNode == null) return null;
+        int currentSort = currentNode.getSortOrder() != null ? currentNode.getSortOrder() : 0;
+        return nodes.stream()
+                .filter(n -> {
+                    int sort = n.getSortOrder() != null ? n.getSortOrder() : 0;
+                    return sort > currentSort && !"start".equals(n.getNodeType());
+                })
+                .min(Comparator.comparingInt(n -> n.getSortOrder() != null ? n.getSortOrder() : 0))
+                .orElse(null);
+    }
+
+    private BpmProcessNode findNodeById(List<BpmProcessNode> nodes, String nodeId) {
+        if (nodeId == null) return null;
+        return nodes.stream()
+                .filter(n -> nodeId.equals(n.getNodeId()))
+                .findFirst()
+                .orElse(null);
+    }
+
+    private Long resolveAssignee(BpmProcessNode node, Long fallbackUserId) {
+        if (node == null || node.getAssigneeValue() == null || node.getAssigneeValue().isEmpty()) {
+            return fallbackUserId;
+        }
+        try {
+            return Long.parseLong(node.getAssigneeValue());
+        } catch (NumberFormatException e) {
+            return fallbackUserId;
+        }
+    }
+
+    private void createTodoTask(BpmProcessInstance instance, BpmProcessNode node,
+                                 Long assigneeId, String assigneeName) {
+        BpmTodoTask todo = new BpmTodoTask();
+        todo.setInstanceId(instance.getId());
+        todo.setInstanceUuid(instance.getInstanceId());
+        todo.setTitle(instance.getTitle());
+        todo.setProcessKey(instance.getProcessKey());
+        todo.setProcessName(instance.getProcessName());
+        todo.setNodeId(node != null ? node.getNodeId() : "unknown");
+        todo.setNodeName(node != null ? node.getNodeName() : "未知节点");
+        todo.setAssigneeId(assigneeId);
+        todo.setAssigneeName(assigneeName);
+        todo.setInitiatorId(instance.getInitiatorId());
+        todo.setInitiatorName(instance.getInitiatorName());
+        todo.setBusinessKey(instance.getBusinessKey());
+        todo.setStatus(TODO_PENDING);
+        todo.setPriority(instance.getPriority() != null ? instance.getPriority() : 0);
+        todo.setReceivedAt(LocalDateTime.now());
+        todo.setIsRead(false);
+        todo.setCreatedAt(LocalDateTime.now());
+        todo.setUpdatedAt(LocalDateTime.now());
+
+        // 设置超时时间
+        if (node != null && node.getTimeoutHours() != null && node.getTimeoutHours() > 0) {
+            todo.setDeadlineAt(LocalDateTime.now().plusHours(node.getTimeoutHours()));
+        }
+
+        todoTaskMapper.insert(todo);
+    }
+
+    private void completeTodoTasks(Long instanceId, Long userId) {
+        LambdaUpdateWrapper<BpmTodoTask> wrapper = new LambdaUpdateWrapper<>();
+        wrapper.eq(BpmTodoTask::getInstanceId, instanceId)
+                .eq(BpmTodoTask::getAssigneeId, userId)
+                .eq(BpmTodoTask::getStatus, TODO_PENDING)
+                .set(BpmTodoTask::getStatus, TODO_COMPLETED)
+                .set(BpmTodoTask::getCompletedAt, LocalDateTime.now())
+                .set(BpmTodoTask::getUpdatedAt, LocalDateTime.now());
+        todoTaskMapper.update(null, wrapper);
+    }
+
+    private void cancelTodoTasks(Long instanceId) {
+        LambdaUpdateWrapper<BpmTodoTask> wrapper = new LambdaUpdateWrapper<>();
+        wrapper.eq(BpmTodoTask::getInstanceId, instanceId)
+                .eq(BpmTodoTask::getStatus, TODO_PENDING)
+                .set(BpmTodoTask::getStatus, TODO_CANCELLED)
+                .set(BpmTodoTask::getCompletedAt, LocalDateTime.now())
+                .set(BpmTodoTask::getUpdatedAt, LocalDateTime.now());
+        todoTaskMapper.update(null, wrapper);
+    }
+
+    private BpmApprovalRecord buildApprovalRecord(BpmProcessInstance instance, String nodeId,
+                                                    Long approverId, String approverName,
+                                                    String action, String comment) {
+        BpmApprovalRecord record = new BpmApprovalRecord();
+        record.setInstanceId(instance.getId());
+        record.setInstanceUuid(instance.getInstanceId());
+        record.setNodeId(nodeId != null ? nodeId : instance.getCurrentNodeId());
+        record.setNodeName(instance.getCurrentNodeName());
+        record.setApproverId(approverId);
+        record.setApproverName(approverName);
+        record.setAction(action);
+        record.setComment(comment);
+        record.setApprovedAt(LocalDateTime.now());
+        record.setCreatedAt(LocalDateTime.now());
+        return record;
+    }
+
+    private String toJson(Object obj) {
+        if (obj == null) return null;
+        try {
+            return objectMapper.writeValueAsString(obj);
+        } catch (JsonProcessingException e) {
+            log.warn("JSON序列化失败: {}", e.getMessage());
+            return null;
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private Map<String, Object> fromJson(String json) {
+        if (json == null || json.isEmpty()) return Collections.emptyMap();
+        try {
+            return objectMapper.readValue(json, new TypeReference<Map<String, Object>>() {});
+        } catch (JsonProcessingException e) {
+            log.warn("JSON反序列化失败: {}", e.getMessage());
+            return Collections.emptyMap();
+        }
     }
-}
+}

wm-bpm/src/main/resources/db/V_bpm_core.sql

+-- ==========================================
+-- BPM 流程引擎核心表结构
+-- 数据库: PostgreSQL
+-- 版本: V1.0
+-- ==========================================
+
+-- 1. 流程定义表
+CREATE TABLE IF NOT EXISTS bpm_process_definition (
+    id              BIGSERIAL PRIMARY KEY,
+    process_key     VARCHAR(100) NOT NULL,
+    process_name    VARCHAR(200) NOT NULL,
+    description     TEXT,
+    bpmn_xml        TEXT,
+    form_schema     TEXT,
+    category        VARCHAR(50),
+    version         INTEGER NOT NULL DEFAULT 1,
+    status          INTEGER NOT NULL DEFAULT 0,          -- 0-草稿 1-已发布 2-已停用
+    created_by      VARCHAR(100),
+    icon            VARCHAR(200),
+    sort_order      INTEGER DEFAULT 0,
+    published_at    TIMESTAMP,
+    tenant_id       VARCHAR(50),
+    deleted         INTEGER NOT NULL DEFAULT 0,
+    created_at      TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at      TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_bpm_def_key ON bpm_process_definition(process_key);
+CREATE INDEX IF NOT EXISTS idx_bpm_def_category ON bpm_process_definition(category);
+CREATE INDEX IF NOT EXISTS idx_bpm_def_status ON bpm_process_definition(status);
+CREATE UNIQUE INDEX IF NOT EXISTS uk_bpm_def_key_version ON bpm_process_definition(process_key, version) WHERE deleted = 0;
+
+COMMENT ON TABLE bpm_process_definition IS '流程定义表';
+COMMENT ON COLUMN bpm_process_definition.process_key IS '流程唯一标识';
+COMMENT ON COLUMN bpm_process_definition.status IS '状态: 0-草稿 1-已发布 2-已停用';
+
+-- 2. 流程节点定义表
+CREATE TABLE IF NOT EXISTS bpm_process_node (
+    id                      BIGSERIAL PRIMARY KEY,
+    definition_id           BIGINT NOT NULL REFERENCES bpm_process_definition(id),
+    node_id                 VARCHAR(100) NOT NULL,
+    node_name               VARCHAR(200) NOT NULL,
+    node_type               VARCHAR(50) NOT NULL,        -- start/end/userTask/serviceTask/gateway/subprocess/timer
+    assignee_type           VARCHAR(50),                 -- role/user/department/position/initiator
+    assignee_value          VARCHAR(200),
+    assignee_name           VARCHAR(100),
+    multi_instance_type     VARCHAR(50),                 -- sequential(会签)/parallel(或签)/countersign(比例签)
+    countersign_rate        INTEGER,
+    timeout_hours           INTEGER,
+    timeout_action          VARCHAR(50),                 -- remind/transfer/escalate/auto_approve
+    form_permission         TEXT,
+    condition_expression    VARCHAR(500),
+    sort_order              INTEGER DEFAULT 0,
+    tenant_id               VARCHAR(50),
+    deleted                 INTEGER NOT NULL DEFAULT 0,
+    created_at              TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at              TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_bpm_node_def ON bpm_process_node(definition_id);
+CREATE INDEX IF NOT EXISTS idx_bpm_node_type ON bpm_process_node(node_type);
+
+COMMENT ON TABLE bpm_process_node IS '流程节点定义表';
+COMMENT ON COLUMN bpm_process_node.node_type IS '节点类型: start/end/userTask/serviceTask/gateway/subprocess/timer';
+COMMENT ON COLUMN bpm_process_node.multi_instance_type IS '多人审批方式: sequential(会签)/parallel(或签)/countersign(比例签)';
+
+-- 3. 流程实例表
+CREATE TABLE IF NOT EXISTS bpm_process_instance (
+    id                          BIGSERIAL PRIMARY KEY,
+    instance_id                 VARCHAR(64) NOT NULL,
+    definition_id               BIGINT NOT NULL REFERENCES bpm_process_definition(id),
+    process_key                 VARCHAR(100) NOT NULL,
+    process_name                VARCHAR(200),
+    business_key                VARCHAR(200),
+    business_type               VARCHAR(100),
+    title                       VARCHAR(500),
+    initiator_id                BIGINT NOT NULL,
+    initiator_name              VARCHAR(100),
+    current_node_id             VARCHAR(100),
+    current_node_name           VARCHAR(200),
+    current_assignee_id         BIGINT,
+    current_assignee_name       VARCHAR(100),
+    status                      VARCHAR(50) NOT NULL DEFAULT 'running',  -- running/completed/terminated/rejected/suspended
+    priority                    INTEGER DEFAULT 0,                       -- 0-普通 1-紧急 2-特急
+    variables                   TEXT,
+    form_data                   TEXT,
+    started_at                  TIMESTAMP,
+    completed_at                TIMESTAMP,
+    expected_completion_at      TIMESTAMP,
+    duration_seconds            BIGINT,
+    tenant_id                   VARCHAR(50),
+    deleted                     INTEGER NOT NULL DEFAULT 0,
+    created_at                  TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at                  TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uk_bpm_instance_id ON bpm_process_instance(instance_id) WHERE deleted = 0;
+CREATE INDEX IF NOT EXISTS idx_bpm_instance_def ON bpm_process_instance(definition_id);
+CREATE INDEX IF NOT EXISTS idx_bpm_instance_status ON bpm_process_instance(status);
+CREATE INDEX IF NOT EXISTS idx_bpm_instance_initiator ON bpm_process_instance(initiator_id);
+CREATE INDEX IF NOT EXISTS idx_bpm_instance_assignee ON bpm_process_instance(current_assignee_id);
+CREATE INDEX IF NOT EXISTS idx_bpm_instance_business ON bpm_process_instance(business_key);
+CREATE INDEX IF NOT EXISTS idx_bpm_instance_created ON bpm_process_instance(created_at);
+
+COMMENT ON TABLE bpm_process_instance IS '流程实例表';
+COMMENT ON COLUMN bpm_process_instance.status IS '状态: running-运行中/completed-已完成/terminated-已撤回/rejected-已驳回/suspended-挂起';
+COMMENT ON COLUMN bpm_process_instance.priority IS '优先级: 0-普通 1-紧急 2-特急';
+
+-- 4. 审批记录表
+CREATE TABLE IF NOT EXISTS bpm_approval_record (
+    id                      BIGSERIAL PRIMARY KEY,
+    instance_id             BIGINT NOT NULL REFERENCES bpm_process_instance(id),
+    instance_uuid           VARCHAR(64),
+    node_id                 VARCHAR(100),
+    node_name               VARCHAR(200),
+    approver_id             BIGINT NOT NULL,
+    approver_name           VARCHAR(100),
+    action                  VARCHAR(50) NOT NULL,       -- approve/reject/transfer/delegate/back/countersign/start
+    comment                 TEXT,
+    target_assignee_id      BIGINT,
+    target_assignee_name    VARCHAR(100),
+    countersign_result      VARCHAR(50),                -- all/pass_one/veto
+    countersign_approved    INTEGER,
+    countersign_total       INTEGER,
+    approved_at             TIMESTAMP,
+    tenant_id               VARCHAR(50),
+    deleted                 INTEGER NOT NULL DEFAULT 0,
+    created_at              TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_bpm_record_instance ON bpm_approval_record(instance_id);
+CREATE INDEX IF NOT EXISTS idx_bpm_record_uuid ON bpm_approval_record(instance_uuid);
+CREATE INDEX IF NOT EXISTS idx_bpm_record_approver ON bpm_approval_record(approver_id);
+CREATE INDEX IF NOT EXISTS idx_bpm_record_action ON bpm_approval_record(action);
+CREATE INDEX IF NOT EXISTS idx_bpm_record_time ON bpm_approval_record(approved_at);
+
+COMMENT ON TABLE bpm_approval_record IS '审批记录表';
+COMMENT ON COLUMN bpm_approval_record.action IS '审批动作: approve-通过/reject-驳回/transfer-转办/delegate-委派/back-退回/countersign-会签/start-发起';
+
+-- 5. 待办任务表
+CREATE TABLE IF NOT EXISTS bpm_todo_task (
+    id                  BIGSERIAL PRIMARY KEY,
+    instance_id         BIGINT NOT NULL REFERENCES bpm_process_instance(id),
+    instance_uuid       VARCHAR(64),
+    title               VARCHAR(500),
+    process_key         VARCHAR(100),
+    process_name        VARCHAR(200),
+    node_id             VARCHAR(100),
+    node_name           VARCHAR(200),
+    assignee_id         BIGINT NOT NULL,
+    assignee_name       VARCHAR(100),
+    initiator_id        BIGINT,
+    initiator_name      VARCHAR(100),
+    business_key        VARCHAR(200),
+    status              VARCHAR(50) NOT NULL DEFAULT 'pending',   -- pending/completed/transferred/delegated/cancelled
+    priority            INTEGER DEFAULT 0,
+    received_at         TIMESTAMP,
+    completed_at        TIMESTAMP,
+    deadline_at         TIMESTAMP,
+    is_read             BOOLEAN DEFAULT FALSE,
+    tenant_id           VARCHAR(50),
+    deleted             INTEGER NOT NULL DEFAULT 0,
+    created_at          TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at          TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_bpm_todo_assignee ON bpm_todo_task(assignee_id);
+CREATE INDEX IF NOT EXISTS idx_bpm_todo_status ON bpm_todo_task(status);
+CREATE INDEX IF NOT EXISTS idx_bpm_todo_instance ON bpm_todo_task(instance_id);
+CREATE INDEX IF NOT EXISTS idx_bpm_todo_uuid ON bpm_todo_task(instance_uuid);
+CREATE INDEX IF NOT EXISTS idx_bpm_todo_initiator ON bpm_todo_task(initiator_id);
+CREATE INDEX IF NOT EXISTS idx_bpm_todo_priority ON bpm_todo_task(priority DESC, received_at);
+CREATE INDEX IF NOT EXISTS idx_bpm_todo_deadline ON bpm_todo_task(deadline_at) WHERE status = 'pending';
+
+COMMENT ON TABLE bpm_todo_task IS '待办任务表';
+COMMENT ON COLUMN bpm_todo_task.status IS '任务状态: pending-待处理/completed-已完成/transferred-已转办/delegated-已委派/cancelled-已取消';
+
+-- 6. 流程编排表
+CREATE TABLE IF NOT EXISTS bpm_orchestration (
+    id                          BIGSERIAL PRIMARY KEY,
+    orchestration_name          VARCHAR(200) NOT NULL,
+    orchestration_code          VARCHAR(100) NOT NULL,
+    description                 TEXT,
+    process_definition_ids      TEXT,
+    orchestration_rules         TEXT,
+    trigger_type                VARCHAR(50),            -- manual/scheduled/event
+    cron_expression             VARCHAR(100),
+    event_name                  VARCHAR(200),
+    status                      INTEGER NOT NULL DEFAULT 0,
+    created_by                  VARCHAR(100),
+    execution_count             INTEGER DEFAULT 0,
+    tenant_id                   VARCHAR(50),
+    deleted                     INTEGER NOT NULL DEFAULT 0,
+    created_at                  TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at                  TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_bpm_orch_code ON bpm_orchestration(orchestration_code);
+CREATE INDEX IF NOT EXISTS idx_bpm_orch_status ON bpm_orchestration(status);
+
+COMMENT ON TABLE bpm_orchestration IS '流程编排表';
+
+-- 7. 流程表单模板表
+CREATE TABLE IF NOT EXISTS bpm_form_template (
+    id                  BIGSERIAL PRIMARY KEY,
+    template_name       VARCHAR(200) NOT NULL,
+    template_code       VARCHAR(100) NOT NULL,
+    category            VARCHAR(50),
+    form_schema         TEXT,
+    bpmn_template       TEXT,
+    description         TEXT,
+    icon                VARCHAR(200),
+    use_count           INTEGER DEFAULT 0,
+    status              INTEGER NOT NULL DEFAULT 0,
+    created_by          VARCHAR(100),
+    tenant_id           VARCHAR(50),
+    deleted             INTEGER NOT NULL DEFAULT 0,
+    created_at          TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at          TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_bpm_form_code ON bpm_form_template(template_code);
+CREATE INDEX IF NOT EXISTS idx_bpm_form_category ON bpm_form_template(category);
+
+COMMENT ON TABLE bpm_form_template IS '流程表单模板表';
+
+-- 8. 流程统计表
+CREATE TABLE IF NOT EXISTS bpm_process_stat (
+    id                          BIGSERIAL PRIMARY KEY,
+    definition_id               BIGINT NOT NULL REFERENCES bpm_process_definition(id),
+    process_key                 VARCHAR(100),
+    period                      VARCHAR(20),            -- day/week/month/quarter/year
+    stat_date                   VARCHAR(20),
+    start_count                 INTEGER DEFAULT 0,
+    completed_count             INTEGER DEFAULT 0,
+    rejected_count              INTEGER DEFAULT 0,
+    terminated_count            INTEGER DEFAULT 0,
+    avg_duration_seconds        BIGINT,
+    max_duration_seconds        BIGINT,
+    min_duration_seconds        BIGINT,
+    avg_node_duration_seconds   BIGINT,
+    timeout_count               INTEGER DEFAULT 0,
+    first_pass_rate             DOUBLE PRECISION,
+    tenant_id                   VARCHAR(50),
+    deleted                     INTEGER NOT NULL DEFAULT 0,
+    created_at                  TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at                  TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_bpm_stat_def ON bpm_process_stat(definition_id);
+CREATE INDEX IF NOT EXISTS idx_bpm_stat_date ON bpm_process_stat(stat_date);
+CREATE INDEX IF NOT EXISTS idx_bpm_stat_period ON bpm_process_stat(period);
+
+COMMENT ON TABLE bpm_process_stat IS '流程统计表';
+
+-- ==========================================
+-- 初始化数据：示例流程定义
+-- ==========================================
+
+INSERT INTO bpm_process_definition (process_key, process_name, description, category, version, status, created_by, sort_order, published_at, created_at, updated_at)
+VALUES
+    ('water_revenue_approval', '水费审批流程', '水费收缴相关审批流程', 'revenue', 1, 1, 'admin', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
+    ('water_patrol_approval', '巡检审批流程', '巡检任务审批流程', 'patrol', 1, 1, 'admin', 2, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
+    ('water_dispatch_approval', '调度审批流程', '供水调度审批流程', 'dispatch', 1, 1, 'admin', 3, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
+    ('water_maintenance_approval', '维修审批流程', '设备维修审批流程', 'maintenance', 1, 1, 'admin', 4, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+ON CONFLICT DO NOTHING;
+
+-- 示例节点：水费审批流程
+INSERT INTO bpm_process_node (definition_id, node_id, node_name, node_type, assignee_type, assignee_value, assignee_name, sort_order, created_at, updated_at)
+SELECT d.id, n.node_id, n.node_name, n.node_type, n.assignee_type, n.assignee_value, n.assignee_name, n.sort_order, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP
+FROM bpm_process_definition d,
+     (VALUES
+        ('start', '开始', 'start', 'initiator', NULL, '发起人', 1),
+        ('dept_review', '部门审核', 'userTask', 'role', '10', '部门主管', 2),
+        ('finance_review', '财务审核', 'userTask', 'role', '20', '财务主管', 3),
+        ('end', '结束', 'end', NULL, NULL, NULL, 4)
+     ) AS n(node_id, node_name, node_type, assignee_type, assignee_value, assignee_name, sort_order)
+WHERE d.process_key = 'water_revenue_approval' AND d.version = 1
+ON CONFLICT DO NOTHING;

wm-bpm/src/test/java/com/water/bpm/service/ProcessDefinitionServiceTest.java

+package com.water.bpm.service;
+
+import com.water.bpm.entity.BpmProcessDefinition;
+import com.water.bpm.entity.BpmProcessNode;
+import com.water.bpm.mapper.BpmProcessDefinitionMapper;
+import com.water.bpm.mapper.BpmProcessNodeMapper;
+import com.water.common.core.exception.BusinessException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * 流程定义管理服务测试
+ */
+@ExtendWith(MockitoExtension.class)
+class ProcessDefinitionServiceTest {
+
+    @Mock
+    private BpmProcessDefinitionMapper definitionMapper;
+    @Mock
+    private BpmProcessNodeMapper processNodeMapper;
+
+    @InjectMocks
+    private ProcessDefinitionService definitionService;
+
+    @Test
+    @DisplayName("创建流程定义 - 成功")
+    void create_success() {
+        when(definitionMapper.selectByProcessKey("test_key")).thenReturn(null);
+        when(definitionMapper.insert(any(BpmProcessDefinition.class))).thenAnswer(inv -> {
+            BpmProcessDefinition def = inv.getArgument(0);
+            def.setId(1L);
+            return 1;
+        });
+
+        BpmProcessDefinition def = new BpmProcessDefinition();
+        def.setProcessKey("test_key");
+        def.setProcessName("测试流程");
+        def.setCategory("test");
+
+        BpmProcessDefinition result = definitionService.create(def);
+
+        assertNotNull(result);
+        assertEquals("test_key", result.getProcessKey());
+        assertEquals(0, result.getStatus()); // 草稿
+        assertEquals(1, result.getVersion());
+        verify(definitionMapper).insert(any(BpmProcessDefinition.class));
+    }
+
+    @Test
+    @DisplayName("创建流程定义 - processKey 重复")
+    void create_duplicateKey() {
+        BpmProcessDefinition existing = new BpmProcessDefinition();
+        existing.setId(1L);
+        existing.setProcessKey("test_key");
+        when(definitionMapper.selectByProcessKey("test_key")).thenReturn(existing);
+
+        BpmProcessDefinition def = new BpmProcessDefinition();
+        def.setProcessKey("test_key");
+
+        assertThrows(BusinessException.class, () -> definitionService.create(def));
+    }
+
+    @Test
+    @DisplayName("发布流程定义 - 成功")
+    void publish_success() {
+        BpmProcessDefinition def = new BpmProcessDefinition();
+        def.setId(1L);
+        def.setStatus(0);
+        when(definitionMapper.selectById(1L)).thenReturn(def);
+        when(definitionMapper.updateById(any())).thenReturn(1);
+
+        BpmProcessDefinition result = definitionService.publish(1L);
+
+        assertEquals(1, result.getStatus());
+        assertNotNull(result.getPublishedAt());
+    }
+
+    @Test
+    @DisplayName("发布已发布的定义 - 异常")
+    void publish_alreadyPublished() {
+        BpmProcessDefinition def = new BpmProcessDefinition();
+        def.setId(1L);
+        def.setStatus(1);
+        when(definitionMapper.selectById(1L)).thenReturn(def);
+
+        assertThrows(BusinessException.class, () -> definitionService.publish(1L));
+    }
+
+    @Test
+    @DisplayName("停用流程定义 - 成功")
+    void deactivate_success() {
+        BpmProcessDefinition def = new BpmProcessDefinition();
+        def.setId(1L);
+        def.setStatus(1);
+        when(definitionMapper.selectById(1L)).thenReturn(def);
+        when(definitionMapper.updateById(any())).thenReturn(1);
+
+        BpmProcessDefinition result = definitionService.deactivate(1L);
+
+        assertEquals(2, result.getStatus());
+    }
+
+    @Test
+    @DisplayName("停用草稿定义 - 异常")
+    void deactivate_notPublished() {
+        BpmProcessDefinition def = new BpmProcessDefinition();
+        def.setId(1L);
+        def.setStatus(0);
+        when(definitionMapper.selectById(1L)).thenReturn(def);
+
+        assertThrows(BusinessException.class, () -> definitionService.deactivate(1L));
+    }
+
+    @Test
+    @DisplayName("创建新版本 - 成功")
+    void createNewVersion_success() {
+        BpmProcessDefinition oldDef = new BpmProcessDefinition();
+        oldDef.setId(1L);
+        oldDef.setProcessKey("test_key");
+        oldDef.setProcessName("测试流程");
+        oldDef.setVersion(1);
+        oldDef.setStatus(1);
+        when(definitionMapper.selectById(1L)).thenReturn(oldDef);
+        when(definitionMapper.updateById(any())).thenReturn(1);
+        when(processNodeMapper.selectByDefinitionId(1L)).thenReturn(Collections.emptyList());
+        when(definitionMapper.insert(any())).thenAnswer(inv -> {
+            BpmProcessDefinition def = inv.getArgument(0);
+            def.setId(2L);
+            return 1;
+        });
+
+        BpmProcessDefinition result = definitionService.createNewVersion(1L);
+
+        assertEquals(2, result.getVersion());
+        assertEquals(0, result.getStatus()); // 草稿
+        assertEquals("test_key", result.getProcessKey());
+    }
+
+    @Test
+    @DisplayName("更新草稿定义 - 成功")
+    void update_success() {
+        BpmProcessDefinition existing = new BpmProcessDefinition();
+        existing.setId(1L);
+        existing.setStatus(0);
+        when(definitionMapper.selectById(1L)).thenReturn(existing);
+        when(definitionMapper.updateById(any())).thenReturn(1);
+        when(definitionMapper.selectById(1L)).thenReturn(existing);
+
+        BpmProcessDefinition update = new BpmProcessDefinition();
+        update.setProcessName("更新后名称");
+
+        definitionService.update(1L, update);
+        verify(definitionMapper).updateById(any());
+    }
+
+    @Test
+    @DisplayName("更新已发布定义 - 异常")
+    void update_published() {
+        BpmProcessDefinition existing = new BpmProcessDefinition();
+        existing.setId(1L);
+        existing.setStatus(1);
+        when(definitionMapper.selectById(1L)).thenReturn(existing);
+
+        BpmProcessDefinition update = new BpmProcessDefinition();
+        update.setProcessName("更新后名称");
+
+        assertThrows(BusinessException.class, () -> definitionService.update(1L, update));
+    }
+
+    @Test
+    @DisplayName("查询定义列表")
+    void list() {
+        when(definitionMapper.selectList(any())).thenReturn(Arrays.asList(
+                new BpmProcessDefinition(), new BpmProcessDefinition()
+        ));
+
+        List<BpmProcessDefinition> result = definitionService.list("test", null);
+        assertEquals(2, result.size());
+    }
+
+    @Test
+    @DisplayName("获取节点列表")
+    void getNodes() {
+        BpmProcessNode node = new BpmProcessNode();
+        node.setNodeId("start");
+        when(processNodeMapper.selectByDefinitionId(1L)).thenReturn(List.of(node));
+
+        List<BpmProcessNode> result = definitionService.getNodes(1L);
+        assertEquals(1, result.size());
+    }
+
+    @Test
+    @DisplayName("删除草稿定义 - 成功")
+    void delete_success() {
+        BpmProcessDefinition def = new BpmProcessDefinition();
+        def.setId(1L);
+        def.setStatus(0);
+        when(definitionMapper.selectById(1L)).thenReturn(def);
+        when(definitionMapper.deleteById(1L)).thenReturn(1);
+
+        definitionService.delete(1L);
+        verify(definitionMapper).deleteById(1L);
+    }
+
+    @Test
+    @DisplayName("删除已发布定义 - 异常")
+    void delete_published() {
+        BpmProcessDefinition def = new BpmProcessDefinition();
+        def.setId(1L);
+        def.setStatus(1);
+        when(definitionMapper.selectById(1L)).thenReturn(def);
+
+        assertThrows(BusinessException.class, () -> definitionService.delete(1L));
+    }
+}

wm-bpm/src/test/java/com/water/bpm/service/ProcessEngineTest.java

+package com.water.bpm.service;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.water.bpm.entity.*;
+import com.water.bpm.mapper.*;
+import com.water.common.core.exception.BusinessException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.time.LocalDateTime;
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * 流程引擎核心单元测试
+ * 覆盖：启动流程、审批通过、驳回、转办、会签、待办查询
+ */
+@ExtendWith(MockitoExtension.class)
+class ProcessEngineTest {
+
+    @Mock
+    private BpmProcessDefinitionMapper definitionMapper;
+    @Mock
+    private BpmProcessInstanceMapper instanceMapper;
+    @Mock
+    private BpmApprovalRecordMapper approvalRecordMapper;
+    @Mock
+    private BpmTodoTaskMapper todoTaskMapper;
+    @Mock
+    private BpmProcessNodeMapper processNodeMapper;
+
+    @Spy
+    private ObjectMapper objectMapper = new ObjectMapper();
+
+    @InjectMocks
+    private ProcessEngine processEngine;
+
+    private BpmProcessDefinition testDefinition;
+    private BpmProcessNode startNode;
+    private BpmProcessNode reviewNode;
+    private BpmProcessNode endNode;
+    private List<BpmProcessNode> testNodes;
+
+    @BeforeEach
+    void setUp() {
+        testDefinition = new BpmProcessDefinition();
+        testDefinition.setId(1L);
+        testDefinition.setProcessKey("test_process");
+        testDefinition.setProcessName("测试流程");
+        testDefinition.setStatus(1);
+        testDefinition.setVersion(1);
+
+        startNode = new BpmProcessNode();
+        startNode.setId(1L);
+        startNode.setNodeId("start");
+        startNode.setNodeName("开始");
+        startNode.setNodeType("start");
+        startNode.setAssigneeType("initiator");
+        startNode.setSortOrder(1);
+
+        reviewNode = new BpmProcessNode();
+        reviewNode.setId(2L);
+        reviewNode.setNodeId("review");
+        reviewNode.setNodeName("审核");
+        reviewNode.setNodeType("userTask");
+        reviewNode.setAssigneeType("user");
+        reviewNode.setAssigneeValue("100");
+        reviewNode.setAssigneeName("审核人");
+        reviewNode.setSortOrder(2);
+
+        endNode = new BpmProcessNode();
+        endNode.setId(3L);
+        endNode.setNodeId("end");
+        endNode.setNodeName("结束");
+        endNode.setNodeType("end");
+        endNode.setSortOrder(3);
+
+        testNodes = Arrays.asList(startNode, reviewNode, endNode);
+    }
+
+    // ==================== 启动流程测试 ====================
+
+    @Test
+    @DisplayName("启动流程 - 成功场景")
+    void startProcess_success() {
+        when(definitionMapper.selectById(1L)).thenReturn(testDefinition);
+        when(processNodeMapper.selectByDefinitionId(1L)).thenReturn(testNodes);
+        when(instanceMapper.insert(any(BpmProcessInstance.class))).thenAnswer(inv -> {
+            BpmProcessInstance inst = inv.getArgument(0);
+            inst.setId(100L);
+            return 1;
+        });
+        when(todoTaskMapper.insert(any(BpmTodoTask.class))).thenReturn(1);
+        when(approvalRecordMapper.insert(any(BpmApprovalRecord.class))).thenReturn(1);
+        when(instanceMapper.updateById(any(BpmProcessInstance.class))).thenReturn(1);
+
+        Map<String, Object> formData = Map.of("amount", 1000, "reason", "测试");
+        BpmProcessInstance result = processEngine.startProcess(
+                1L, 1L, "张三", "BIZ-001", "test", "测试流程", formData, null, 0);
+
+        assertNotNull(result);
+        assertEquals("running", result.getStatus());
+        assertEquals("start", result.getCurrentNodeId());
+        assertEquals("张三", result.getInitiatorName());
+        assertEquals("BIZ-001", result.getBusinessKey());
+        assertNotNull(result.getInstanceId());
+
+        // 验证实例已插入
+        verify(instanceMapper).insert(any(BpmProcessInstance.class));
+        // 验证待办已创建
+        verify(todoTaskMapper).insert(any(BpmTodoTask.class));
+        // 验证启动记录已插入
+        verify(approvalRecordMapper).insert(any(BpmApprovalRecord.class));
+    }
+
+    @Test
+    @DisplayName("启动流程 - 定义不存在")
+    void startProcess_definitionNotFound() {
+        when(definitionMapper.selectById(999L)).thenReturn(null);
+
+        assertThrows(BusinessException.class, () ->
+                processEngine.startProcess(999L, 1L, "张三", "BIZ-001", null, null, null, null, 0));
+    }
+
+    @Test
+    @DisplayName("启动流程 - 定义未发布")
+    void startProcess_definitionNotPublished() {
+        testDefinition.setStatus(0); // 草稿
+        when(definitionMapper.selectById(1L)).thenReturn(testDefinition);
+
+        assertThrows(BusinessException.class, () ->
+                processEngine.startProcess(1L, 1L, "张三", "BIZ-001", null, null, null, null, 0));
+    }
+
+    @Test
+    @DisplayName("启动流程 - 无节点配置")
+    void startProcess_noNodes() {
+        when(definitionMapper.selectById(1L)).thenReturn(testDefinition);
+        when(processNodeMapper.selectByDefinitionId(1L)).thenReturn(Collections.emptyList());
+
+        assertThrows(BusinessException.class, () ->
+                processEngine.startProcess(1L, 1L, "张三", "BIZ-001", null, null, null, null, 0));
+    }
+
+    // ==================== 审批通过测试 ====================
+
+    @Test
+    @DisplayName("审批通过 - 流转到下一节点")
+    void approveTask_success() {
+        BpmProcessInstance instance = createRunningInstance();
+        when(instanceMapper.selectOne(any())).thenReturn(instance);
+        when(approvalRecordMapper.insert(any())).thenReturn(1);
+        when(todoTaskMapper.update(any(), any())).thenReturn(1);
+        when(processNodeMapper.selectByDefinitionId(1L)).thenReturn(testNodes);
+        when(todoTaskMapper.insert(any())).thenReturn(1);
+        when(instanceMapper.updateById(any())).thenReturn(1);
+
+        BpmProcessInstance result = processEngine.approveTask(
+                "test-uuid", 100L, "审核人", "review", "同意");
+
+        assertNotNull(result);
+        assertEquals("review", result.getCurrentNodeId());
+
+        // 验证审批记录已创建
+        ArgumentCaptor<BpmApprovalRecord> recordCaptor = ArgumentCaptor.forClass(BpmApprovalRecord.class);
+        verify(approvalRecordMapper).insert(recordCaptor.capture());
+        assertEquals("approve", recordCaptor.getValue().getAction());
+    }
+
+    @Test
+    @DisplayName("审批通过 - 流程完成（到达结束节点）")
+    void approveTask_completeProcess() {
+        BpmProcessInstance instance = createRunningInstance();
+        instance.setCurrentNodeId("review");
+        instance.setCurrentNodeName("审核");
+
+        when(instanceMapper.selectOne(any())).thenReturn(instance);
+        when(approvalRecordMapper.insert(any())).thenReturn(1);
+        when(todoTaskMapper.update(any(), any())).thenReturn(1);
+        when(processNodeMapper.selectByDefinitionId(1L)).thenReturn(testNodes);
+        when(instanceMapper.updateById(any())).thenReturn(1);
+        when(todoTaskMapper.update(any(), any())).thenReturn(1);
+
+        BpmProcessInstance result = processEngine.approveTask(
+                "test-uuid", 100L, "审核人", "review", "同意");
+
+        assertNotNull(result);
+        assertEquals("completed", result.getStatus());
+        assertNotNull(result.getCompletedAt());
+    }
+
+    @Test
+    @DisplayName("审批通过 - 实例不在运行状态")
+    void approveTask_instanceNotRunning() {
+        BpmProcessInstance instance = createRunningInstance();
+        instance.setStatus("completed");
+
+        when(instanceMapper.selectOne(any())).thenReturn(instance);
+
+        assertThrows(BusinessException.class, () ->
+                processEngine.approveTask("test-uuid", 100L, "审核人", "review", "同意"));
+    }
+
+    @Test
+    @DisplayName("审批通过 - 非当前审批人")
+    void approveTask_wrongApprover() {
+        BpmProcessInstance instance = createRunningInstance();
+        instance.setCurrentAssigneeId(100L);
+
+        when(instanceMapper.selectOne(any())).thenReturn(instance);
+
+        assertThrows(BusinessException.class, () ->
+                processEngine.approveTask("test-uuid", 999L, "其他人", "review", "同意"));
+    }
+
+    // ==================== 驳回测试 ====================
+
+    @Test
+    @DisplayName("驳回 - 成功场景")
+    void rejectTask_success() {
+        BpmProcessInstance instance = createRunningInstance();
+        when(instanceMapper.selectOne(any())).thenReturn(instance);
+        when(approvalRecordMapper.insert(any())).thenReturn(1);
+        when(todoTaskMapper.update(any(), any())).thenReturn(1);
+        when(instanceMapper.updateById(any())).thenReturn(1);
+
+        BpmProcessInstance result = processEngine.rejectTask(
+                "test-uuid", 100L, "审核人", "review", "不符合要求");
+
+        assertNotNull(result);
+        assertEquals("rejected", result.getStatus());
+        assertNotNull(result.getCompletedAt());
+
+        // 验证审批记录
+        ArgumentCaptor<BpmApprovalRecord> recordCaptor = ArgumentCaptor.forClass(BpmApprovalRecord.class);
+        verify(approvalRecordMapper).insert(recordCaptor.capture());
+        assertEquals("reject", recordCaptor.getValue().getAction());
+    }
+
+    @Test
+    @DisplayName("驳回 - 实例不存在")
+    void rejectTask_instanceNotFound() {
+        when(instanceMapper.selectOne(any())).thenReturn(null);
+
+        assertThrows(BusinessException.class, () ->
+                processEngine.rejectTask("non-exist", 100L, "审核人", "review", "拒绝"));
+    }
+
+    // ==================== 转办测试 ====================
+
+    @Test
+    @DisplayName("转办 - 成功场景")
+    void transferTask_success() {
+        BpmProcessInstance instance = createRunningInstance();
+        when(instanceMapper.selectOne(any())).thenReturn(instance);
+        when(approvalRecordMapper.insert(any())).thenReturn(1);
+
+        BpmTodoTask currentTodo = new BpmTodoTask();
+        currentTodo.setId(1L);
+        currentTodo.setInstanceId(instance.getId());
+        currentTodo.setStatus("pending");
+        when(todoTaskMapper.selectPendingByUserId(100L)).thenReturn(List.of(currentTodo));
+        when(todoTaskMapper.updateById(any())).thenReturn(1);
+
+        when(processNodeMapper.selectByDefinitionId(1L)).thenReturn(testNodes);
+        when(todoTaskMapper.insert(any())).thenReturn(1);
+        when(instanceMapper.updateById(any())).thenReturn(1);
+
+        BpmProcessInstance result = processEngine.transferTask(
+                "test-uuid", 100L, "审核人", 200L, "新审核人", "review", "转交处理");
+
+        assertNotNull(result);
+        assertEquals(Long.valueOf(200L), result.getCurrentAssigneeId());
+        assertEquals("新审核人", result.getCurrentAssigneeName());
+        assertEquals("running", result.getStatus());
+
+        // 验证转办记录
+        ArgumentCaptor<BpmApprovalRecord> recordCaptor = ArgumentCaptor.forClass(BpmApprovalRecord.class);
+        verify(approvalRecordMapper).insert(recordCaptor.capture());
+        BpmApprovalRecord record = recordCaptor.getValue();
+        assertEquals("transfer", record.getAction());
+        assertEquals(Long.valueOf(200L), record.getTargetAssigneeId());
+    }
+
+    @Test
+    @DisplayName("转办 - 目标人相同")
+    void transferTask_sameTarget() {
+        BpmProcessInstance instance = createRunningInstance();
+        when(instanceMapper.selectOne(any())).thenReturn(instance);
+
+        assertThrows(BusinessException.class, () ->
+                processEngine.transferTask("test-uuid", 100L, "审核人", 100L, "审核人", "review", ""));
+    }
+
+    @Test
+    @DisplayName("转办 - 目标人为空")
+    void transferTask_nullTarget() {
+        BpmProcessInstance instance = createRunningInstance();
+        when(instanceMapper.selectOne(any())).thenReturn(instance);
+
+        assertThrows(BusinessException.class, () ->
+                processEngine.transferTask("test-uuid", 100L, "审核人", null, null, "review", ""));
+    }
+
+    // ==================== 会签测试 ====================
+
+    @Test
+    @DisplayName("发起会签 - 成功场景")
+    void initiateCountersign_success() {
+        BpmProcessInstance instance = createRunningInstance();
+        when(instanceMapper.selectOne(any())).thenReturn(instance);
+        when(approvalRecordMapper.insert(any())).thenReturn(1);
+        when(todoTaskMapper.update(any(), any())).thenReturn(1);
+        when(processNodeMapper.selectByDefinitionId(1L)).thenReturn(testNodes);
+        when(todoTaskMapper.insert(any())).thenReturn(1);
+        when(instanceMapper.updateById(any())).thenReturn(1);
+
+        List<Long> signerIds = Arrays.asList(101L, 102L, 103L);
+        List<String> signerNames = Arrays.asList("会签人A", "会签人B", "会签人C");
+
+        BpmProcessInstance result = processEngine.initiateCountersign(
+                "test-uuid", 1L, signerIds, signerNames, "review", "需要三人会签");
+
+        assertNotNull(result);
+
+        // 验证会签记录
+        ArgumentCaptor<BpmApprovalRecord> recordCaptor = ArgumentCaptor.forClass(BpmApprovalRecord.class);
+        verify(approvalRecordMapper).insert(recordCaptor.capture());
+        BpmApprovalRecord record = recordCaptor.getValue();
+        assertEquals("countersign", record.getAction());
+        assertEquals(3, record.getCountersignTotal());
+        assertEquals(0, record.getCountersignApproved());
+
+        // 验证为每个会签人创建了待办
+        verify(todoTaskMapper, times(3)).insert(any(BpmTodoTask.class));
+    }
+
+    @Test
+    @DisplayName("发起会签 - 少于2人")
+    void initiateCountersign_tooFewSigners() {
+        BpmProcessInstance instance = createRunningInstance();
+        when(instanceMapper.selectOne(any())).thenReturn(instance);
+
+        assertThrows(BusinessException.class, () ->
+                processEngine.initiateCountersign("test-uuid", 1L,
+                        List.of(101L), List.of("单人"), "review", ""));
+    }
+
+    @Test
+    @DisplayName("会签审批 - 单人通过后仍有待办")
+    void countersignApprove_partialApproval() {
+        BpmProcessInstance instance = createRunningInstance();
+        when(instanceMapper.selectOne(any())).thenReturn(instance);
+
+        BpmTodoTask signerTodo = new BpmTodoTask();
+        signerTodo.setId(1L);
+        signerTodo.setInstanceId(instance.getId());
+        signerTodo.setStatus("pending");
+        when(todoTaskMapper.selectPendingByUserId(101L)).thenReturn(List.of(signerTodo));
+        when(approvalRecordMapper.insert(any())).thenReturn(1);
+        when(todoTaskMapper.update(any(), any())).thenReturn(1);
+
+        // 还有其他会签人待办
+        BpmTodoTask remainingTodo = new BpmTodoTask();
+        remainingTodo.setId(2L);
+        remainingTodo.setInstanceId(instance.getId());
+        when(todoTaskMapper.selectPendingByInstanceId(instance.getId())).thenReturn(List.of(remainingTodo));
+
+        BpmProcessInstance result = processEngine.countersignApprove(
+                "test-uuid", 101L, "会签人A", "review", "同意");
+
+        assertNotNull(result);
+        assertEquals("running", result.getStatus());
+    }
+
+    @Test
+    @DisplayName("会签审批 - 全部通过流转到下一节点")
+    void countersignApprove_allApproved() {
+        BpmProcessInstance instance = createRunningInstance();
+        when(instanceMapper.selectOne(any())).thenReturn(instance);
+
+        BpmTodoTask signerTodo = new BpmTodoTask();
+        signerTodo.setId(1L);
+        signerTodo.setInstanceId(instance.getId());
+        signerTodo.setStatus("pending");
+        when(todoTaskMapper.selectPendingByUserId(101L)).thenReturn(List.of(signerTodo));
+        when(approvalRecordMapper.insert(any())).thenReturn(1);
+        when(todoTaskMapper.update(any(), any())).thenReturn(1);
+
+        // 所有会签人已完成
+        when(todoTaskMapper.selectPendingByInstanceId(instance.getId())).thenReturn(Collections.emptyList());
+        when(processNodeMapper.selectByDefinitionId(1L)).thenReturn(testNodes);
+        when(instanceMapper.updateById(any())).thenReturn(1);
+
+        BpmProcessInstance result = processEngine.countersignApprove(
+                "test-uuid", 101L, "会签人A", "review", "同意");
+
+        assertNotNull(result);
+        // 应该流转到下一节点或完成
+        assertTrue("completed".equals(result.getStatus()) || "running".equals(result.getStatus()));
+    }
+
+    @Test
+    @DisplayName("会签审批 - 无待办权限")
+    void countersignApprove_noPermission() {
+        BpmProcessInstance instance = createRunningInstance();
+        when(instanceMapper.selectOne(any())).thenReturn(instance);
+        when(todoTaskMapper.selectPendingByUserId(999L)).thenReturn(Collections.emptyList());
+
+        assertThrows(BusinessException.class, () ->
+                processEngine.countersignApprove("test-uuid", 999L, "无权限人", "review", "同意"));
+    }
+
+    // ==================== 待办查询测试 ====================
+
+    @Test
+    @DisplayName("查询待办列表 - 有数据")
+    void getTodoTasks_hasData() {
+        BpmTodoTask todo1 = new BpmTodoTask();
+        todo1.setId(1L);
+        todo1.setStatus("pending");
+        BpmTodoTask todo2 = new BpmTodoTask();
+        todo2.setId(2L);
+        todo2.setStatus("pending");
+
+        when(todoTaskMapper.selectPendingByUserId(100L)).thenReturn(Arrays.asList(todo1, todo2));
+
+        List<BpmTodoTask> result = processEngine.getTodoTasks(100L);
+        assertEquals(2, result.size());
+    }
+
+    @Test
+    @DisplayName("查询待办列表 - 空列表")
+    void getTodoTasks_empty() {
+        when(todoTaskMapper.selectPendingByUserId(100L)).thenReturn(Collections.emptyList());
+
+        List<BpmTodoTask> result = processEngine.getTodoTasks(100L);
+        assertTrue(result.isEmpty());
+    }
+
+    @Test
+    @DisplayName("查询待办数量")
+    void getTodoCount() {
+        when(todoTaskMapper.countPendingByUserId(100L)).thenReturn(5);
+
+        Integer count = processEngine.getTodoCount(100L);
+        assertEquals(5, count);
+    }
+
+    @Test
+    @DisplayName("查询已办列表")
+    void getDoneTasks() {
+        BpmTodoTask done1 = new BpmTodoTask();
+        done1.setId(1L);
+        done1.setStatus("completed");
+        when(todoTaskMapper.selectDoneByUserId(100L)).thenReturn(List.of(done1));
+
+        List<BpmTodoTask> result = processEngine.getDoneTasks(100L);
+        assertEquals(1, result.size());
+        assertEquals("completed", result.get(0).getStatus());
+    }
+
+    @Test
+    @DisplayName("查询我发起的流程")
+    void getMyInitiated() {
+        BpmProcessInstance inst = createRunningInstance();
+        when(instanceMapper.selectMyInitiated(1L)).thenReturn(List.of(inst));
+
+        List<BpmProcessInstance> result = processEngine.getMyInitiated(1L);
+        assertEquals(1, result.size());
+    }
+
+    @Test
+    @DisplayName("查询审批记录")
+    void getApprovalRecords() {
+        BpmApprovalRecord record = new BpmApprovalRecord();
+        record.setAction("approve");
+        when(approvalRecordMapper.selectByInstanceId(100L)).thenReturn(List.of(record));
+
+        List<BpmApprovalRecord> records = processEngine.getApprovalRecords(100L);
+        assertEquals(1, records.size());
+    }
+
+    // ==================== 辅助方法 ====================
+
+    private BpmProcessInstance createRunningInstance() {
+        BpmProcessInstance instance = new BpmProcessInstance();
+        instance.setId(100L);
+        instance.setInstanceId("test-uuid");
+        instance.setDefinitionId(1L);
+        instance.setProcessKey("test_process");
+        instance.setProcessName("测试流程");
+        instance.setTitle("测试流程 - 张三");
+        instance.setBusinessKey("BIZ-001");
+        instance.setInitiatorId(1L);
+        instance.setInitiatorName("张三");
+        instance.setCurrentNodeId("review");
+        instance.setCurrentNodeName("审核");
+        instance.setCurrentAssigneeId(100L);
+        instance.setCurrentAssigneeName("审核人");
+        instance.setStatus("running");
+        instance.setStartedAt(LocalDateTime.now().minusHours(1));
+        instance.setCreatedAt(LocalDateTime.now().minusHours(1));
+        instance.setPriority(0);
+        return instance;
+    }
+}