@gadmin2n/schematics 0.0.144 → 0.0.146

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

@@ -1,20 +1,31 @@
 import {
   BadRequestException,
+  ConflictException,
   Injectable,
   Logger,
   NotFoundException,
   UnauthorizedException,
 } from '@nestjs/common';
+import { Interval } from '@nestjs/schedule';
 import { Prisma } from '@prisma/client';
+import { CronExpressionParser } from 'cron-parser';
 import { PrismaService } from 'nestjs-prisma';
+import { createHash } from 'node:crypto';
 import { HumanApprovalService } from '../humanApproval/human-approval.service';
 import { validateDslGraph } from './dsl-validate.util';
-import { TemporalService } from './temporal.service';
-import { verifyWebhookSignature } from './webhook-signature.util';
 import {
-  describeCallableWorkflow,
-  validateCallableWorkflow,
-} from './workflow-callable';
+  assertManualWorkflowExecution,
+  normalizeIdempotencyKey,
+  scopedIdempotencyKey,
+  workflowDataHash,
+} from './manual-workflow-execution';
+import {
+  TemporalService,
+  WorkflowRetryCheckpoint,
+  workflowTemporalId,
+} from './temporal.service';
+import { verifyWebhookSignature } from './webhook-signature.util';
+import { describeCallableWorkflow } from './workflow-callable';
 import { WorkflowCompilerService } from './workflow-compiler.service';
 import { DraftWorkflowDsl } from './workflow-compiler.types';
 import { validateWorkflowDataEdges } from './workflow-data-edge.util';
@@ -24,6 +35,322 @@ import {
   validateWorkflowHandles,
 } from './workflow-handle-validator';
 
