@gadmin2n/schematics 0.0.152 → 0.0.153

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow.service.ts

@@ -19,11 +19,7 @@ import {
   scopedIdempotencyKey,
   workflowDataHash,
 } from './manual-workflow-execution';
-import {
-  TemporalService,
-  WorkflowRetryCheckpoint,
-  workflowTemporalId,
-} from './temporal.service';
+import { TemporalService, workflowTemporalId } from './temporal.service';
 import { verifyWebhookSignature } from './webhook-signature.util';
 import { describeCallableWorkflow } from './workflow-callable';
 import { WorkflowCompilerService } from './workflow-compiler.service';
@@ -97,19 +93,22 @@ type CronSchedulePlan =
       version: { id: bigint; dsl: unknown };
     };
 const WORKFLOW_PUBLISH_LOCK_KEY = BigInt(734_221_907);
-const RETRYABLE_MAIN_FLOW_NODE_TYPES = new Set([
-  'http_request',
-  'db_execute',
-  'code',
-  'delay',
-  'sub_workflow',
-]);
-
 interface WorkflowExecutionInternalOptions {
   operationScopeId?: string;
-  retryCheckpoint?: WorkflowRetryCheckpoint;
   retryOfInstanceId?: bigint;
-  retryFromNodeId?: string;
+}
+
+export type WorkflowServiceOutcome<T> =
+  | { kind: 'ok'; value: T }
+  | { kind: 'not_found'; message: string }
+  | { kind: 'conflict'; message: string }
+  | { kind: 'invalid_input'; message: string };
+
+export interface WorkflowExecutionResult {
+  instanceId: string;
+  temporalRunId: string | null;
+  workflowVersionId: string;
+  status: string;
 }
 
 function dslUsesBusinessEvent(dsl: unknown, registrationCode: string): boolean {
@@ -644,6 +643,7 @@ export class WorkflowService {
       {
         pending: number;
         running: number;
+        waiting_retry: number;
         completed: number;
         failed: number;
         cancelled: number;
@@ -654,6 +654,7 @@ export class WorkflowService {
         runsMap.set(row.workflowId, {
           pending: 0,
           running: 0,
+          waiting_retry: 0,
           completed: 0,
           failed: 0,
           cancelled: 0,
@@ -681,6 +682,7 @@ export class WorkflowService {
       runs: runsMap.get(item.id) || {
         pending: 0,
         running: 0,
+        waiting_retry: 0,
         completed: 0,
         failed: 0,
         cancelled: 0,
@@ -1407,7 +1409,7 @@ export class WorkflowService {
     const activeInstances = await tx.workflowInstance.count({
       where: {
         workflowId,
-        status: { in: ['PENDING', 'RUNNING'] },
+        status: { in: ['PENDING', 'RUNNING', 'WAITING_RETRY'] },
       },
     });
     if (activeInstances > 0)
@@ -1727,19 +1729,24 @@ export class WorkflowService {
   }
 
   async getStats(workflowId: bigint) {
-    const [running, failed, completed, total] = await Promise.all([
-      this.prisma.workflowInstance.count({
-        where: { workflowId, status: 'RUNNING' },
-      }),
-      this.prisma.workflowInstance.count({
-        where: { workflowId, status: 'FAILED' },
-      }),
-      this.prisma.workflowInstance.count({
-        where: { workflowId, status: 'COMPLETED' },
-      }),
-      this.prisma.workflowInstance.count({ where: { workflowId } }),
-    ]);
-    return { running, failed, completed, total };
+    const [running, waitingRetry, failed, completed, total] = await Promise.all(
+      [
+        this.prisma.workflowInstance.count({
+          where: { workflowId, status: 'RUNNING' },
+        }),
+        this.prisma.workflowInstance.count({
+          where: { workflowId, status: 'WAITING_RETRY' },
+        }),
+        this.prisma.workflowInstance.count({
+          where: { workflowId, status: 'FAILED' },
+        }),
+        this.prisma.workflowInstance.count({
+          where: { workflowId, status: 'COMPLETED' },
+        }),
+        this.prisma.workflowInstance.count({ where: { workflowId } }),
+      ],
+    );
+    return { running, waitingRetry, failed, completed, total };
   }
 
   async getWorkflowStatsByCode(code: string) {
@@ -1764,6 +1771,7 @@ export class WorkflowService {
       failed24h,
       running,
       pending,
+      waitingRetry,
     ] = await Promise.all([
       this.prisma.workflowInstance.count(),
       this.prisma.workflowInstance.count({
@@ -1779,6 +1787,9 @@ export class WorkflowService {
       }),
       this.prisma.workflowInstance.count({ where: { status: 'RUNNING' } }),
       this.prisma.workflowInstance.count({ where: { status: 'PENDING' } }),
+      this.prisma.workflowInstance.count({
+        where: { status: 'WAITING_RETRY' },
+      }),
     ]);
 
     // Success rate calculation
@@ -1828,6 +1839,7 @@ export class WorkflowService {
       },
       running,
       pending,
+      waitingRetry,
     };
   }
 
@@ -1902,7 +1914,6 @@ export class WorkflowService {
     const executionContext = createWorkflowExecutionState(
       dto.workflow,
       internal?.operationScopeId,
-      internal?.retryCheckpoint,
     );
     const idempotencyRequestHash = dto.idempotencyKey
       ? workflowDataHash(
@@ -1938,7 +1949,6 @@ export class WorkflowService {
             }),
             ...(internal?.retryOfInstanceId && {
               retryOfInstanceId: internal.retryOfInstanceId,
-              retryFromNodeId: internal.retryFromNodeId,
             }),
             creator,
           },
@@ -2011,7 +2021,6 @@ export class WorkflowService {
         versionId: Number(instanceVersion.id),
         dsl: instanceVersion.dsl,
         context: instance.context as Record<string, any>,
-        retryCheckpoint: readRetryCheckpoint(instance.context),
       });
     } catch (error) {
       await this.workflowLifecycle.markFailed({
@@ -2250,7 +2259,6 @@ export class WorkflowService {
         select: {
           id: true,
           status: true,
-          retryFromNodeId: true,
           createdAt: true,
         },
       }),
@@ -2271,16 +2279,10 @@ export class WorkflowService {
       workflow: { name: instance.workflow.name },
       approvableNodeIds: approvableRequests.map((request) => request.nodeId),
       retryableNodeIds:
-        instance.status === 'FAILED' && dsl && retryAttempts.length === 0
-          ? listRetryableNodeIds(
-              dsl,
-              instance.nodeExecutions,
-              readRetryCheckpoint(instance.context),
-            )
+        instance.status === 'WAITING_RETRY' && dsl
+          ? listSameRunRetryableNodeIds(dsl, instance.nodeExecutions)
           : [],
       retryAttempts,
-      reusedNodeIds:
-        readRetryCheckpoint(instance.context)?.completedNodeIds ?? [],
       dsl,
     };
   }
@@ -2306,7 +2308,7 @@ export class WorkflowService {
       ...(Object.prototype.hasOwnProperty.call(result, 'output') && {
         result: result.output,
       }),
-      ...(instance.status === 'FAILED' && {
+      ...(['FAILED', 'WAITING_RETRY'].includes(instance.status) && {
         error: {
           ...(typeof result.code === 'string' ? { code: result.code } : {}),
           message:
@@ -2347,10 +2349,10 @@ export class WorkflowService {
     if (!instance) throw new NotFoundException('Workflow instance not found');
     if (
       instance.status !== 'CANCELLED' &&
-      !['RUNNING', 'PENDING'].includes(instance.status)
+      !['RUNNING', 'PENDING', 'WAITING_RETRY'].includes(instance.status)
     )
       throw new ConflictException(
-        'Only RUNNING or PENDING instances can be cancelled',
+        'Only RUNNING, PENDING, or WAITING_RETRY instances can be cancelled',
       );
     if (
       instance.status !== 'CANCELLED' &&
@@ -2510,7 +2512,7 @@ export class WorkflowService {
 
     const reservedInstances = await this.prisma.workflowInstance.findMany({
       where: {
-        status: { in: ['PENDING', 'RUNNING'] },
+        status: { in: ['PENDING', 'RUNNING', 'WAITING_RETRY'] },
         temporalRunId: { not: null },
         updatedAt: { lte: cutoff },
       },
@@ -2529,7 +2531,10 @@ export class WorkflowService {
           instance.temporalRunId!,
         );
         if (temporalState.kind === 'MISSING') {
-          if (instance.status === 'RUNNING') {
+          if (
+            instance.status === 'RUNNING' ||
+            instance.status === 'WAITING_RETRY'
+          ) {
             await this.failMissingRunningInstance(
               instance.id,
               instance.temporalRunId!,
@@ -2555,7 +2560,6 @@ export class WorkflowService {
               versionId: Number(instance.versionId),
               dsl: version.dsl,
               context: (instance.context ?? {}) as Record<string, any>,
-              retryCheckpoint: readRetryCheckpoint(instance.context),
             });
           } catch (error) {
             await this.failUnstartedInstance(
@@ -2599,7 +2603,7 @@ export class WorkflowService {
   ): Promise<void> {
     await this.workflowLifecycle.markFailed({
       instanceId,
-      expectedStatuses: ['RUNNING'],
+      expectedStatuses: ['RUNNING', 'WAITING_RETRY'],
       temporalRunId,
       result: {
         code: 'TEMPORAL_EXECUTION_MISSING',
@@ -2685,7 +2689,7 @@ export class WorkflowService {
     if (state.status !== 'COMPLETED' && state.status !== 'CANCELLED') {
       await this.workflowLifecycle.markFailed({
         instanceId,
-        expectedStatuses: ['PENDING', 'RUNNING'],
+        expectedStatuses: ['PENDING', 'RUNNING', 'WAITING_RETRY'],
         temporalRunId,
         result:
           state.result === undefined
@@ -2702,7 +2706,7 @@ export class WorkflowService {
     await this.prisma.workflowInstance.updateMany({
       where: {
         id: instanceId,
-        status: { in: ['PENDING', 'RUNNING'] },
+        status: { in: ['PENDING', 'RUNNING', 'WAITING_RETRY'] },
         temporalRunId,
       },
       data: {
@@ -2785,59 +2789,72 @@ export class WorkflowService {
     );
   }
 
-  async retryInstanceFromNode(
+  async retryFailedNode(
     instanceId: bigint,
     nodeId: string,
-    creator: string,
     temporalService: TemporalService,
-  ) {
+  ): Promise<WorkflowServiceOutcome<WorkflowExecutionResult>> {
     const instance = await this.prisma.workflowInstance.findUnique({
       where: { id: instanceId },
       include: { nodeExecutions: true },
     });
-    if (!instance) throw new NotFoundException('Instance not found');
-    if (instance.status !== 'FAILED') {
-      throw new BadRequestException('只有失败的 Workflow 才能从节点重试');
-    }
-
-    const existingRetry = await this.prisma.workflowInstance.findFirst({
-      where: { retryOfInstanceId: instance.id },
-      orderBy: { createdAt: 'desc' },
-    });
-    if (existingRetry) return workflowExecutionResult(existingRetry);
+    if (!instance) return { kind: 'not_found', message: 'Instance not found' };
+    if (instance.status !== 'WAITING_RETRY')
+      return {
+        kind: 'conflict',
+        message: '只有等待重试的 Workflow 才能重试失败节点',
+      };
 
     const version = await this.prisma.workflowVersion.findUnique({
       where: { id: instance.versionId },
       select: { dsl: true },
     });
-    if (!version) throw new NotFoundException('Workflow version not found');
+    if (!version)
+      return { kind: 'not_found', message: 'Workflow version not found' };
 
-    const retryCheckpoint = buildRetryCheckpoint(
+    const invalidTargetMessage = validateSameRunRetryTarget(
       version.dsl,
       instance.nodeExecutions,
       nodeId,
-      readRetryCheckpoint(instance.context),
     );
-    const executionState = asRecord(instance.context);
-    const operationScopeId =
-      asRecord(executionState.system).operationScopeId ?? String(instance.id);
-
-    return this.executeWorkflow(
-      instance.workflowId,
-      {
-        workflow: asRecord(executionState.workflow),
-        workflowVersionId: instance.versionId,
-        idempotencyKey: `retry:${instance.id}`,
-      },
-      creator,
-      temporalService,
-      {
-        operationScopeId: String(operationScopeId),
-        retryCheckpoint,
-        retryOfInstanceId: instance.id,
-        retryFromNodeId: nodeId,
-      },
+    if (invalidTargetMessage)
+      return { kind: 'invalid_input', message: invalidTargetMessage };
+    if (!instance.temporalRunId)
+      return {
+        kind: 'conflict',
+        message: '当前 Workflow 没有可继续的 Temporal Run',
+      };
+    const failedExecution = instance.nodeExecutions.find(
+      (execution) =>
+        execution.nodeId === nodeId && execution.status === 'FAILED',
     );
+    if (!failedExecution)
+      return { kind: 'invalid_input', message: '只能重试当前失败的节点' };
+    try {
+      await temporalService.signalWorkflow(
+        instance.temporalRunId,
+        'retryNode',
+        {
+          nodeId,
+          requestId: `retry-node:${
+            instance.id
+          }:${nodeId}:${failedExecution.updatedAt.toISOString()}`,
+        },
+      );
+    } catch (error) {
+      this.logger.error(
+        `workflow_node_retry_signal_failed - instanceId: ${
+          instance.id
+        }, nodeId: ${nodeId}, error: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+      throw error;
+    }
+    this.logger.log(
+      `workflow_node_retry_signal_sent - instanceId: ${instance.id}, nodeId: ${nodeId}`,
+    );
+    return { kind: 'ok', value: workflowExecutionResult(instance) };
   }
 
   async approveInstance(
@@ -2868,15 +2885,13 @@ export class WorkflowService {
 function createWorkflowExecutionState(
   value: Record<string, any> | undefined,
   operationScopeId?: string,
-  retryCheckpoint?: WorkflowRetryCheckpoint,
 ): Record<string, any> {
   return {
     workflow: value ?? {},
     nodes: {},
-    ...((operationScopeId || retryCheckpoint) && {
+    ...(operationScopeId && {
       system: {
-        ...(operationScopeId && { operationScopeId }),
-        ...(retryCheckpoint && { retryCheckpoint }),
+        operationScopeId,
       },
     }),
   };
@@ -2887,7 +2902,7 @@ function workflowExecutionResult(instance: {
   versionId: bigint;
   status: string;
   temporalRunId: string | null;
-}) {
+}): WorkflowExecutionResult {
   return {
     instanceId: instance.id.toString(),
     temporalRunId: instance.temporalRunId,
@@ -2910,50 +2925,11 @@ function quoteLiteral(value: string): string {
   return `'${value.replace(/'/g, "''")}'`;
 }
 
-function readRetryCheckpoint(
-  value: unknown,
-): WorkflowRetryCheckpoint | undefined {
-  const checkpoint = asRecord(asRecord(value).system).retryCheckpoint;
-  if (
-    !checkpoint ||
-    typeof checkpoint !== 'object' ||
-    Array.isArray(checkpoint)
-  )
-    return undefined;
-  const record = checkpoint as Record<string, unknown>;
-  if (
-    typeof record.startNodeId !== 'string' ||
-    !Array.isArray(record.completedNodeIds) ||
-    !record.completedNodeIds.every((item) => typeof item === 'string') ||
-    !record.outputs ||
-    typeof record.outputs !== 'object' ||
-    Array.isArray(record.outputs)
-  )
-    return undefined;
-  const outputs = record.outputs as Record<string, unknown>;
-  if (
-    !record.completedNodeIds.every((nodeId) =>
-      Object.prototype.hasOwnProperty.call(outputs, nodeId),
-    )
-  )
-    return undefined;
-  return {
-    startNodeId: record.startNodeId,
-    completedNodeIds: record.completedNodeIds,
-    outputs,
-  };
-}
-
-function buildRetryCheckpoint(
+function validateSameRunRetryTarget(
   dslValue: unknown,
-  nodeExecutions: Array<{
-    nodeId: string;
-    status: string;
-    output: unknown;
-  }>,
-  retryFromNodeId: string,
-  inheritedCheckpoint?: WorkflowRetryCheckpoint,
-): WorkflowRetryCheckpoint {
+  nodeExecutions: Array<{ nodeId: string; status: string }>,
+  nodeId: string,
+): string | undefined {
   const dsl = asRecord(dslValue);
   const nodes = Array.isArray(dsl.nodes)
     ? (dsl.nodes as Array<Record<string, unknown>>)
@@ -2961,128 +2937,41 @@ function buildRetryCheckpoint(
   const edges = Array.isArray(dsl.edges)
     ? (dsl.edges as Array<Record<string, unknown>>)
     : [];
-  const target = nodes.find((node) => node.id === retryFromNodeId);
-  if (!target) throw new BadRequestException('失败节点不在原发布版本中');
-  if (!RETRYABLE_MAIN_FLOW_NODE_TYPES.has(String(target.type))) {
-    throw new BadRequestException('该节点暂不支持从这里重试');
-  }
+  const target = nodes.find((node) => node.id === nodeId);
+  if (!target) return '失败节点不在原发布版本中';
+  const nodeType = String(target.type ?? '');
+  if (nodeType.endsWith('_trigger')) return '触发节点不能重试';
+  const isCompositeOwner = nodeType === 'parallel' || nodeType === 'for_each';
   if (
+    !isCompositeOwner &&
     edges.some(
       (edge) =>
         typeof edge.pairId === 'string' &&
         edge.pairId.length > 0 &&
-        (edge.source === retryFromNodeId || edge.target === retryFromNodeId),
+        (edge.source === nodeId || edge.target === nodeId),
     )
-  ) {
-    throw new BadRequestException('暂不支持从循环或并行分支内部重试');
-  }
-
-  const executionMap = new Map<
-    string,
-    { nodeId: string; status: string; output: unknown }
-  >();
-  for (const completedNodeId of inheritedCheckpoint?.completedNodeIds ?? []) {
-    executionMap.set(completedNodeId, {
-      nodeId: completedNodeId,
-      status: 'COMPLETED',
-      output: inheritedCheckpoint?.outputs[completedNodeId],
-    });
-  }
-  for (const execution of nodeExecutions) {
-    executionMap.set(execution.nodeId, execution);
-  }
-  if (executionMap.get(retryFromNodeId)?.status !== 'FAILED') {
-    throw new BadRequestException('只能从实际失败的节点重试');
-  }
-
-  const mainPredecessors = new Map<string, string[]>();
-  for (const edge of edges) {
-    if (
-      (edge.kind === undefined || edge.kind === 'FLOW') &&
-      !edge.pairId &&
-      typeof edge.source === 'string' &&
-      typeof edge.target === 'string'
-    ) {
-      const predecessors = mainPredecessors.get(edge.target) ?? [];
-      predecessors.push(edge.source);
-      mainPredecessors.set(edge.target, predecessors);
-    }
-  }
-
-  const nodeMap = new Map(
-    nodes
-      .filter((node) => typeof node.id === 'string')
-      .map((node) => [String(node.id), node]),
-  );
-  const ancestors = new Set<string>();
-  const pending = [...(mainPredecessors.get(retryFromNodeId) ?? [])];
-  while (pending.length > 0) {
-    const current = pending.pop();
-    if (!current) continue;
-    if (ancestors.has(current)) continue;
-    ancestors.add(current);
-    pending.push(...(mainPredecessors.get(current) ?? []));
-  }
-
-  const completedNodeIds: string[] = [];
-  const outputs: Record<string, unknown> = {};
-  for (const node of nodes) {
-    const ancestorId = typeof node.id === 'string' ? node.id : '';
-    if (!ancestorId || !ancestors.has(ancestorId)) continue;
-    if (String(node.type).endsWith('_trigger')) continue;
-    const execution = executionMap.get(ancestorId);
-    if (execution?.status !== 'COMPLETED') {
-      throw new BadRequestException(
-        `节点“${String(
-          node.label || node.type || ancestorId,
-        )}”没有可复用的成功结果`,
-      );
-    }
-    completedNodeIds.push(ancestorId);
-    outputs[ancestorId] = execution.output;
-  }
-
-  const immediatePredecessors = mainPredecessors.get(retryFromNodeId) ?? [];
-  if (immediatePredecessors.length > 1) {
-    throw new BadRequestException('失败节点存在多个上游，暂不支持从这里重试');
-  }
+  )
+    return '请从外层循环或并行节点重试';
   if (
-    immediatePredecessors.length === 1 &&
-    !String(nodeMap.get(immediatePredecessors[0])?.type ?? '').endsWith(
-      '_trigger',
-    ) &&
-    !Object.prototype.hasOwnProperty.call(outputs, immediatePredecessors[0])
-  ) {
-    throw new BadRequestException('失败节点的上一步没有可复用结果');
-  }
-
-  return { startNodeId: retryFromNodeId, completedNodeIds, outputs };
+    !nodeExecutions.some(
+      (execution) =>
+        execution.nodeId === nodeId && execution.status === 'FAILED',
+    )
+  )
+    return '只能重试当前失败的节点';
+  return undefined;
 }
 
-function listRetryableNodeIds(
+function listSameRunRetryableNodeIds(
   dsl: unknown,
-  nodeExecutions: Array<{
-    nodeId: string;
-    status: string;
-    output: unknown;
-  }>,
-  inheritedCheckpoint?: WorkflowRetryCheckpoint,
+  nodeExecutions: Array<{ nodeId: string; status: string }>,
 ): string[] {
   return nodeExecutions
     .filter((execution) => execution.status === 'FAILED')
-    .filter((execution) => {
-      try {
-        buildRetryCheckpoint(
-          dsl,
-          nodeExecutions,
-          execution.nodeId,
-          inheritedCheckpoint,
-        );
-        return true;
-      } catch {
-        return false;
-      }
-    })
+    .filter(
+      (execution) =>
+        !validateSameRunRetryTarget(dsl, nodeExecutions, execution.nodeId),
+    )
     .map((execution) => execution.nodeId);
 }
 

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/config/routeRegistry.test.ts

@@ -10,11 +10,13 @@ describe('workflow route placement', () => {
 });
 
 describe('person and access routes', () => {
-  it('keeps people, groups and access authorization as separate pages', () => {
-    expect(getRoutePath('person_directory')).toBe('/admin/permission/people');
-    expect(getRoutePath('people_group')).toBe(
-      '/admin/permission/people-groups',
-    );
+  it('merges service/connection/people pages into workflow settings', () => {
+    expect(getRoutePath('workflow_settings')).toBe('/admin/workflow/settings');
+    expect(getRoutePath('person_directory')).toBeNull();
+    expect(getRoutePath('people_group')).toBeNull();
+    expect(getRoutePath('workflow_temporal_tenant')).toBeNull();
+    expect(getRoutePath('workflow_connections')).toBeNull();
+    expect(getRoutePath('workflow_event_catalog')).toBeNull();
     expect(getRoutePath('user')).toBe('/admin/permission/user');
   });
 });

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/config/routeRegistry.tsx

@@ -191,31 +191,13 @@ export const routeRegistry: Record<string, RouteEntry> = {
               })),
             ),
           },
-          // 人员目录 — code: person_directory
-          person_directory: {
-            path: 'people',
-            component: lazyWithReload(() =>
-              import('routes/person-directory').then((m) => ({
-                default: m.default,
-              })),
-            ),
-          },
-          // 访问授权 — 保留 user code/path，兼容既有页面权限和链接
+          // 用户管理 — 保留 user code/path，兼容既有页面权限和链接
           user: {
             path: 'user',
             component: lazyWithReload(() =>
               import('routes/user').then((m) => ({ default: m.UserListPage })),
             ),
           },
-          // 人员组 — code: people_group
-          people_group: {
-            path: 'people-groups',
-            component: lazyWithReload(() =>
-              import('routes/people-groups').then((m) => ({
-                default: m.default,
-              })),
-            ),
-          },
           // 角色管理
           role: {
             path: 'role-list',
@@ -379,24 +361,12 @@ export const routeRegistry: Record<string, RouteEntry> = {
               () => import('routes/workflow/node-instances/show'),
             ),
           },
-          workflow_temporal_tenant: {
-            path: 'temporal-tenant',
-            component: lazyWithReload(
-              () => import('routes/workflow/temporal-tenant'),
-            ),
-          },
-          workflow_connections: {
-            path: 'connections',
-            component: lazyWithReload(
-              () => import('routes/workflow/connections'),
-            ),
-          },
-          workflow_event_catalog: {
-            path: 'business-events',
-            component: lazyWithReload(
-              () => import('routes/workflow/business-events'),
-            ),
+          // 功能设置 — 合并原服务注册/连接管理/人员目录/人员组四个页面
+          workflow_settings: {
+            path: 'settings',
+            component: lazyWithReload(() => import('routes/workflow/settings')),
           },
+          // 业务事件运行记录详情（列表已并入功能设置 tab，此路由保留详情深链）
           businessEventDetail: {
             path: 'business-events/show/:registrationCode',
             component: lazyWithReload(