+export interface EventCatalogDeliveryRow {
+  registrationCode: string;
+  createdAt: Date;
+  status: string;
+  processedAt: Date | null;
+  retryCount: number;
+  lastError: string | null;
+}
+
+interface BusinessEventInstanceRow {
+  id: bigint;
+  workflowId: bigint;
+  workflowName: string;
+  version: number;
+  status: string;
+  retryOfInstanceId: bigint | null;
+  startedAt: Date | null;
+  finishedAt: Date | null;
+  createdAt: Date;
+}
+
+export interface BusinessEventCatalogItem {
+  registrationCode: string;
+  label: string;
+  schemaName: string;
+  tableName: string;
+  operation: 'INSERT' | 'UPDATE' | 'DELETE';
+  watchedFields: string[];
+  primaryKeyFields: string[];
+  isEnabled: boolean;
+  fields: Array<{
+    path: string;
+    label: string;
+    description?: string;
+    type: string;
+    required: boolean;
+    primaryKey: boolean;
+    nullable: boolean;
+  }>;
+  defaultKeyPath?: string;
+}
+
+interface BusinessEventColumnRow {
+  schemaName: string;
+  tableName: string;
+  columnName: string;
+  dataType: string;
+  nullable: boolean;
+  primaryKey: boolean;
+}
+
+type CronSchedulePlan =
+  | { kind: 'NONE'; workflowId: bigint }
+  | { kind: 'DELETE'; workflowId: bigint }
+  | {
+      kind: 'UPSERT';
+      workflowId: bigint;
+      isEnabled: boolean;
+      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;
+}
+
+function dslUsesBusinessEvent(dsl: unknown, registrationCode: string): boolean {
+  const value = asRecord(dsl);
+  const nodes = Array.isArray(value.nodes) ? value.nodes : [];
+  return nodes.some((item) => {
+    const node = asRecord(item);
+    return (
+      node.type === 'event_trigger' &&
+      asRecord(node.config).registrationCode === registrationCode
+    );
+  });
+}
+
+export function buildBusinessEventCatalog(
+  rows: Array<{
+    code: string;
+    schemaName: string;
+    tableName: string;
+    operation: string;
+    watchedFields: Prisma.JsonValue;
+    primaryKeyFields: Prisma.JsonValue;
+    isEnabled: boolean;
+  }>,
+  columns: BusinessEventColumnRow[],
+): BusinessEventCatalogItem[] {
+  return rows.map((row) => {
+    const watchedFields = stringArray(row.watchedFields);
+    const primaryKeyFields = stringArray(row.primaryKeyFields);
+    const sourceColumns = columns.filter(
+      (column) =>
+        column.schemaName === row.schemaName &&
+        column.tableName === row.tableName,
+    );
+    const prefixes =
+      row.operation === 'INSERT'
+        ? ['after']
+        : row.operation === 'DELETE'
+        ? ['before']
+        : ['before', 'after'];
+    const fields = [
+      ...primaryKeyFields.flatMap((columnName) => {
+        const column = sourceColumns.find(
+          (candidate) => candidate.columnName === columnName,
+        );
+        return column
+          ? [eventField(`primaryKey.${columnName}`, column, true, false)]
+          : [];
+      }),
+      ...prefixes.flatMap((prefix) =>
+        sourceColumns.map((column) =>
+          eventField(
+            `${prefix}.${column.columnName}`,
+            column,
+            false,
+            column.nullable,
+          ),
+        ),
+      ),
+    ];
+    return {
+      registrationCode: row.code,
+      label: `${row.schemaName}.${row.tableName} · ${row.operation}`,
+      schemaName: row.schemaName,
+      tableName: row.tableName,
+      operation: row.operation as BusinessEventCatalogItem['operation'],
+      watchedFields,
+      primaryKeyFields,
+      isEnabled: row.isEnabled,
+      fields,
+      ...(primaryKeyFields[0]
+        ? { defaultKeyPath: `primaryKey.${primaryKeyFields[0]}` }
+        : {}),
+    };
+  });
+}
+
+export function unknownBusinessEventNames(
+  dsl: unknown,
+  catalog: Array<{ registrationCode: string }>,
+): string[] {
+  const value = asRecord(dsl);
+  const nodes = Array.isArray(value.nodes) ? value.nodes : [];
+  const available = new Set(catalog.map((item) => item.registrationCode));
+  return [
+    ...new Set(
+      nodes.flatMap((item) => {
+        const node = asRecord(item);
+        if (node.type !== 'event_trigger') return [];
+        const registrationCode = asRecord(node.config).registrationCode;
+        return typeof registrationCode === 'string' &&
+          !available.has(registrationCode)
+          ? [registrationCode]
+          : [];
+      }),
+    ),
+  ];
+}
+
+export function validateBusinessEventTriggers(
+  dsl: unknown,
+  catalog: BusinessEventCatalogItem[],
+): void {
+  const value = asRecord(dsl);
+  const nodes = Array.isArray(value.nodes) ? value.nodes : [];
+  const eventByCode = new Map(
+    catalog.map((event) => [event.registrationCode, event] as const),
+  );
+
+  for (const item of nodes) {
+    const node = asRecord(item);
+    if (node.type !== 'event_trigger') continue;
+    const config = asRecord(node.config);
+    const registrationCode = String(config.registrationCode ?? '');
+    const event = eventByCode.get(registrationCode);
+    if (!event) continue;
+
+    validateBusinessEventMatch(config.match, event);
+
+    if (config.processingMode !== 'SERIAL_BY_KEY') continue;
+
+    const keyPath = String(config.concurrencyKeyPath ?? '');
+    const field = event.fields.find((candidate) => candidate.path === keyPath);
+    if (
+      !field ||
+      field.nullable ||
+      !['string', 'number', 'boolean'].includes(field.type)
+    )
+      throw new BadRequestException({
+        code: 'WORKFLOW_EVENT_KEY_INVALID',
+        message: `业务事件“${event.label}”的顺序处理字段必须存在、不能为空，并且是文本、数字或是/否`,
+        registrationCode,
+        concurrencyKeyPath: keyPath,
+      });
+  }
+}
+
+const EVENT_MATCH_OPERATORS = new Set(['EQ', 'NEQ', 'EMPTY', 'NOT_EMPTY']);
+const EVENT_MATCH_UNARY_OPERATORS = new Set(['EMPTY', 'NOT_EMPTY']);
+
+function validateBusinessEventMatch(
+  value: unknown,
+  event: BusinessEventCatalogItem,
+): void {
+  if (value === undefined) return;
+  const match = asRecord(value);
+  const conditions = Array.isArray(match.conditions) ? match.conditions : [];
+  if (
+    !['AND', 'OR'].includes(String(match.combineOperation)) ||
+    conditions.length === 0
+  ) {
+    throw invalidBusinessEventMatch(event, '启动条件至少需要一条有效条件');
+  }
+
+  for (const item of conditions) {
+    const condition = asRecord(item);
+    const left = asRecord(condition.left);
+    const path = String(left.path ?? '');
+    const field = event.fields.find((candidate) => candidate.path === path);
+    if (
+      left.source !== 'WORKFLOW' ||
+      !field ||
+      !['string', 'number', 'boolean'].includes(field.type)
+    ) {
+      throw invalidBusinessEventMatch(
+        event,
+        `字段“${path || '未选择'}”不存在或不支持用于启动条件`,
+      );
+    }
+
+    const operator = String(condition.operator ?? '');
+    if (!EVENT_MATCH_OPERATORS.has(operator)) {
+      throw invalidBusinessEventMatch(event, '启动条件的判断方式无效');
+    }
+    if (EVENT_MATCH_UNARY_OPERATORS.has(operator)) continue;
+
+    const right = asRecord(condition.right);
+    const expectedValueType =
+      field.type === 'number'
+        ? 'NUMBER'
+        : field.type === 'boolean'
+        ? 'BOOLEAN'
+        : 'STRING';
+    if (
+      right.source !== 'FIXED' ||
+      right.valueType !== expectedValueType ||
+      typeof right.value !== 'string' ||
+      (expectedValueType === 'NUMBER' &&
+        (!right.value.trim() || !Number.isFinite(Number(right.value)))) ||
+      (expectedValueType === 'BOOLEAN' &&
+        !['true', 'false'].includes(right.value))
+    ) {
+      throw invalidBusinessEventMatch(event, `字段“${path}”的比较值类型不正确`);
+    }
+  }
+}
+
+function invalidBusinessEventMatch(
+  event: BusinessEventCatalogItem,
+  message: string,
+): BadRequestException {
+  return new BadRequestException({
+    code: 'WORKFLOW_EVENT_MATCH_INVALID',
+    message: `业务事件“${event.label}”的${message}`,
+    registrationCode: event.registrationCode,
+  });
+}
+
+function stringArray(value: Prisma.JsonValue): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === 'string')
+    : [];
+}
+
+function eventField(
+  path: string,
+  column: BusinessEventColumnRow,
+  primaryKey: boolean,
+  nullable: boolean,
+) {
+  return {
+    path,
+    label: path,
+    type: postgresTypeToFieldType(column.dataType),
+    required: !nullable,
+    primaryKey,
+    nullable,
+  };
+}
+
+function postgresTypeToFieldType(dataType: string): string {
+  if (
+    /^(smallint|integer|bigint|numeric|decimal|real|double precision)/.test(
+      dataType,
+    )
+  )
+    return 'number';
+  if (dataType === 'boolean') return 'boolean';
+  if (dataType === 'json' || dataType === 'jsonb') return 'object';
+  return 'string';
+}
+
 @Injectable()
 export class WorkflowService {
   private readonly logger = new Logger(WorkflowService.name);
@@ -35,33 +362,161 @@ export class WorkflowService {
     private workflowCompiler: WorkflowCompilerService,
   ) {}
 
-  private validateCallableDraft(dsl: any): void {
-    if (
-      !Array.isArray(dsl?.nodes) ||
-      !dsl.nodes.some((node: any) => node?.type === 'callable_trigger')
-    )
-      return;
-    try {
-      validateCallableWorkflow(dsl);
-    } catch (error) {
-      throw new BadRequestException({
-        code: 'CALLABLE_WORKFLOW_INVALID',
-        message:
-          error instanceof Error ? error.message : '可调用 Workflow 配置无效',
-      });
-    }
-  }
-
   /**
    * Find the cron_trigger node config in a DSL, if any.
-   * Returns null when no cron_trigger node or when its `cron` field is missing.
+   * Returns null when no cron_trigger node or when its schedule is missing.
    */
   private extractCronConfig(
     dsl: any,
-  ): { cron: string; timezone?: string } | null {
+  ): { cronExpressions: string[]; timezone?: string } | null {
     const node = dsl?.nodes?.find((n: any) => n?.type === 'cron_trigger');
-    if (!node?.config?.cron) return null;
-    return { cron: node.config.cron, timezone: node.config.timezone };
+    if (!node?.config?.cronExpressions?.length) return null;
+    return {
+      cronExpressions: node.config.cronExpressions,
+      timezone: node.config.timezone,
+    };
+  }
+
+  private validateCronConfig(config: {
+    cronExpressions: string[];
+    timezone?: string;
+  }): void {
+    try {
+      if (config.cronExpressions.length === 0) throw new Error();
+      for (const cronExpression of config.cronExpressions) {
+        CronExpressionParser.parse(cronExpression, {
+          ...(config.timezone && { tz: config.timezone }),
+        });
+      }
+    } catch {
+      throw new BadRequestException({
+        code: 'WORKFLOW_CRON_INVALID',
+        message: '定时触发的 Cron 表达式或时区无效',
+      });
+    }
+  }
+
+  private async syncCronSchedule(
+    workflowId: bigint,
+    version: { id: bigint; dsl: unknown },
+  ): Promise<void> {
+    const cronConfig = this.extractCronConfig(version.dsl);
+    if (cronConfig) {
+      this.validateCronConfig(cronConfig);
+      await this.temporalService.upsertCronSchedule({
+        workflowId: Number(workflowId),
+        versionId: Number(version.id),
+        dsl: version.dsl,
+        cronExpressions: cronConfig.cronExpressions,
+        timezone: cronConfig.timezone,
+      });
+      return;
+    }
+    await this.temporalService.deleteCronSchedule(Number(workflowId));
+  }
+
+  private hasCronHistory(versions: Array<{ dsl: unknown }> | undefined) {
+    return Boolean(
+      versions?.some((version) => this.extractCronConfig(version.dsl)),
+    );
+  }
+
+  private async readCronSchedulePlanLocked(
+    tx: Prisma.TransactionClient,
+    workflowId: bigint,
+  ): Promise<{ active: boolean; plan: CronSchedulePlan }> {
+    const rows = await tx.$queryRaw<
+      Array<{ isEnabled: boolean; status: string }>
+    >`SELECT is_enabled AS "isEnabled", status::text AS status
+        FROM t_workflow
+       WHERE id = ${workflowId}
+       FOR UPDATE`;
+    const workflow = rows[0];
+    if (!workflow || workflow.status === 'DELETING')
+      return { active: false, plan: { kind: 'NONE', workflowId } };
+
+    const versions = await tx.workflowVersion.findMany({
+      where: { workflowId },
+      orderBy: { version: 'desc' },
+      select: { id: true, dsl: true },
+    });
+    const latestVersion = versions[0];
+    if (!latestVersion || !this.hasCronHistory(versions))
+      return { active: true, plan: { kind: 'NONE', workflowId } };
+
+    const cronConfig = this.extractCronConfig(latestVersion.dsl);
+    if (!cronConfig)
+      return { active: true, plan: { kind: 'DELETE', workflowId } };
+
+    return {
+      active: true,
+      plan: {
+        kind: 'UPSERT',
+        workflowId,
+        isEnabled: workflow.isEnabled,
+        version: latestVersion,
+      },
+    };
+  }
+
+  private async applyCronSchedulePlan(plan: CronSchedulePlan): Promise<void> {
+    if (plan.kind === 'NONE') return;
+    if (plan.kind === 'DELETE') {
+      await this.temporalService.deleteCronSchedule(Number(plan.workflowId));
+      return;
+    }
+
+    await this.syncCronSchedule(plan.workflowId, plan.version);
+    if (plan.isEnabled)
+      await this.temporalService.unpauseCronSchedule(Number(plan.workflowId));
+    else await this.temporalService.pauseCronSchedule(Number(plan.workflowId));
+  }
+
+  private cronSchedulePlanKey(plan: CronSchedulePlan): string {
+    if (plan.kind !== 'UPSERT') return plan.kind;
+    return `${plan.kind}:${plan.version.id}:${plan.isEnabled}`;
+  }
+
+  private async reconcileCronScheduleCurrent(
+    workflowId: bigint,
+  ): Promise<boolean> {
+    let snapshot = await this.prisma.$transaction((tx) =>
+      this.readCronSchedulePlanLocked(tx, workflowId),
+    );
+    if (!snapshot.active) return false;
+
+    for (let attempt = 0; attempt < 3; attempt++) {
+      await this.applyCronSchedulePlan(snapshot.plan);
+      const latest = await this.prisma.$transaction((tx) =>
+        this.readCronSchedulePlanLocked(tx, workflowId),
+      );
+      if (!latest.active) return false;
+      if (
+        this.cronSchedulePlanKey(latest.plan) ===
+        this.cronSchedulePlanKey(snapshot.plan)
+      )
+        return true;
+      snapshot = latest;
+    }
+    return true;
+  }
+
+  private workflowDeletingError() {
+    return new ConflictException({
+      code: 'WORKFLOW_DELETING',
+      message: 'Workflow 正在删除，不能再修改或执行',
+    });
+  }
+
+  private hasUnpublishedChanges(workflow: {
+    dsl: unknown;
+    versions?: Array<{ dsl?: unknown }>;
+  }): boolean {
+    const latest = workflow.versions?.[0]?.dsl;
+    return Boolean(
+      workflow.dsl &&
+        (!latest || !areWorkflowDslSourcesEqual(workflow.dsl, latest)),
+    );
   }
 
   /**
@@ -73,8 +528,6 @@ export class WorkflowService {
     method: string;
     secret?: string;
     verificationMode: 'HMAC' | 'NONE';
-    responseMode: 'IMMEDIATE' | 'WAIT_FOR_RESULT';
-    responseTimeoutSeconds: number;
   }> {
     if (!Array.isArray(dsl?.nodes)) return [];
     return dsl.nodes
@@ -88,16 +541,6 @@ export class WorkflowService {
         secret: n.config.secret,
         verificationMode:
           n.config.verificationMode === 'NONE' ? 'NONE' : 'HMAC',
-        responseMode:
-          n.config.responseMode === 'WAIT_FOR_RESULT'
-            ? 'WAIT_FOR_RESULT'
-            : 'IMMEDIATE',
-        responseTimeoutSeconds:
-          Number.isInteger(n.config.responseTimeoutSeconds) &&
-          n.config.responseTimeoutSeconds >= 1 &&
-          n.config.responseTimeoutSeconds <= 300
-            ? n.config.responseTimeoutSeconds
-            : 60,
       }));
   }
 
@@ -129,7 +572,7 @@ export class WorkflowService {
           versions: {
             orderBy: { version: 'desc' },
             take: 1,
-            select: { version: true, changeSummary: true },
+            select: { version: true, changeSummary: true, dsl: true },
           },
           _count: { select: { instances: true } },
         },
@@ -178,6 +621,7 @@ export class WorkflowService {
 
     const enrichedItems = items.map((item) => ({
       ...item,
+      hasUnpublishedChanges: this.hasUnpublishedChanges(item),
       runs: runsMap.get(item.id) || {
         pending: 0,
         running: 0,
@@ -192,43 +636,54 @@ export class WorkflowService {
 
   async findCallableWorkflows() {
     const workflows = await this.prisma.workflow.findMany({
-      where: { status: 'PUBLISHED', isEnabled: true },
+      where: { isEnabled: true, versions: { some: {} } },
       orderBy: { name: 'asc' },
       include: {
         versions: {
           orderBy: { version: 'desc' },
-          take: 1,
-          select: { dsl: true },
+          select: { id: true, version: true, dsl: true },
         },
       },
     });
     return workflows.flatMap((workflow) => {
-      try {
-        const descriptor = describeCallableWorkflow(workflow.versions[0]?.dsl);
-        if (!descriptor) return [];
-        return [
-          {
-            id: String(workflow.id),
-            name: workflow.name,
-            description: workflow.description,
-            inputParameters: descriptor.inputParameters,
-          },
-        ];
-      } catch {
-        return [];
-      }
+      const versions = workflow.versions.flatMap((version) => {
+        try {
+          const descriptor = describeCallableWorkflow(version.dsl);
+          return descriptor
+            ? [
+                {
+                  id: String(version.id),
+                  version: version.version,
+                  inputParameters: descriptor.inputParameters,
+                },
+              ]
+            : [];
+        } catch {
+          return [];
+        }
+      });
+      if (versions.length === 0) return [];
+      return [
+        {
+          id: String(workflow.id),
+          name: workflow.name,
+          description: workflow.description,
+          latestVersionId: versions[0].id,
+          versions,
+        },
+      ];
     });
   }
 
   async findExternalInteractionOptions() {
     const workflows = await this.prisma.workflow.findMany({
-      where: { status: 'PUBLISHED', isEnabled: true },
+      where: { isEnabled: true, versions: { some: {} } },
       orderBy: { name: 'asc' },
       include: {
         versions: {
           orderBy: { version: 'desc' },
           take: 1,
-          select: { dsl: true },
+          select: { id: true, version: true, dsl: true },
         },
       },
     });
@@ -254,6 +709,472 @@ export class WorkflowService {
     return { dispatchWorkflows: [], callbackWorkflows };
   }
 
+  async findBusinessEventCatalog() {
+    const [events, columns, schemaName] = await Promise.all([
+      this.prisma.workflowBusinessEventRegistration.findMany({
+        where: { isEnabled: true },
+        orderBy: [
+          { schemaName: 'asc' },
+          { tableName: 'asc' },
+          { operation: 'asc' },
+        ],
+      }),
+      this.findBusinessEventColumns(),
+      this.findBusinessEventSchema(),
+    ]);
+    return {
+      items: buildBusinessEventCatalog(
+        events.filter((event) => event.schemaName === schemaName),
+        columns,
+      ),
+    };
+  }
+
+  async findBusinessEventSources() {
+    const columns = await this.findBusinessEventColumns();
+    const sources = new Map<
+      string,
+      {
+        schemaName: string;
+        tableName: string;
+        columns: Array<{
+          name: string;
+          dataType: string;
+          nullable: boolean;
+          primaryKey: boolean;
+        }>;
+      }
+    >();
+    for (const column of columns) {
+      const key = `${column.schemaName}.${column.tableName}`;
+      const source = sources.get(key) ?? {
+        schemaName: column.schemaName,
+        tableName: column.tableName,
+        columns: [],
+      };
+      source.columns.push({
+        name: column.columnName,
+        dataType: column.dataType,
+        nullable: column.nullable,
+        primaryKey: column.primaryKey,
+      });
+      sources.set(key, source);
+    }
+    return { items: [...sources.values()] };
+  }
+
+  private async findBusinessEventColumns(): Promise<BusinessEventColumnRow[]> {
+    return this.prisma.$queryRaw<BusinessEventColumnRow[]>`
+      SELECT
+        namespace.nspname AS "schemaName",
+        relation.relname AS "tableName",
+        attribute.attname AS "columnName",
+        format_type(attribute.atttypid, attribute.atttypmod) AS "dataType",
+        NOT attribute.attnotnull AS nullable,
+        EXISTS (
+          SELECT 1 FROM pg_index primary_index
+          WHERE primary_index.indrelid = relation.oid
+            AND primary_index.indisprimary
+            AND attribute.attnum = ANY(primary_index.indkey)
+        ) AS "primaryKey"
+      FROM pg_class relation
+      JOIN pg_namespace namespace ON namespace.oid = relation.relnamespace
+      JOIN pg_attribute attribute ON attribute.attrelid = relation.oid
+      WHERE relation.relkind IN ('r', 'p')
+        AND namespace.nspname = current_schema()
+        AND attribute.attnum > 0
+        AND NOT attribute.attisdropped
+        AND relation.relname NOT LIKE 't_workflow%'
+        AND relation.relname NOT LIKE 't_external_interaction%'
+        AND relation.relname NOT LIKE 't_approval%'
+      ORDER BY namespace.nspname, relation.relname, attribute.attnum
+    `;
+  }
+
+  private async findBusinessEventSchema(): Promise<string> {
+    const rows = await this.prisma.$queryRaw<Array<{ schemaName: string }>>`
+      SELECT current_schema() AS "schemaName"
+    `;
+    return rows[0]?.schemaName || 'public';
+  }
+
+  async registerBusinessEvent(
+    data: {
+      schemaName: string;
+      tableName: string;
+      operation: 'INSERT' | 'UPDATE' | 'DELETE';
+      watchedFields: string[];
+    },
+    creator: string,
+  ) {
+    const [columns, currentSchema] = await Promise.all([
+      this.findBusinessEventColumns(),
+      this.findBusinessEventSchema(),
+    ]);
+    if (data.schemaName !== currentSchema)
+      throw new BadRequestException(
+        `只能登记当前数据库 Schema（${currentSchema}）中的业务表`,
+      );
+    const sourceColumns = columns.filter(
+      (column) =>
+        column.schemaName === data.schemaName &&
+        column.tableName === data.tableName,
+    );
+    if (sourceColumns.length === 0)
+      throw new BadRequestException('请选择可监听的数据库表');
+
+    const requestedFields = [
+      ...new Set(
+        data.watchedFields.map((field) => field.trim()).filter(Boolean),
+      ),
+    ].sort();
+    if (data.operation === 'UPDATE' && requestedFields.length === 0)
+      throw new BadRequestException('请至少选择一个监听字段');
+    const watchedFields =
+      data.operation === 'UPDATE'
+        ? requestedFields
+        : sourceColumns.map((column) => column.columnName).sort();
+    const availableFields = new Set(
+      sourceColumns.map((column) => column.columnName),
+    );
+    const unknownFields = watchedFields.filter(
+      (field) => !availableFields.has(field),
+    );
+    if (unknownFields.length > 0)
+      throw new BadRequestException(`字段不存在：${unknownFields.join('、')}`);
+    const primaryKeyFields = sourceColumns
+      .filter((column) => column.primaryKey)
+      .map((column) => column.columnName);
+    if (primaryKeyFields.length === 0)
+      throw new BadRequestException('被监听表必须有主键');
+
+    const registrationKey = createHash('sha256')
+      .update(
+        JSON.stringify({
+          schemaName: data.schemaName,
+          tableName: data.tableName,
+          operation: data.operation,
+          watchedFields,
+        }),
+      )
+      .digest('hex');
+    const event = await this.prisma.$transaction(async (tx) => {
+      await tx.$queryRaw`
+        SELECT pg_advisory_xact_lock(${WORKFLOW_PUBLISH_LOCK_KEY})::text AS "lock"
+      `;
+      const existing = await tx.workflowBusinessEventRegistration.findUnique({
+        where: { registrationKey },
+      });
+      if (existing?.isEnabled)
+        throw new ConflictException('相同的表字段监听已经登记');
+      const registration = existing
+        ? await tx.workflowBusinessEventRegistration.update({
+            where: { id: existing.id },
+            data: { isEnabled: true, creator },
+          })
+        : await tx.workflowBusinessEventRegistration.create({
+            data: {
+              registrationKey,
+              schemaName: data.schemaName,
+              tableName: data.tableName,
+              operation: data.operation,
+              watchedFields,
+              primaryKeyFields,
+              creator,
+            },
+          });
+      await this.installBusinessEventTrigger(tx, registration);
+      return registration;
+    });
+    this.logger.log(
+      `Registered ${event.operation} listener ${event.schemaName}.${event.tableName} (${event.code})`,
+    );
+    return buildBusinessEventCatalog([event], columns)[0];
+  }
+
+  private async installBusinessEventTrigger(
+    tx: Prisma.TransactionClient,
+    event: {
+      id: bigint;
+      schemaName: string;
+      tableName: string;
+      operation: string;
+      watchedFields: Prisma.JsonValue;
+      primaryKeyFields: Prisma.JsonValue;
+    },
+  ) {
+    const schema = quoteIdentifier(event.schemaName);
+    const table = quoteIdentifier(event.tableName);
+    const functionName = quoteIdentifier(`gadmin_wf_event_fn_${event.id}`);
+    const triggerName = quoteIdentifier(`gadmin_wf_event_${event.id}`);
+    const watchedFields = stringArray(event.watchedFields);
+    const primaryKeyFields = stringArray(event.primaryKeyFields);
+    const fieldArray = `ARRAY[${watchedFields
+      .map(quoteLiteral)
+      .join(', ')}]::text[]`;
+    const primaryKey = `jsonb_build_object(${primaryKeyFields
+      .flatMap((field) => [
+        quoteLiteral(field),
+        `COALESCE(after_row -> ${quoteLiteral(
+          field,
+        )}, before_row -> ${quoteLiteral(field)})`,
+      ])
+      .join(', ')})`;
+    const workflowSchemaRows = await tx.$queryRaw<
+      Array<{ schemaName: string }>
+    >`SELECT current_schema() AS "schemaName"`;
+    const workflowSchema = quoteIdentifier(
+      workflowSchemaRows[0]?.schemaName || 'public',
+    );
+    const triggerEvent =
+      event.operation === 'UPDATE'
+        ? `UPDATE OF ${watchedFields.map(quoteIdentifier).join(', ')}`
+        : event.operation;
+
+    await tx.$executeRawUnsafe(`
+      CREATE OR REPLACE FUNCTION ${schema}.${functionName}()
+      RETURNS trigger LANGUAGE plpgsql AS $gadmin_workflow_event$
+      DECLARE
+        before_row jsonb;
+        after_row jsonb;
+        changed_fields jsonb;
+        event_primary_key jsonb;
+      BEGIN
+        before_row := CASE WHEN TG_OP = 'INSERT' THEN NULL ELSE to_jsonb(OLD) END;
+        after_row := CASE WHEN TG_OP = 'DELETE' THEN NULL ELSE to_jsonb(NEW) END;
+        IF TG_OP = 'UPDATE' THEN
+          SELECT COALESCE(jsonb_agg(field_name), '[]'::jsonb)
+            INTO changed_fields
+            FROM unnest(${fieldArray}) AS field_name
+           WHERE before_row -> field_name IS DISTINCT FROM after_row -> field_name;
+          IF jsonb_array_length(changed_fields) = 0 THEN RETURN NEW; END IF;
+        ELSE
+          SELECT COALESCE(jsonb_agg(field_name ORDER BY field_name), '[]'::jsonb)
+            INTO changed_fields
+            FROM jsonb_object_keys(COALESCE(after_row, before_row)) AS field_name;
+        END IF;
+        event_primary_key := ${primaryKey};
+        INSERT INTO ${workflowSchema}.t_workflow_event_outbox
+          (registration_id, operation, schema_name, table_name, primary_key,
+           before, after, changed_fields, status, retry_count,
+           next_attempt_at, created_at, updated_at)
+        VALUES
+          (${event.id}, TG_OP::${workflowSchema}."WorkflowEventOperation",
+           ${quoteLiteral(event.schemaName)}, ${quoteLiteral(event.tableName)},
+           event_primary_key, before_row, after_row, changed_fields,
+           'PENDING', 0, NOW(), NOW(), NOW());
+        IF TG_OP = 'DELETE' THEN RETURN OLD; END IF;
+        RETURN NEW;
+      END;
+      $gadmin_workflow_event$;
+    `);
+    await tx.$executeRawUnsafe(
+      `DROP TRIGGER IF EXISTS ${triggerName} ON ${schema}.${table}`,
+    );
+    await tx.$executeRawUnsafe(`
+      CREATE TRIGGER ${triggerName}
+      AFTER ${triggerEvent} ON ${schema}.${table}
+      FOR EACH ROW EXECUTE FUNCTION ${schema}.${functionName}()
+    `);
+  }
+
+  async unregisterBusinessEvent(registrationCode: string) {
+    const result = await this.prisma.$transaction(async (tx) => {
+      await tx.$queryRaw`
+        SELECT pg_advisory_xact_lock(${WORKFLOW_PUBLISH_LOCK_KEY})::text AS "lock"
+      `;
+      const event = await tx.workflowBusinessEventRegistration.findUnique({
+        where: { code: registrationCode },
+      });
+      if (!event || !event.isEnabled)
+        throw new NotFoundException('这个业务事件监听尚未登记');
+
+      const workflows = await tx.workflow.findMany({
+        select: {
+          name: true,
+          dsl: true,
+          versions: {
+            orderBy: { version: 'desc' },
+            take: 1,
+            select: { dsl: true },
+          },
+        },
+      });
+      const referencingWorkflows = workflows
+        .filter(
+          (workflow) =>
+            dslUsesBusinessEvent(workflow.dsl, registrationCode) ||
+            dslUsesBusinessEvent(workflow.versions[0]?.dsl, registrationCode),
+        )
+        .map((workflow) => workflow.name);
+      if (referencingWorkflows.length > 0) {
+        throw new ConflictException(
+          `以下 Workflow 仍在使用该监听：${referencingWorkflows.join('、')}`,
+        );
+      }
+
+      const schema = quoteIdentifier(event.schemaName);
+      const table = quoteIdentifier(event.tableName);
+      const functionName = quoteIdentifier(`gadmin_wf_event_fn_${event.id}`);
+      const triggerName = quoteIdentifier(`gadmin_wf_event_${event.id}`);
+      await tx.$executeRawUnsafe(
+        `DROP TRIGGER IF EXISTS ${triggerName} ON ${schema}.${table}`,
+      );
+      await tx.$executeRawUnsafe(
+        `DROP FUNCTION IF EXISTS ${schema}.${functionName}()`,
+      );
+      await tx.workflowBusinessEventRegistration.update({
+        where: { id: event.id },
+        data: { isEnabled: false },
+      });
+      return { registrationCode };
+    });
+    this.logger.log(`Unregistered business event listener ${registrationCode}`);
+    return result;
+  }
+
+  async findBusinessEventCatalogOverview() {
+    const { items } = await this.findBusinessEventCatalog();
+    if (items.length === 0) return { items: [] };
+
+    const workflows = await this.prisma.workflow.findMany({
+      where: { status: 'PUBLISHED', isEnabled: true },
+      select: {
+        id: true,
+        name: true,
+        versions: {
+          orderBy: { version: 'desc' },
+          take: 1,
+          select: { dsl: true },
+        },
+      },
+    });
+    const subscribers = new Map<
+      string,
+      Array<{ workflowId: string; workflowName: string }>
+    >();
+    for (const workflow of workflows) {
+      const dsl = asRecord(workflow.versions[0]?.dsl);
+      const nodes = Array.isArray(dsl.nodes) ? dsl.nodes : [];
+      for (const value of nodes) {
+        const node = asRecord(value);
+        if (node.type !== 'event_trigger') continue;
+        const registrationCode = asRecord(node.config).registrationCode;
+        if (typeof registrationCode !== 'string') continue;
+        const current = subscribers.get(registrationCode) ?? [];
+        current.push({
+          workflowId: workflow.id.toString(),
+          workflowName: workflow.name,
+        });
+        subscribers.set(registrationCode, current);
+      }
+    }
+
+    const registrationCodes = items.map((item) => item.registrationCode);
+    const deliveries = await this.prisma.$queryRaw<EventCatalogDeliveryRow[]>(
+      Prisma.sql`
+        SELECT DISTINCT ON (registration.code)
+          registration.code AS "registrationCode",
+          outbox.created_at AS "createdAt",
+          outbox.status::text AS status,
+          outbox.processed_at AS "processedAt",
+          outbox.retry_count AS "retryCount",
+          outbox.last_error AS "lastError"
+        FROM t_workflow_event_outbox outbox
+        JOIN t_workflow_business_event_registration registration
+          ON registration.id = outbox.registration_id
+        WHERE registration.code IN (${Prisma.join(registrationCodes)})
+        ORDER BY registration.code, outbox.created_at DESC, outbox.id DESC
+      `,
+    );
+    const latestDelivery = new Map(
+      deliveries.map((delivery) => [delivery.registrationCode, delivery]),
+    );
+
+    return {
+      items: items.map((item) => ({
+        ...item,
+        subscribers: subscribers.get(item.registrationCode) ?? [],
+        latestDelivery: latestDelivery.get(item.registrationCode),
+      })),
+    };
+  }
+
+  async findBusinessEventInstances(
+    registrationCode: string,
+    params: { status?: string; skip?: number; limit?: number },
+  ) {
+    const event =
+      await this.prisma.workflowBusinessEventRegistration.findUnique({
+        where: { code: registrationCode },
+      });
+    if (!event) throw new NotFoundException('业务事件不存在');
+    const columns = await this.findBusinessEventColumns();
+
+    const statusFilter = params.status
+      ? Prisma.sql`AND instance.status::text = ${params.status}`
+      : Prisma.empty;
+    const instanceTree = Prisma.sql`
+      WITH RECURSIVE event_instance_tree AS (
+        SELECT instance.id
+        FROM t_workflow_instance instance
+        JOIN t_workflow_event_outbox source_event
+          ON source_event.id = instance.source_outbox_id
+        WHERE source_event.registration_id = ${event.id}
+
+        UNION ALL
+
+        SELECT retry.id
+        FROM t_workflow_instance retry
+        JOIN event_instance_tree parent
+          ON retry.retry_of_instance_id = parent.id
+      )
+    `;
+    const skip = params.skip ?? 0;
+    const limit = params.limit ?? 20;
+    const [rows, countRows] = await Promise.all([
+      this.prisma.$queryRaw<BusinessEventInstanceRow[]>(Prisma.sql`
+        ${instanceTree}
+        SELECT
+          instance.id,
+          instance.workflow_id AS "workflowId",
+          workflow.name AS "workflowName",
+          version.version,
+          instance.status::text AS status,
+          instance.retry_of_instance_id AS "retryOfInstanceId",
+          instance.started_at AS "startedAt",
+          instance.finished_at AS "finishedAt",
+          instance.created_at AS "createdAt"
+        FROM event_instance_tree tree
+        JOIN t_workflow_instance instance ON instance.id = tree.id
+        JOIN t_workflow workflow ON workflow.id = instance.workflow_id
+        JOIN t_workflow_version version ON version.id = instance.version_id
+        WHERE TRUE ${statusFilter}
+        ORDER BY instance.created_at DESC, instance.id DESC
+        OFFSET ${skip}
+        LIMIT ${limit}
+      `),
+      this.prisma.$queryRaw<Array<{ total: bigint }>>(Prisma.sql`
+        ${instanceTree}
+        SELECT COUNT(*)::bigint AS total
+        FROM event_instance_tree tree
+        JOIN t_workflow_instance instance ON instance.id = tree.id
+        WHERE TRUE ${statusFilter}
+      `),
+    ]);
+
+    return {
+      event: buildBusinessEventCatalog([event], columns)[0],
+      items: rows.map((row) => ({
+        ...row,
+        id: row.id.toString(),
+        workflowId: row.workflowId.toString(),
+        retryOfInstanceId: row.retryOfInstanceId?.toString() ?? null,
+      })),
+      total: Number(countRows[0]?.total ?? 0),
+    };
+  }
+
   async findOne(id: bigint) {
     const workflow = await this.prisma.workflow.findUnique({
       where: { id },
@@ -265,14 +1186,22 @@ export class WorkflowService {
       },
     });
     if (!workflow) throw new NotFoundException('Workflow not found');
-    return workflow;
+    const hasCronSchedule = Boolean(
+      this.extractCronConfig(workflow.versions[0]?.dsl),
+    );
+    return {
+      ...workflow,
+      hasUnpublishedChanges: this.hasUnpublishedChanges(workflow),
+      scheduleStatus: hasCronSchedule
+        ? await this.temporalService.getCronScheduleStatus(Number(id))
+        : 'NOT_APPLICABLE',
+    };
   }
 
   async create(
     data: { name: string; description?: string; dsl?: any },
     creator: string,
   ) {
-    this.validateCallableDraft(data.dsl);
     const workflow = await this.prisma.workflow.create({
       data: {
         name: data.name,
@@ -292,71 +1221,96 @@ export class WorkflowService {
   }
 
   async saveDraft(id: bigint, dsl: any) {
-    const workflow = await this.prisma.workflow.findUnique({
-      where: { id },
-      include: {
-        versions: {
-          orderBy: { version: 'desc' },
-          take: 1,
-          select: { dsl: true },
-        },
-      },
-    });
+    const workflow = await this.prisma.workflow.findUnique({ where: { id } });
     if (!workflow) throw new NotFoundException('Workflow not found');
-    this.validateCallableDraft(dsl);
-    const latestPublishedDsl = workflow.versions?.[0]?.dsl;
-    const status =
-      latestPublishedDsl && areWorkflowDslSourcesEqual(dsl, latestPublishedDsl)
-        ? 'PUBLISHED'
-        : 'DRAFT';
-    return this.prisma.workflow.update({
-      where: { id },
-      data: { dsl, status },
+    if (workflow.status === 'DELETING') throw this.workflowDeletingError();
+    return this.prisma.$transaction(async (tx) => {
+      const locked = await tx.$queryRaw<Array<{ status: string }>>`
+        SELECT status::text AS status
+          FROM t_workflow
+         WHERE id = ${id}
+         FOR UPDATE`;
+      if (!locked[0]) throw new NotFoundException('Workflow not found');
+      if (locked[0].status === 'DELETING') throw this.workflowDeletingError();
+
+      const latestVersion = await tx.workflowVersion.findFirst({
+        where: { workflowId: id },
+        orderBy: { version: 'desc' },
+        select: { dsl: true },
+      });
+      const status = latestVersion ? 'PUBLISHED' : 'DRAFT';
+      const updated = await tx.workflow.update({
+        where: { id },
+        data: { dsl, status },
+      });
+      return {
+        ...updated,
+        hasUnpublishedChanges: Boolean(
+          !latestVersion || !areWorkflowDslSourcesEqual(dsl, latestVersion.dsl),
+        ),
+      };
     });
   }
 
   async toggleEnabled(id: bigint, enabled: boolean) {
-    const workflow = await this.prisma.workflow.findUnique({ where: { id } });
-    if (!workflow) throw new NotFoundException('Workflow not found');
-    const updated = await this.prisma.workflow.update({
-      where: { id },
-      data: { isEnabled: enabled },
-    });
+    const workflow = await this.prisma.$transaction(async (tx) => {
+      const changed = await tx.workflow.updateMany({
+        where: { id, status: { not: 'DELETING' } },
+        data: { isEnabled: enabled },
+      });
+      if (changed.count !== 1) {
+        const existing = await tx.workflow.findUnique({ where: { id } });
+        if (!existing) throw new NotFoundException('Workflow not found');
+        throw this.workflowDeletingError();
+      }
 
-    // Cron schedule lifecycle: pause when disabled, resume when re-enabled
+      return tx.workflow.findUniqueOrThrow({ where: { id } });
+    });
     try {
-      if (enabled) {
-        await this.temporalService.unpauseCronSchedule(Number(id));
-      } else {
-        await this.temporalService.pauseCronSchedule(Number(id));
-      }
+      const active = await this.reconcileCronScheduleCurrent(id);
+      if (!active) throw this.workflowDeletingError();
     } catch (err: any) {
-      this.logger.warn(
-        `Failed to ${
-          enabled ? 'unpause' : 'pause'
-        } cron schedule for workflow ${id}: ${err?.message ?? err}`,
+      this.logger.error(
+        `Failed to synchronize cron schedule for workflow ${id}: ${
+          err?.message ?? err
+        }`,
       );
+      throw err;
     }
-
-    return updated;
+    return workflow;
   }
 
   async remove(id: bigint) {
     const workflow = await this.prisma.workflow.findUnique({ where: { id } });
     if (!workflow) throw new NotFoundException('Workflow not found');
+    await this.assertNoWorkflowCallers(id);
 
-    // Best-effort: delete cron schedule before removing the workflow row
-    try {
+    // Phase 1 makes the Workflow unavailable to new executions. The active
+    // instance check is performed while the row is locked by the update.
+    const hadCronSchedule = await this.prisma.$transaction(async (tx) => {
+      await tx.workflow.update({
+        where: { id },
+        data: { isEnabled: false, status: 'DELETING' },
+      });
+      await this.assertNoActiveInstances(tx, id);
+      const versions = await tx.workflowVersion.findMany({
+        where: { workflowId: id },
+        select: { dsl: true },
+      });
+      return this.hasCronHistory(versions);
+    });
+
+    // A failed external delete leaves a disabled, recoverable Workflow row.
+    if (hadCronSchedule)
       await this.temporalService.deleteCronSchedule(Number(id));
-    } catch (err: any) {
-      this.logger.warn(
-        `Failed to delete cron schedule for workflow ${id}: ${
-          err?.message ?? err
-        }`,
-      );
-    }
 
     return this.prisma.$transaction(async (tx) => {
+      await tx.workflow.update({
+        where: { id },
+        data: { isEnabled: false, status: 'DELETING' },
+      });
+      await this.assertNoActiveInstances(tx, id);
+
       const interactions = await tx.externalInteraction.findMany({
         where: {
           OR: [
@@ -381,6 +1335,117 @@ export class WorkflowService {
     });
   }
 
+  private async assertNoActiveInstances(
+    tx: Pick<Prisma.TransactionClient, 'workflowInstance'>,
+    workflowId: bigint,
+  ): Promise<void> {
+    const activeInstances = await tx.workflowInstance.count({
+      where: {
+        workflowId,
+        status: { in: ['PENDING', 'RUNNING'] },
+      },
+    });
+    if (activeInstances > 0)
+      throw new ConflictException({
+        code: 'WORKFLOW_HAS_ACTIVE_INSTANCES',
+        message: '存在运行中或等待中的实例，不能删除 Workflow',
+      });
+  }
+
+  private async assertNoWorkflowCallers(workflowId: bigint): Promise<void> {
+    const workflows = await this.prisma.workflow.findMany({
+      where: { id: { not: workflowId } },
+      select: {
+        id: true,
+        name: true,
+        dsl: true,
+        versions: { select: { version: true, dsl: true } },
+      },
+    });
+    const dsls = (workflows ?? []).flatMap((workflow) => [
+      workflow.dsl,
+      ...(workflow.versions ?? []).map((version) => version.dsl),
+    ]);
+    const referencedInstanceIds = [
+      ...new Set(
+        dsls.flatMap((dsl) => {
+          const nodes = Array.isArray(asRecord(dsl).nodes)
+            ? (asRecord(dsl).nodes as unknown[])
+            : [];
+          return nodes.flatMap((value) => {
+            const node = asRecord(value);
+            if (node.type !== 'sub_workflow') return [];
+            const instanceId = String(
+              asRecord(node.instanceRef).instanceId ?? '',
+            );
+            return /^[1-9]\d*$/.test(instanceId) ? [instanceId] : [];
+          });
+        }),
+      ),
+    ];
+    const referencedInstances = referencedInstanceIds.length
+      ? await this.prisma.workflowNodeInstance.findMany({
+          where: {
+            id: { in: referencedInstanceIds.map((id) => BigInt(id)) },
+          },
+          select: { id: true, config: true },
+        })
+      : [];
+    const instanceConfigs = new Map(
+      referencedInstances.map((instance) => [
+        String(instance.id),
+        asRecord(instance.config),
+      ]),
+    );
+    const callers: Array<{
+      workflowId: string;
+      workflowName: string;
+      source: 'DRAFT' | 'PUBLISHED';
+      version?: number;
+    }> = [];
+    const referencesTarget = (dsl: unknown) => {
+      const nodes = Array.isArray(asRecord(dsl).nodes)
+        ? (asRecord(dsl).nodes as unknown[])
+        : [];
+      return nodes.some((value) => {
+        const node = asRecord(value);
+        if (node.type !== 'sub_workflow') return false;
+        const override = node.configOverride;
+        const instanceId = String(asRecord(node.instanceRef).instanceId ?? '');
+        const config =
+          override && typeof override === 'object' && !Array.isArray(override)
+            ? asRecord(override)
+            : instanceConfigs.get(instanceId) ?? asRecord(node.config);
+        return String(config.workflowId ?? '') === String(workflowId);
+      });
+    };
+
+    for (const workflow of workflows ?? []) {
+      if (referencesTarget(workflow.dsl))
+        callers.push({
+          workflowId: String(workflow.id),
+          workflowName: workflow.name,
+          source: 'DRAFT',
+        });
+      for (const version of workflow.versions ?? []) {
+        if (!referencesTarget(version.dsl)) continue;
+        callers.push({
+          workflowId: String(workflow.id),
+          workflowName: workflow.name,
+          source: 'PUBLISHED',
+          version: version.version,
+        });
+      }
+    }
+
+    if (callers.length > 0)
+      throw new ConflictException({
+        code: 'WORKFLOW_IS_REFERENCED',
+        message: '该 Workflow 仍被其他 Workflow 调用，解除引用后才能删除',
+        callers,
+      });
+  }
+
   async getVersions(workflowId: bigint) {
     return this.prisma.workflowVersion.findMany({
       where: { workflowId },
@@ -415,11 +1480,12 @@ export class WorkflowService {
         versions: {
           orderBy: { version: 'desc' },
           take: 1,
-          select: { dsl: true },
+          select: { id: true, version: true, dsl: true },
         },
       },
     });
     if (!workflow) throw new NotFoundException('Workflow not found');
+    if (workflow.status === 'DELETING') throw this.workflowDeletingError();
 
     // Use workflow.dsl if available; otherwise fall back to latest version's DSL
     let dslToPublish = workflow.dsl;
@@ -429,17 +1495,6 @@ export class WorkflowService {
     if (!dslToPublish) {
       throw new NotFoundException('No draft DSL to publish');
     }
-    const latestPublishedDsl = workflow.versions?.[0]?.dsl;
-    if (
-      latestPublishedDsl &&
-      areWorkflowDslSourcesEqual(dslToPublish, latestPublishedDsl)
-    ) {
-      throw new BadRequestException({
-        code: 'WORKFLOW_DSL_UNCHANGED',
-        message: '保存后的 Workflow DSL 与最新发布版本相同，无需再次发布',
-      });
-    }
-
     // Structural + cycle validation. Reject malformed/cyclic DSL up-front so the
     // worker's executeGraph never has to deal with them at runtime.
     try {
@@ -448,10 +1503,18 @@ export class WorkflowService {
       throw new BadRequestException(`Invalid DSL: ${err?.message ?? err}`);
     }
 
-    // Validate source handles against the same node-type metadata consumed by
-    // the canvas. This also supports project-specific node types and output
-    // declarations without requiring a nest-common release.
-    const handleDsl = dslToPublish as any;
+    const compiledDsl = await this.workflowCompiler.compile(
+      dslToPublish as unknown as DraftWorkflowDsl,
+      { userId: creator, username: creator },
+      { workflowId },
+    );
+    const cronConfig = this.extractCronConfig(compiledDsl);
+    if (cronConfig) this.validateCronConfig(cronConfig);
+
+    // Validate FLOW handles against the same node-type metadata consumed by
+    // the canvas. Use compiled nodes so instance config overrides and dynamic
+    // outputs are validated against the effective runtime configuration.
+    const handleDsl = compiledDsl as any;
     const nodeTypes = await this.prisma.workflowNodeType.findMany({
       select: { type: true, outputs: true },
     });
@@ -470,28 +1533,20 @@ export class WorkflowService {
     const handleErrors = validateWorkflowHandles(
       {
         ...handleDsl,
-        edges: (handleDsl.edges ?? [])
-          .filter((edge: any) => !edge.kind || edge.kind === 'FLOW')
-          .map((edge: any) =>
-            ['response-out', 'result-out'].includes(edge.sourceHandle)
-              ? { ...edge, sourceHandle: undefined }
-              : edge,
-          ),
+        edges: (handleDsl.edges ?? []).filter(
+          (edge: any) => !edge.kind || edge.kind === 'FLOW',
+        ),
       },
       outputsMap,
     );
     if (handleErrors.length > 0) {
       throw new BadRequestException({
-        message: 'DSL validation failed: invalid edge sourceHandle(s)',
+        message: 'DSL validation failed: invalid edge handle(s)',
         code: 'DSL_HANDLE_VALIDATION',
         errors: handleErrors,
       });
     }
 
-    const compiledDsl = await this.workflowCompiler.compile(
-      dslToPublish as unknown as DraftWorkflowDsl,
-      { userId: creator, username: creator },
-    );
     try {
       validateWorkflowDataEdges(compiledDsl as any);
     } catch (error) {
@@ -502,46 +1557,63 @@ export class WorkflowService {
       );
     }
 
-    // Validate webhook path collisions across other published workflows
+    if (compiledDsl.nodes.some((node) => node.type === 'event_trigger')) {
+      const catalog = await this.findBusinessEventCatalog();
+      const unknownEvents = unknownBusinessEventNames(
+        compiledDsl,
+        catalog.items,
+      );
+      if (unknownEvents.length > 0)
+        throw new BadRequestException({
+          code: 'WORKFLOW_EVENT_NOT_REGISTERED',
+          message: `未登记的数据库监听：${unknownEvents.join(', ')}`,
+          registrationCodes: unknownEvents,
+        });
+      validateBusinessEventTriggers(compiledDsl, catalog.items);
+    }
+
     const webhookConfigs = this.extractWebhookConfigs(compiledDsl);
-    if (webhookConfigs.length > 0) {
-      const otherPublished = await this.prisma.workflow.findMany({
-        where: { status: 'PUBLISHED', id: { not: workflowId } },
-        select: {
-          id: true,
-          name: true,
-          versions: {
-            orderBy: { version: 'desc' },
-            take: 1,
-            select: { dsl: true },
-          },
-        },
-      });
-      for (const cfg of webhookConfigs) {
-        if (cfg.verificationMode === 'HMAC' && !cfg.secret) {
-          throw new Error(
-            `webhook_trigger path="${cfg.method} ${cfg.path}" requires a secret (HMAC strict mode)`,
-          );
-        }
-        const conflict = otherPublished.find((w) =>
-          this.extractWebhookConfigs(w.versions[0]?.dsl).some(
-            (other) => other.path === cfg.path && other.method === cfg.method,
-          ),
+    for (const node of compiledDsl.nodes.filter(
+      (item) => item.type === 'webhook_trigger',
+    )) {
+      const path = String((node.config as any)?.path ?? '');
+      if (!/^[A-Za-z0-9](?:[A-Za-z0-9_-]*[A-Za-z0-9])?$/.test(path))
+        throw new BadRequestException({
+          code: 'WORKFLOW_WEBHOOK_PATH_INVALID',
+          message:
+            'Webhook 路径必须是非空的单段路径，只能包含字母、数字、- 和 _',
+        });
+    }
+    for (const cfg of webhookConfigs) {
+      if (cfg.verificationMode === 'HMAC' && !cfg.secret) {
+        throw new Error(
+          `webhook_trigger path="${cfg.method} ${cfg.path}" requires a secret (HMAC strict mode)`,
         );
-        if (conflict) {
-          throw new Error(
-            `webhook path "${cfg.method} ${cfg.path}" already used by workflow #${conflict.id} (${conflict.name})`,
-          );
-        }
       }
     }
 
     const result = await this.prisma.$transaction(async (tx) => {
+      // Serialize publication across application replicas so version allocation
+      // remains deterministic.
+      await tx.$queryRaw`
+        SELECT pg_advisory_xact_lock(${WORKFLOW_PUBLISH_LOCK_KEY})::text AS "lock"
+      `;
+      const active = await tx.workflow.updateMany({
+        where: { id: workflowId, status: { not: 'DELETING' } },
+        data: { status: 'PUBLISHED' },
+      });
+      if (active.count !== 1) throw this.workflowDeletingError();
+
       const lastVersion = await tx.workflowVersion.findFirst({
         where: { workflowId },
         orderBy: { version: 'desc' },
-        select: { version: true },
+        select: { id: true, version: true, dsl: true },
       });
+      if (
+        lastVersion &&
+        areWorkflowDslSourcesEqual(dslToPublish, lastVersion.dsl)
+      )
+        return lastVersion;
       const nextVersion = (lastVersion?.version ?? 0) + 1;
 
       const version = await tx.workflowVersion.create({
@@ -555,11 +1627,6 @@ export class WorkflowService {
         },
       });
 
-      await tx.workflow.update({
-        where: { id: workflowId },
-        data: { status: 'PUBLISHED' },
-      });
-
       await tx.audit.create({
         data: {
           creator,
@@ -580,27 +1647,15 @@ export class WorkflowService {
       return version;
     });
 
-    // Cron schedule lifecycle: register/update if cron_trigger present, delete otherwise
-    const cronConfig = this.extractCronConfig(result.dsl);
     try {
-      if (cronConfig) {
-        await this.temporalService.upsertCronSchedule({
-          workflowId: Number(workflowId),
-          versionId: Number(result.id),
-          dsl: result.dsl,
-          cron: cronConfig.cron,
-          timezone: cronConfig.timezone,
-        });
-      } else {
-        // No cron_trigger in this version → clean up any leftover schedule
-        await this.temporalService.deleteCronSchedule(Number(workflowId));
-      }
+      const active = await this.reconcileCronScheduleCurrent(workflowId);
+      if (!active) throw this.workflowDeletingError();
     } catch (err: any) {
-      this.logger.warn(
-        `Cron schedule sync failed for workflow ${workflowId}: ${
-          err?.message ?? err
-        }`,
+      this.logger.error(
+        `Cron schedule sync failed for workflow ${workflowId}`,
+        err?.stack ?? String(err),
       );
+      throw err;
     }
 
     return result;
@@ -622,6 +1677,15 @@ export class WorkflowService {
     return { running, failed, completed, total };
   }
 
+  async getWorkflowStatsByCode(code: string) {
+    const workflow = await this.prisma.workflow.findUnique({
+      where: { code: code.trim() },
+      select: { id: true },
+    });
+    if (!workflow) throw new NotFoundException('Workflow not found');
+    return this.getStats(workflow.id);
+  }
+
   async getOverview() {
     const now = new Date();
     const last24h = new Date(now.getTime() - 24 * 60 * 60 * 1000);
@@ -730,9 +1794,12 @@ export class WorkflowService {
       workflow?: Record<string, any>;
       versionId?: number;
       workflowVersionId?: bigint;
+      idempotencyKey?: string;
+      idempotencyIgnoredWorkflowFields?: string[];
     },
     creator: string,
-    temporalService: any,
+    temporalService: TemporalService,
+    internal?: WorkflowExecutionInternalOptions,
   ) {
     // Get the workflow and its latest published version
     const workflow = await this.prisma.workflow.findUnique({
@@ -746,9 +1813,7 @@ export class WorkflowService {
     });
 
     if (!workflow) throw new NotFoundException('Workflow not found');
-    if (workflow.status !== 'PUBLISHED') {
-      throw new Error('Workflow must be published before execution');
-    }
+    if (workflow.status === 'DELETING') throw this.workflowDeletingError();
     if (!workflow.isEnabled) {
       throw new Error('Workflow is disabled');
     }
@@ -769,40 +1834,193 @@ export class WorkflowService {
 
     if (!version) throw new NotFoundException('No published version found');
 
-    const executionContext = createWorkflowExecutionState(dto.workflow);
+    const executionContext = createWorkflowExecutionState(
+      dto.workflow,
+      internal?.operationScopeId,
+      internal?.retryCheckpoint,
+    );
+    const idempotencyRequestHash = dto.idempotencyKey
+      ? workflowDataHash(
+          dto.workflow ?? {},
+          dto.idempotencyIgnoredWorkflowFields,
+        )
+      : undefined;
+
+    let instance;
+    try {
+      instance = await this.prisma.$transaction(async (tx) => {
+        const lockedWorkflow = await tx.$queryRaw<
+          Array<{ isEnabled: boolean; status: string }>
+        >`SELECT is_enabled AS "isEnabled", status::text AS status
+            FROM t_workflow
+           WHERE id = ${workflowId}
+           FOR UPDATE`;
+        if (!lockedWorkflow[0])
+          throw new NotFoundException('Workflow not found');
+        if (lockedWorkflow[0].status === 'DELETING')
+          throw this.workflowDeletingError();
+        if (!lockedWorkflow[0].isEnabled)
+          throw new Error('Workflow is disabled');
+        return tx.workflowInstance.create({
+          data: {
+            workflowId,
+            versionId: version.id,
+            status: 'PENDING',
+            context: executionContext,
+            ...(dto.idempotencyKey && {
+              idempotencyKey: dto.idempotencyKey,
+              idempotencyRequestHash,
+            }),
+            ...(internal?.retryOfInstanceId && {
+              retryOfInstanceId: internal.retryOfInstanceId,
+              retryFromNodeId: internal.retryFromNodeId,
+            }),
+            creator,
+          },
+        });
+      });
+    } catch (error) {
+      if (
+        !dto.idempotencyKey ||
+        !(error instanceof Prisma.PrismaClientKnownRequestError) ||
+        error.code !== 'P2002'
+      )
+        throw error;
 
-    // Create a WorkflowInstance record
-    const instance = await this.prisma.workflowInstance.create({
-      data: {
-        workflowId,
-        versionId: version.id,
-        status: 'PENDING',
-        context: executionContext,
-        creator,
-      },
+      const existing = await this.prisma.workflowInstance.findUnique({
+        where: {
+          workflowId_idempotencyKey: {
+            workflowId,
+            idempotencyKey: dto.idempotencyKey,
+          },
+        },
+      });
+      if (!existing) throw error;
+      if (existing.idempotencyRequestHash !== idempotencyRequestHash) {
+        throw new ConflictException({
+          code: 'IDEMPOTENCY_KEY_REUSED_WITH_DIFFERENT_INPUT',
+          message: '同一个 Idempotency-Key 不能用于不同的启动数据',
+        });
+      }
+      instance = existing;
+    }
+
+    if (instance.status !== 'PENDING') return workflowExecutionResult(instance);
+
+    const instanceVersion =
+      instance.versionId === version.id
+        ? version
+        : await this.prisma.workflowVersion.findUnique({
+            where: { id: instance.versionId },
+          });
+    if (!instanceVersion)
+      throw new NotFoundException('Workflow version not found');
+
+    const temporalRunId =
+      instance.temporalRunId ??
+      workflowTemporalId(Number(workflowId), Number(instance.id));
+    let launchReservedByCaller = false;
+    if (!instance.temporalRunId) {
+      const reserved = await this.prisma.workflowInstance.updateMany({
+        where: { id: instance.id, status: 'PENDING', temporalRunId: null },
+        data: { temporalRunId },
+      });
+      if (reserved.count !== 1) {
+        const current = await this.prisma.workflowInstance.findUnique({
+          where: { id: instance.id },
+        });
+        if (!current)
+          throw new NotFoundException('Workflow instance not found');
+        return workflowExecutionResult(current);
+      }
+      instance = { ...instance, temporalRunId };
+      launchReservedByCaller = true;
+    }
+
+    if (!launchReservedByCaller) return workflowExecutionResult(instance);
+
+    try {
+      await temporalService.startWorkflow({
+        instanceId: Number(instance.id),
+        workflowId: Number(workflowId),
+        versionId: Number(instanceVersion.id),
+        dsl: instanceVersion.dsl,
+        context: instance.context as Record<string, any>,
+        retryCheckpoint: readRetryCheckpoint(instance.context),
+      });
+    } catch (error) {
+      await this.prisma.workflowInstance.updateMany({
+        where: { id: instance.id, status: 'PENDING', temporalRunId },
+        data: {
+          status: 'FAILED',
+          result: {
+            code: 'TEMPORAL_START_FAILED',
+            message: error instanceof Error ? error.message : String(error),
+          },
+          finishedAt: new Date(),
+        },
+      });
+      throw error;
+    }
+
+    const current = await this.prisma.workflowInstance.findUnique({
+      where: { id: instance.id },
     });
+    if (!current) throw new NotFoundException('Workflow instance not found');
+    if (current.status === 'CANCELLED') {
+      await temporalService
+        .cancelWorkflow(temporalRunId)
+        .catch((error) =>
+          this.logger.warn(
+            `Failed to cancel Temporal workflow ${temporalRunId} after launch race: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
+          ),
+        );
+    }
+    return workflowExecutionResult(current);
+  }
 
-    // Start the Temporal workflow
-    const { temporalRunId } = await temporalService.startWorkflow({
-      instanceId: Number(instance.id),
-      workflowId: Number(workflowId),
-      versionId: Number(version.id),
-      dsl: version.dsl,
-      context: executionContext,
+  async executeManualWorkflowByCode(
+    code: string,
+    workflowData: Record<string, unknown>,
+    rawIdempotencyKey: string | undefined,
+    creator: string,
+  ) {
+    const idempotencyKey = scopedIdempotencyKey(
+      'manual',
+      normalizeIdempotencyKey(rawIdempotencyKey),
+    );
+    const workflow = await this.prisma.workflow.findUnique({
+      where: { code: code.trim() },
+      include: {
+        versions: {
+          orderBy: { version: 'desc' },
+          take: 1,
+        },
+      },
     });
 
-    // Update instance with Temporal run ID
-    await this.prisma.workflowInstance.update({
-      where: { id: instance.id },
-      data: { temporalRunId },
-    });
+    if (!workflow) throw new NotFoundException('Workflow not found');
+    if (workflow.status !== 'PUBLISHED')
+      throw new BadRequestException('Workflow is not published');
+    if (!workflow.isEnabled)
+      throw new BadRequestException('Workflow is disabled');
+
+    const version = workflow.versions[0];
+    if (!version) throw new NotFoundException('No published version found');
+    assertManualWorkflowExecution(version.dsl, workflowData);
 
-    return {
-      instanceId: instance.id.toString(),
-      temporalRunId,
-      workflowVersionId: version.id.toString(),
-      status: 'PENDING',
-    };
+    return this.executeWorkflow(
+      workflow.id,
+      {
+        workflow: workflowData,
+        workflowVersionId: version.id,
+        idempotencyKey,
+      },
+      creator,
+      this.temporalService,
+    );
   }
 
   /**
@@ -823,18 +2041,15 @@ export class WorkflowService {
     body: any;
     headers: Record<string, any>;
     query: Record<string, any>;
-  }): Promise<{
-    instanceIds: string[];
-    response?: {
-      statusCode: number;
-      headers: Record<string, string>;
-      body: unknown;
-    };
-  }> {
+  }): Promise<{ instanceIds: string[] }> {
     // 1) Lookup matching published + enabled workflows. Verification is configured
     // per trigger, so the matching trigger must be known before headers are checked.
     const published = await this.prisma.workflow.findMany({
-      where: { status: 'PUBLISHED', isEnabled: true },
+      where: {
+        status: 'PUBLISHED',
+        isEnabled: true,
+        versions: { some: {} },
+      },
       include: {
         versions: { orderBy: { version: 'desc' }, take: 1 },
       },
@@ -846,8 +2061,6 @@ export class WorkflowService {
       dsl: any;
       secret?: string;
       verificationMode: 'HMAC' | 'NONE';
-      responseMode: 'IMMEDIATE' | 'WAIT_FOR_RESULT';
-      responseTimeoutSeconds: number;
     };
     const matches: Match[] = [];
     for (const wf of published) {
@@ -866,8 +2079,6 @@ export class WorkflowService {
         dsl,
         secret: cfg.secret,
         verificationMode: cfg.verificationMode,
-        responseMode: cfg.responseMode,
-        responseTimeoutSeconds: cfg.responseTimeoutSeconds,
       });
     }
 
@@ -906,6 +2117,15 @@ export class WorkflowService {
       }
     }
 
+    const webhookIdempotencyKey = scopedIdempotencyKey(
+      'webhook',
+      normalizeIdempotencyKey(
+        typeof input.headers['idempotency-key'] === 'string'
+          ? input.headers['idempotency-key']
+          : undefined,
+      ),
+    );
+
     // 3) Trigger executions in parallel
     const workflowData = {
       headers: input.headers,
@@ -917,78 +2137,27 @@ export class WorkflowService {
       matches.map((m) =>
         this.executeWorkflow(
           m.workflowId,
-          { workflow: workflowData, workflowVersionId: m.versionId },
+          {
+            workflow: workflowData,
+            workflowVersionId: m.versionId,
+            idempotencyKey: webhookIdempotencyKey,
+            idempotencyIgnoredWorkflowFields: [
+              'receivedAt',
+              'headers.x-workflow-signature',
+              'headers.x-workflow-timestamp',
+              'headers.content-length',
+            ],
+          },
           'webhook',
           this.temporalService,
         ),
       ),
     );
 
-    const instanceIds = results.map((result) => result.instanceId);
-    const waitingIndex = matches.findIndex(
-      (match) => match.responseMode === 'WAIT_FOR_RESULT',
-    );
-    if (waitingIndex === -1) return { instanceIds };
-
-    const match = matches[waitingIndex];
-    const execution = results[waitingIndex];
-    try {
-      const waited = await this.temporalService.waitForWorkflowResult(
-        execution.temporalRunId,
-        match.responseTimeoutSeconds * 1000,
-      );
-      if (waited.kind === 'TIMED_OUT') {
-        return {
-          instanceIds,
-          response: {
-            statusCode: 504,
-            headers: {},
-            body: {
-              code: 'WORKFLOW_RESPONSE_TIMEOUT',
-              message: `Workflow did not return a result within ${match.responseTimeoutSeconds} seconds`,
-              instanceId: execution.instanceId,
-            },
-          },
-        };
-      }
-
-      const workflowResult = asRecord(waited.result);
-      if (
-        workflowResult.status !== 'COMPLETED' ||
-        !Object.prototype.hasOwnProperty.call(workflowResult, 'output')
-      ) {
-        throw new Error('Workflow completed without a return result');
-      }
-      const httpResponse = asRecord(workflowResult.httpResponse);
-      return {
-        instanceIds,
-        response: {
-          statusCode: normalizeHttpStatusCode(httpResponse.statusCode),
-          headers: normalizeHttpHeaders(httpResponse.headers),
-          body: workflowResult.output,
-        },
-      };
-    } catch (error) {
-      this.logger.error(
-        `Workflow ${execution.instanceId} failed while waiting for an HTTP response`,
-        error instanceof Error ? error.stack : String(error),
-      );
-      return {
-        instanceIds,
-        response: {
-          statusCode: 500,
-          headers: {},
-          body: {
-            code: 'WORKFLOW_EXECUTION_FAILED',
-            message: 'Workflow execution failed',
-            instanceId: execution.instanceId,
-          },
-        },
-      };
-    }
+    return { instanceIds: results.map((result) => result.instanceId) };
   }
 
-  async getInstanceDetail(instanceId: bigint) {
+  async getInstanceDetail(instanceId: bigint, userId: string) {
     const instance = await this.prisma.workflowInstance.findUnique({
       where: { id: instanceId },
       include: {
@@ -1001,6 +2170,29 @@ export class WorkflowService {
 
     if (!instance) throw new NotFoundException('Instance not found');
 
+    const [approvableRequests, retryAttempts] = await Promise.all([
+      this.prisma.approvalRequest.findMany({
+        where: {
+          workflowInstanceId: instanceId,
+          status: 'PENDING',
+          candidates: {
+            some: { principalRef: userId, invalidatedAt: null },
+          },
+        },
+        select: { nodeId: true },
+      }),
+      this.prisma.workflowInstance.findMany({
+        where: { retryOfInstanceId: instanceId },
+        orderBy: { createdAt: 'desc' },
+        select: {
+          id: true,
+          status: true,
+          retryFromNodeId: true,
+          createdAt: true,
+        },
+      }),
+    ]);
+
     // Fetch the workflow DSL from the version
     let dsl: any = null;
     if (instance.versionId) {
@@ -1014,30 +2206,439 @@ export class WorkflowService {
     return {
       ...instance,
       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),
+            )
+          : [],
+      retryAttempts,
+      reusedNodeIds:
+        readRetryCheckpoint(instance.context)?.completedNodeIds ?? [],
       dsl,
     };
   }
 
-  async cancelInstance(instanceId: bigint, temporalService: any) {
+  async getExecutionStatus(instanceId: bigint) {
     const instance = await this.prisma.workflowInstance.findUnique({
       where: { id: instanceId },
+      select: {
+        id: true,
+        status: true,
+        startedAt: true,
+        finishedAt: true,
+        result: true,
+      },
     });
+    if (!instance) throw new NotFoundException('Workflow instance not found');
+    const result = asRecord(instance.result);
+    return {
+      instanceId: instance.id.toString(),
+      status: instance.status,
+      startedAt: instance.startedAt,
+      finishedAt: instance.finishedAt,
+      ...(Object.prototype.hasOwnProperty.call(result, 'output') && {
+        result: result.output,
+      }),
+      ...(instance.status === 'FAILED' && {
+        error: {
+          ...(typeof result.code === 'string' ? { code: result.code } : {}),
+          message:
+            typeof result.message === 'string'
+              ? result.message
+              : typeof result.error === 'string'
+              ? result.error
+              : 'Workflow execution failed',
+        },
+      }),
+    };
+  }
 
-    if (!instance) throw new NotFoundException('Instance not found');
-    if (instance.status !== 'RUNNING' && instance.status !== 'PENDING') {
-      throw new Error('Can only cancel RUNNING or PENDING instances');
+  async cancelExecutionInTransaction(
+    tx: Prisma.TransactionClient,
+    instanceId: bigint,
+    reason?: string,
+  ) {
+    const rows = await tx.$queryRaw<
+      Array<{
+        id: bigint;
+        status: string;
+        temporalRunId: string | null;
+        cancellationBlockedAt: Date | null;
+      }>
+    >`SELECT id, status::text AS status,
+             temporal_run_id AS "temporalRunId",
+             cancellation_blocked_at AS "cancellationBlockedAt"
+        FROM t_workflow_instance
+       WHERE id = ${instanceId}
+       FOR UPDATE`;
+    const instance = rows[0];
+    if (!instance) throw new NotFoundException('Workflow instance not found');
+    if (
+      instance.status !== 'CANCELLED' &&
+      !['RUNNING', 'PENDING'].includes(instance.status)
+    )
+      throw new ConflictException(
+        'Only RUNNING or PENDING instances can be cancelled',
+      );
+    if (
+      instance.status !== 'CANCELLED' &&
+      instance.cancellationBlockedAt != null
+    )
+      throw new ConflictException({
+        code: 'WORKFLOW_CANCELLATION_BLOCKED',
+        message: 'Workflow cancellation is blocked by a resolved approval',
+      });
+
+    const now = new Date();
+    if (instance.status !== 'CANCELLED') {
+      await tx.workflowInstance.update({
+        where: { id: instanceId },
+        data: {
+          status: 'CANCELLED',
+          finishedAt: now,
+          cancellationRequestedAt: now,
+          cancellationReason: reason?.trim().slice(0, 512) || null,
+          cancellationStatus: instance.temporalRunId ? 'PENDING' : 'COMPLETED',
+          cancellationLastError: null,
+        },
+      });
+      await Promise.all([
+        tx.approvalRequest.updateMany({
+          where: {
+            workflowInstanceId: instanceId,
+            status: { in: ['PENDING', 'BLOCKED'] },
+          },
+          data: { status: 'CANCELLED', completedAt: now },
+        }),
+        tx.externalInteraction.updateMany({
+          where: { workflowInstanceId: instanceId, status: 'PENDING' },
+          data: { status: 'CANCELLED', resolvedAt: now },
+        }),
+      ]);
     }
+  }
+
+  async findEventTriggeredExecutionInTransaction(
+    tx: Prisma.TransactionClient,
+    input: {
+      workflowCode: string;
+      tableName: string;
+      operation: 'INSERT' | 'UPDATE' | 'DELETE';
+      primaryKey: Record<string, string | number | boolean>;
+    },
+  ): Promise<{ instanceId: bigint; status: string } | null> {
+    const rows = await tx.$queryRaw<
+      Array<{ instanceId: bigint; status: string }>
+    >`
+      WITH RECURSIVE execution_tree AS (
+        SELECT instance.id AS "instanceId",
+               instance.status::text AS status,
+               instance.created_at AS "createdAt",
+               0 AS depth
+          FROM t_workflow_event_outbox outbox
+          JOIN t_workflow_event_delivery delivery
+            ON delivery.outbox_id = outbox.id
+          JOIN t_workflow_instance instance
+            ON instance.id = delivery.workflow_instance_id
+          JOIN t_workflow workflow
+            ON workflow.id = delivery.workflow_id
+         WHERE outbox.schema_name = current_schema()
+           AND outbox.table_name = ${input.tableName}
+           AND outbox.operation::text = ${input.operation}
+           AND outbox.primary_key = ${JSON.stringify(input.primaryKey)}::jsonb
+           AND workflow.code = ${input.workflowCode}
+
+        UNION ALL
+
+        SELECT retry.id AS "instanceId",
+               retry.status::text AS status,
+               retry.created_at AS "createdAt",
+               parent.depth + 1 AS depth
+          FROM t_workflow_instance retry
+          JOIN execution_tree parent
+            ON retry.retry_of_instance_id = parent."instanceId"
+      )
+      SELECT "instanceId", status
+        FROM execution_tree
+       ORDER BY depth DESC, "createdAt" DESC, "instanceId" DESC
+       LIMIT 1
+    `;
+    return rows[0] ?? null;
+  }
 
-    if (instance.temporalRunId) {
-      await temporalService.cancelWorkflow(instance.temporalRunId);
+  private async deliverTemporalCancellation(
+    instanceId: bigint,
+    temporalRunId: string,
+  ) {
+    try {
+      await this.temporalService.cancelWorkflow(temporalRunId);
+      await this.prisma.workflowInstance.updateMany({
+        where: { id: instanceId, cancellationStatus: 'PENDING' },
+        data: {
+          cancellationStatus: 'COMPLETED',
+          cancellationLastError: null,
+        },
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      await this.prisma.workflowInstance.updateMany({
+        where: { id: instanceId, cancellationStatus: 'PENDING' },
+        data: { cancellationLastError: message },
+      });
+      this.logger.warn(
+        `Temporal cancellation pending for Workflow instance ${instanceId}: ${message}`,
+      );
     }
+  }
 
-    await this.prisma.workflowInstance.update({
-      where: { id: instanceId },
-      data: { status: 'CANCELLED', finishedAt: new Date() },
+  @Interval(30_000)
+  async reconcilePendingCancellations() {
+    const pending = await this.prisma.workflowInstance.findMany({
+      where: {
+        status: 'CANCELLED',
+        cancellationStatus: 'PENDING',
+        temporalRunId: { not: null },
+      },
+      orderBy: { cancellationRequestedAt: 'asc' },
+      take: 50,
+      select: { id: true, temporalRunId: true },
+    });
+    await Promise.all(
+      pending.map((instance) =>
+        this.deliverTemporalCancellation(instance.id, instance.temporalRunId!),
+      ),
+    );
+  }
+
+  @Interval(60_000)
+  async reconcileUnstartedInstances(): Promise<void> {
+    const cutoff = new Date(Date.now() - 60_000);
+    await this.prisma.workflowInstance.updateMany({
+      where: {
+        status: 'PENDING',
+        temporalRunId: null,
+        createdAt: { lte: cutoff },
+      },
+      data: {
+        status: 'FAILED',
+        result: {
+          code: 'TEMPORAL_START_NOT_RESERVED',
+          message: 'Workflow failed before Temporal execution was reserved',
+        },
+        finishedAt: new Date(),
+      },
+    });
+
+    const reservedInstances = await this.prisma.workflowInstance.findMany({
+      where: {
+        status: { in: ['PENDING', 'RUNNING'] },
+        temporalRunId: { not: null },
+        updatedAt: { lte: cutoff },
+      },
+      select: {
+        id: true,
+        workflowId: true,
+        versionId: true,
+        temporalRunId: true,
+        context: true,
+        status: true,
+      },
+    });
+    for (const instance of reservedInstances) {
+      try {
+        let temporalState = await this.temporalService.inspectWorkflow(
+          instance.temporalRunId!,
+        );
+        if (temporalState.kind === 'MISSING') {
+          if (instance.status === 'RUNNING') {
+            await this.failMissingRunningInstance(
+              instance.id,
+              instance.temporalRunId!,
+            );
+            continue;
+          }
+          const version = await this.prisma.workflowVersion.findUnique({
+            where: { id: instance.versionId },
+            select: { dsl: true },
+          });
+          if (!version) {
+            await this.failUnstartedInstance(
+              instance.id,
+              instance.temporalRunId!,
+              'Workflow version not found during launch reconciliation',
+            );
+            continue;
+          }
+          await this.temporalService.startWorkflow({
+            instanceId: Number(instance.id),
+            workflowId: Number(instance.workflowId),
+            versionId: Number(instance.versionId),
+            dsl: version.dsl,
+            context: (instance.context ?? {}) as Record<string, any>,
+            retryCheckpoint: readRetryCheckpoint(instance.context),
+          });
+          temporalState = await this.temporalService.inspectWorkflow(
+            instance.temporalRunId!,
+          );
+        }
+        if (temporalState.kind === 'MISSING') continue;
+        await this.reconcileInstanceFromTemporal(
+          instance.id,
+          instance.temporalRunId!,
+          temporalState,
+        );
+      } catch (error) {
+        this.logger.warn(
+          `Failed to reconcile Workflow instance ${instance.id}: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+    }
+  }
+
+  private async failMissingRunningInstance(
+    instanceId: bigint,
+    temporalRunId: string,
+  ): Promise<void> {
+    await this.prisma.workflowInstance.updateMany({
+      where: { id: instanceId, status: 'RUNNING', temporalRunId },
+      data: {
+        status: 'FAILED',
+        result: {
+          code: 'TEMPORAL_EXECUTION_MISSING',
+          message: 'Temporal execution disappeared while Workflow was running',
+        },
+        finishedAt: new Date(),
+      },
+    });
+  }
+
+  private async failUnstartedInstance(
+    instanceId: bigint,
+    temporalRunId: string,
+    message: string,
+  ): Promise<void> {
+    await this.prisma.workflowInstance.updateMany({
+      where: { id: instanceId, status: 'PENDING', temporalRunId },
+      data: {
+        status: 'FAILED',
+        result: { code: 'TEMPORAL_START_RECONCILIATION_FAILED', message },
+        finishedAt: new Date(),
+      },
+    });
+  }
+
+  @Interval(60_000)
+  async reconcileTerminalInteractions(): Promise<void> {
+    const pendingApprovals = await this.prisma.$queryRaw<Array<{ id: bigint }>>`
+      SELECT approval.id
+        FROM t_approval_request approval
+        JOIN t_workflow_instance instance
+          ON instance.id = approval.workflow_instance_id
+       WHERE approval.status = 'PENDING'
+         AND instance.status IN ('COMPLETED', 'FAILED', 'CANCELLED')
+       ORDER BY approval.id
+       LIMIT 100`;
+    const approvalResults = await Promise.allSettled(
+      pendingApprovals.map(({ id }) =>
+        this.humanApprovalService.cancelRequest(id, false),
+      ),
+    );
+    approvalResults.forEach((result, index) => {
+      if (result.status === 'rejected')
+        this.logger.warn(
+          `Failed to reconcile approval ${pendingApprovals[index].id}: ${
+            result.reason instanceof Error
+              ? result.reason.message
+              : String(result.reason)
+          }`,
+        );
+    });
+
+    await this.prisma.externalInteraction.updateMany({
+      where: {
+        status: 'PENDING',
+        workflowInstance: {
+          status: { in: ['COMPLETED', 'FAILED', 'CANCELLED'] },
+        },
+      },
+      data: { status: 'CANCELLED', resolvedAt: new Date() },
+    });
+  }
+
+  private async reconcileInstanceFromTemporal(
+    instanceId: bigint,
+    temporalRunId: string,
+    state: Exclude<
+      Awaited<ReturnType<TemporalService['inspectWorkflow']>>,
+      { kind: 'MISSING' }
+    >,
+  ): Promise<void> {
+    if (state.status === 'RUNNING' || state.status === 'PAUSED') {
+      const updated = await this.prisma.workflowInstance.updateMany({
+        where: { id: instanceId, status: 'PENDING', temporalRunId },
+        data: { status: 'RUNNING', startedAt: state.startedAt },
+      });
+      if (updated.count !== 1) {
+        const current = await this.prisma.workflowInstance.findUnique({
+          where: { id: instanceId },
+          select: { status: true },
+        });
+        if (current?.status === 'CANCELLED')
+          await this.temporalService.cancelWorkflow(temporalRunId);
+      }
+      return;
+    }
+    const status =
+      state.status === 'COMPLETED'
+        ? 'COMPLETED'
+        : state.status === 'CANCELLED'
+        ? 'CANCELLED'
+        : 'FAILED';
+    await this.prisma.workflowInstance.updateMany({
+      where: {
+        id: instanceId,
+        status: { in: ['PENDING', 'RUNNING'] },
+        temporalRunId,
+      },
+      data: {
+        status,
+        result:
+          state.result === undefined
+            ? {
+                code: 'TEMPORAL_TERMINAL_STATUS_RECONCILED',
+                temporalStatus: state.status,
+              }
+            : normalizeTemporalCompletedResult(state.result),
+        startedAt: state.startedAt,
+        finishedAt: state.finishedAt ?? new Date(),
+      },
+    });
+  }
+
+  @Interval(60_000)
+  async reconcileCronSchedules(): Promise<void> {
+    const workflows = await this.prisma.workflow.findMany({
+      where: { status: 'PUBLISHED' },
+      select: { id: true },
     });
 
-    return { success: true };
+    for (const workflow of workflows) {
+      try {
+        await this.reconcileCronScheduleCurrent(workflow.id);
+      } catch (error) {
+        this.logger.warn(
+          `Failed to reconcile cron schedule for workflow ${workflow.id}: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+    }
   }
 
   async retryInstance(
@@ -1054,7 +2655,15 @@ export class WorkflowService {
       throw new Error('Can only retry FAILED instances');
     }
 
+    const existingRetry = await this.prisma.workflowInstance.findFirst({
+      where: { retryOfInstanceId: instance.id },
+      orderBy: { createdAt: 'desc' },
+    });
+    if (existingRetry) return workflowExecutionResult(existingRetry);
+
     const executionState = instance.context as Record<string, any>;
+    const operationScopeId =
+      executionState.system?.operationScopeId ?? String(instance.id);
     // Create a new instance with the same immutable Workflow data.
     return this.executeWorkflow(
       instance.workflowId,
@@ -1066,32 +2675,70 @@ export class WorkflowService {
             ? executionState.workflow
             : {},
         workflowVersionId: instance.versionId,
+        idempotencyKey: `retry:${instance.id}`,
       },
       creator,
       temporalService,
+      {
+        operationScopeId: String(operationScopeId),
+        retryOfInstanceId: instance.id,
+      },
     );
   }
 
-  async signalInstance(
+  async retryInstanceFromNode(
     instanceId: bigint,
-    dto: { signalName: string; payload: Record<string, any> },
-    temporalService: any,
+    nodeId: string,
+    creator: string,
+    temporalService: TemporalService,
   ) {
     const instance = await this.prisma.workflowInstance.findUnique({
       where: { id: instanceId },
+      include: { nodeExecutions: true },
     });
-
     if (!instance) throw new NotFoundException('Instance not found');
-    if (!instance.temporalRunId) {
-      throw new Error('Instance has no Temporal run ID');
+    if (instance.status !== 'FAILED') {
+      throw new BadRequestException('只有失败的 Workflow 才能从节点重试');
     }
 
-    await temporalService.signalWorkflow(
-      instance.temporalRunId,
-      dto.signalName,
-      dto.payload,
+    const existingRetry = await this.prisma.workflowInstance.findFirst({
+      where: { retryOfInstanceId: instance.id },
+      orderBy: { createdAt: 'desc' },
+    });
+    if (existingRetry) return workflowExecutionResult(existingRetry);
+
+    const version = await this.prisma.workflowVersion.findUnique({
+      where: { id: instance.versionId },
+      select: { dsl: true },
+    });
+    if (!version) throw new NotFoundException('Workflow version not found');
+
+    const retryCheckpoint = buildRetryCheckpoint(
+      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,
+      },
     );
-    return { success: true };
   }
 
   async approveInstance(
@@ -1121,10 +2768,32 @@ export class WorkflowService {
 
 function createWorkflowExecutionState(
   value: Record<string, any> | undefined,
+  operationScopeId?: string,
+  retryCheckpoint?: WorkflowRetryCheckpoint,
 ): Record<string, any> {
   return {
     workflow: value ?? {},
     nodes: {},
+    ...((operationScopeId || retryCheckpoint) && {
+      system: {
+        ...(operationScopeId && { operationScopeId }),
+        ...(retryCheckpoint && { retryCheckpoint }),
+      },
+    }),
+  };
+}
+
+function workflowExecutionResult(instance: {
+  id: bigint;
+  versionId: bigint;
+  status: string;
+  temporalRunId: string | null;
+}) {
+  return {
+    instanceId: instance.id.toString(),
+    temporalRunId: instance.temporalRunId,
+    workflowVersionId: instance.versionId.toString(),
+    status: instance.status,
   };
 }
 
@@ -1134,6 +2803,190 @@ function asRecord(value: unknown): Record<string, unknown> {
     : {};
 }
 
+function quoteIdentifier(value: string): string {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+
+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(
+  dslValue: unknown,
+  nodeExecutions: Array<{
+    nodeId: string;
+    status: string;
+    output: unknown;
+  }>,
+  retryFromNodeId: string,
+  inheritedCheckpoint?: WorkflowRetryCheckpoint,
+): WorkflowRetryCheckpoint {
+  const dsl = asRecord(dslValue);
+  const nodes = Array.isArray(dsl.nodes)
+    ? (dsl.nodes as Array<Record<string, unknown>>)
+    : [];
+  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('该节点暂不支持从这里重试');
+  }
+  if (
+    edges.some(
+      (edge) =>
+        typeof edge.pairId === 'string' &&
+        edge.pairId.length > 0 &&
+        (edge.source === retryFromNodeId || edge.target === retryFromNodeId),
+    )
+  ) {
+    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('失败节点存在多个上游，暂不支持从这里重试');
+  }
+  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 };
+}
+
+function listRetryableNodeIds(
+  dsl: unknown,
+  nodeExecutions: Array<{
+    nodeId: string;
+    status: string;
+    output: unknown;
+  }>,
+  inheritedCheckpoint?: WorkflowRetryCheckpoint,
+): string[] {
+  return nodeExecutions
+    .filter((execution) => execution.status === 'FAILED')
+    .filter((execution) => {
+      try {
+        buildRetryCheckpoint(
+          dsl,
+          nodeExecutions,
+          execution.nodeId,
+          inheritedCheckpoint,
+        );
+        return true;
+      } catch {
+        return false;
+      }
+    })
+    .map((execution) => execution.nodeId);
+}
+
 function normalizeHttpStatusCode(value: unknown): number {
   return typeof value === 'number' &&
     Number.isInteger(value) &&
@@ -1150,3 +3003,17 @@ function normalizeHttpHeaders(value: unknown): Record<string, string> {
     ),
   );
 }
+
+function normalizeTemporalCompletedResult(
+  value: unknown,
+): Prisma.InputJsonValue {
+  const result = asRecord(value);
+  const context = asRecord(result.context);
+  return {
+    workflow: asRecord(context.workflow) as Prisma.InputJsonObject,
+    output: (result.output ?? null) as Prisma.InputJsonValue,
+    ...(result.httpResponse !== undefined && {
+      httpResponse: result.httpResponse as Prisma.InputJsonValue,
+    }),
+  };
+}