@gadmin2n/schematics 0.0.144 → 0.0.145

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

@@ -0,0 +1,773 @@
+import { ConflictException } from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+import { WorkflowService } from './workflow.service';
+
+describe('Workflow execution idempotency', () => {
+  const workflowId = BigInt(7);
+  const version = {
+    id: BigInt(11),
+    version: 1,
+    dsl: { nodes: [{ type: 'webhook_trigger' }], edges: [] },
+  };
+
+  function setup() {
+    const prisma: any = {
+      workflow: {
+        findUnique: jest.fn().mockResolvedValue({
+          id: workflowId,
+          status: 'PUBLISHED',
+          isEnabled: true,
+          versions: [version],
+        }),
+      },
+      workflowVersion: {
+        findFirst: jest.fn().mockResolvedValue(version),
+        findUnique: jest.fn(),
+      },
+      workflowInstance: {
+        create: jest.fn(),
+        findFirst: jest.fn().mockResolvedValue(null),
+        findUnique: jest.fn(),
+        findMany: jest.fn().mockResolvedValue([]),
+        update: jest.fn(),
+        updateMany: jest.fn().mockResolvedValue({ count: 0 }),
+      },
+    };
+    prisma.$transaction = jest.fn(async (callback: any) =>
+      callback({
+        $queryRaw: jest.fn().mockResolvedValue([{ isEnabled: true }]),
+        workflowInstance: prisma.workflowInstance,
+      }),
+    );
+    const temporal: any = {
+      startWorkflow: jest.fn().mockResolvedValue({
+        temporalRunId: 'wf-7-21',
+      }),
+      cancelWorkflow: jest.fn().mockResolvedValue(undefined),
+      inspectWorkflow: jest.fn(),
+    };
+    const service = new WorkflowService(prisma, temporal, {} as any, {} as any);
+    return { prisma, temporal, service };
+  }
+
+  it('persists the key and starts one deterministic Temporal execution', async () => {
+    const { prisma, temporal, service } = setup();
+    const created = {
+      id: BigInt(21),
+      workflowId,
+      versionId: version.id,
+      status: 'PENDING',
+      context: { workflow: { orderId: 'O-1' }, nodes: {} },
+      idempotencyRequestHash:
+        '6d288206d621b9052da3914713fb30b193ca75b1123e29d3ead4db81be833904',
+      temporalRunId: null,
+    };
+    prisma.workflowInstance.create.mockResolvedValue(created);
+    prisma.workflowInstance.updateMany.mockResolvedValue({ count: 1 });
+    prisma.workflowInstance.findUnique.mockResolvedValue({
+      ...created,
+      temporalRunId: 'wf-7-21',
+    });
+
+    await expect(
+      service.executeWorkflow(
+        workflowId,
+        {
+          workflow: { orderId: 'O-1' },
+          workflowVersionId: version.id,
+          idempotencyKey: 'webhook:key-1',
+        },
+        'webhook',
+        temporal,
+      ),
+    ).resolves.toMatchObject({
+      instanceId: '21',
+      temporalRunId: 'wf-7-21',
+    });
+
+    expect(prisma.workflowInstance.create).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        idempotencyKey: 'webhook:key-1',
+        idempotencyRequestHash: expect.stringMatching(/^[a-f0-9]{64}$/),
+      }),
+    });
+    expect(temporal.startWorkflow).toHaveBeenCalledTimes(1);
+  });
+
+  it('rechecks enabled state while holding the Workflow row lock', async () => {
+    const { prisma, temporal, service } = setup();
+    prisma.$transaction.mockImplementationOnce(async (callback: any) =>
+      callback({
+        $queryRaw: jest.fn().mockResolvedValue([{ isEnabled: false }]),
+        workflowInstance: prisma.workflowInstance,
+      }),
+    );
+
+    await expect(
+      service.executeWorkflow(workflowId, {}, 'manual', temporal),
+    ).rejects.toThrow('Workflow is disabled');
+    expect(prisma.workflowInstance.create).not.toHaveBeenCalled();
+    expect(temporal.startWorkflow).not.toHaveBeenCalled();
+  });
+
+  it('returns the existing execution for the same key and equivalent input', async () => {
+    const { prisma, temporal, service } = setup();
+    prisma.workflowInstance.create.mockRejectedValue(
+      new Prisma.PrismaClientKnownRequestError('duplicate', {
+        code: 'P2002',
+        clientVersion: '6.19.3',
+      }),
+    );
+    prisma.workflowInstance.findUnique.mockResolvedValue({
+      id: BigInt(21),
+      workflowId,
+      versionId: version.id,
+      status: 'COMPLETED',
+      context: {
+        workflow: { orderId: 'O-1', receivedAt: 'first' },
+        nodes: {},
+      },
+      idempotencyRequestHash:
+        '6d288206d621b9052da3914713fb30b193ca75b1123e29d3ead4db81be833904',
+      temporalRunId: 'wf-7-21',
+    });
+
+    await expect(
+      service.executeWorkflow(
+        workflowId,
+        {
+          workflow: { receivedAt: 'retry', orderId: 'O-1' },
+          workflowVersionId: version.id,
+          idempotencyKey: 'webhook:key-1',
+          idempotencyIgnoredWorkflowFields: ['receivedAt'],
+        },
+        'webhook',
+        temporal,
+      ),
+    ).resolves.toMatchObject({
+      instanceId: '21',
+      status: 'COMPLETED',
+    });
+    expect(temporal.startWorkflow).not.toHaveBeenCalled();
+  });
+
+  it('does not start Temporal twice when an equivalent execution is already reserved', async () => {
+    const { prisma, temporal, service } = setup();
+    prisma.workflowInstance.create.mockRejectedValue(
+      new Prisma.PrismaClientKnownRequestError('duplicate', {
+        code: 'P2002',
+        clientVersion: '6.19.3',
+      }),
+    );
+    prisma.workflowInstance.findUnique.mockResolvedValue({
+      id: BigInt(21),
+      workflowId,
+      versionId: version.id,
+      status: 'PENDING',
+      context: { workflow: { orderId: 'O-1' }, nodes: {} },
+      idempotencyRequestHash:
+        '6d288206d621b9052da3914713fb30b193ca75b1123e29d3ead4db81be833904',
+      temporalRunId: 'wf-7-21',
+    });
+
+    await expect(
+      service.executeWorkflow(
+        workflowId,
+        {
+          workflow: { orderId: 'O-1' },
+          workflowVersionId: version.id,
+          idempotencyKey: 'retry:20',
+        },
+        'retry',
+        temporal,
+      ),
+    ).resolves.toMatchObject({
+      instanceId: '21',
+      temporalRunId: 'wf-7-21',
+      status: 'PENDING',
+    });
+    expect(temporal.startWorkflow).not.toHaveBeenCalled();
+  });
+
+  it('rejects the same key with different input', async () => {
+    const { prisma, temporal, service } = setup();
+    prisma.workflowInstance.create.mockRejectedValue(
+      new Prisma.PrismaClientKnownRequestError('duplicate', {
+        code: 'P2002',
+        clientVersion: '6.19.3',
+      }),
+    );
+    prisma.workflowInstance.findUnique.mockResolvedValue({
+      id: BigInt(21),
+      versionId: version.id,
+      status: 'COMPLETED',
+      context: { workflow: { orderId: 'O-1' }, nodes: {} },
+      idempotencyRequestHash: 'different-request-hash',
+      temporalRunId: 'wf-7-21',
+    });
+
+    await expect(
+      service.executeWorkflow(
+        workflowId,
+        {
+          workflow: { orderId: 'O-2' },
+          workflowVersionId: version.id,
+          idempotencyKey: 'webhook:key-1',
+        },
+        'webhook',
+        temporal,
+      ),
+    ).rejects.toBeInstanceOf(ConflictException);
+  });
+
+  it('marks a reserved instance failed when Temporal cannot start it', async () => {
+    const { prisma, temporal, service } = setup();
+    const created = {
+      id: BigInt(21),
+      workflowId,
+      versionId: version.id,
+      status: 'PENDING',
+      context: { workflow: {}, nodes: {} },
+      temporalRunId: null,
+    };
+    prisma.workflowInstance.create.mockResolvedValue(created);
+    prisma.workflowInstance.updateMany.mockResolvedValue({ count: 1 });
+    temporal.startWorkflow.mockRejectedValue(new Error('Temporal unavailable'));
+
+    await expect(
+      service.executeWorkflow(workflowId, {}, 'manual', temporal),
+    ).rejects.toThrow('Temporal unavailable');
+
+    expect(prisma.workflowInstance.updateMany).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          id: BigInt(21),
+          status: 'PENDING',
+          temporalRunId: 'wf-7-21',
+        }),
+        data: expect.objectContaining({ status: 'FAILED' }),
+      }),
+    );
+  });
+
+  it('cancels Temporal immediately when cancellation wins the launch race', async () => {
+    const { prisma, temporal, service } = setup();
+    const created = {
+      id: BigInt(21),
+      workflowId,
+      versionId: version.id,
+      status: 'PENDING',
+      context: { workflow: {}, nodes: {} },
+      temporalRunId: null,
+    };
+    prisma.workflowInstance.create.mockResolvedValue(created);
+    prisma.workflowInstance.updateMany.mockResolvedValue({ count: 1 });
+    prisma.workflowInstance.findUnique.mockResolvedValue({
+      ...created,
+      temporalRunId: 'wf-7-21',
+      status: 'CANCELLED',
+    });
+
+    await service.executeWorkflow(workflowId, {}, 'manual', temporal);
+
+    expect(temporal.cancelWorkflow).toHaveBeenCalledWith('wf-7-21');
+  });
+
+  it('reuses the original side-effect scope when retrying a failed instance', async () => {
+    const { prisma, temporal, service } = setup();
+    prisma.workflowInstance.findUnique.mockResolvedValueOnce({
+      id: BigInt(22),
+      workflowId,
+      versionId: version.id,
+      status: 'FAILED',
+      context: {
+        workflow: { orderId: 'O-1' },
+        nodes: {},
+        system: { operationScopeId: '21' },
+      },
+    });
+    const execute = jest
+      .spyOn(service, 'executeWorkflow')
+      .mockResolvedValue({ instanceId: '23' } as any);
+
+    await service.retryInstance(BigInt(22), 'alice', temporal);
+
+    expect(execute).toHaveBeenCalledWith(
+      workflowId,
+      {
+        workflow: { orderId: 'O-1' },
+        workflowVersionId: version.id,
+        idempotencyKey: 'retry:22',
+      },
+      'alice',
+      temporal,
+      {
+        operationScopeId: '21',
+        retryOfInstanceId: BigInt(22),
+      },
+    );
+  });
+
+  it('uses one stable execution for concurrent retries of the same failed instance', async () => {
+    const { prisma, temporal, service } = setup();
+    const failed = {
+      id: BigInt(22),
+      workflowId,
+      versionId: version.id,
+      status: 'FAILED',
+      context: { workflow: { orderId: 'O-1' }, nodes: {} },
+    };
+    prisma.workflowInstance.findUnique.mockResolvedValue(failed);
+    const execute = jest
+      .spyOn(service, 'executeWorkflow')
+      .mockResolvedValue({ instanceId: '23' } as any);
+
+    await Promise.all([
+      service.retryInstance(BigInt(22), 'alice', temporal),
+      service.retryInstance(BigInt(22), 'alice', temporal),
+    ]);
+
+    expect(execute).toHaveBeenCalledTimes(2);
+    expect(execute).toHaveBeenNthCalledWith(
+      1,
+      workflowId,
+      expect.objectContaining({ idempotencyKey: 'retry:22' }),
+      'alice',
+      temporal,
+      {
+        operationScopeId: '22',
+        retryOfInstanceId: BigInt(22),
+      },
+    );
+    expect(execute).toHaveBeenNthCalledWith(
+      2,
+      workflowId,
+      expect.objectContaining({ idempotencyKey: 'retry:22' }),
+      'alice',
+      temporal,
+      {
+        operationScopeId: '22',
+        retryOfInstanceId: BigInt(22),
+      },
+    );
+  });
+
+  it('returns the existing recovery instead of creating another retry from the same failed run', async () => {
+    const { prisma, temporal, service } = setup();
+    prisma.workflowInstance.findUnique.mockResolvedValueOnce({
+      id: BigInt(22),
+      workflowId,
+      versionId: version.id,
+      status: 'FAILED',
+      context: { workflow: { orderId: 'O-1' }, nodes: {} },
+      nodeExecutions: [],
+    });
+    prisma.workflowInstance.findFirst.mockResolvedValueOnce({
+      id: BigInt(23),
+      workflowId,
+      versionId: version.id,
+      status: 'COMPLETED',
+      temporalRunId: 'wf-7-23',
+    });
+    const execute = jest.spyOn(service, 'executeWorkflow');
+
+    await expect(
+      service.retryInstanceFromNode(BigInt(22), 'request', 'alice', temporal),
+    ).resolves.toEqual({
+      instanceId: '23',
+      temporalRunId: 'wf-7-23',
+      workflowVersionId: '11',
+      status: 'COMPLETED',
+    });
+    expect(execute).not.toHaveBeenCalled();
+  });
+
+  it('creates a checkpointed retry that preserves the original side-effect scope', async () => {
+    const { prisma, temporal, service } = setup();
+    const approvalOutput = {
+      previous: { eventId: 'event-1' },
+      result: { requestId: '6', result: 'APPROVED', approved: true },
+    };
+    prisma.workflowInstance.findUnique.mockResolvedValueOnce({
+      id: BigInt(22),
+      workflowId,
+      versionId: version.id,
+      status: 'FAILED',
+      context: {
+        workflow: { eventId: 'event-1' },
+        nodes: {},
+        system: { operationScopeId: '21' },
+      },
+      nodeExecutions: [
+        {
+          nodeId: 'approval',
+          status: 'COMPLETED',
+          output: approvalOutput,
+        },
+        { nodeId: 'request', status: 'FAILED', output: null },
+      ],
+    });
+    prisma.workflowVersion.findUnique.mockResolvedValueOnce({
+      dsl: {
+        nodes: [
+          { id: 'start', type: 'event_trigger', label: '业务事件触发' },
+          { id: 'approval', type: 'approval', label: '人工审批' },
+          { id: 'request', type: 'http_request', label: '确认报废' },
+        ],
+        edges: [
+          { source: 'start', target: 'approval', kind: 'FLOW' },
+          {
+            source: 'approval',
+            target: 'request',
+            sourceHandle: 'true',
+            kind: 'FLOW',
+          },
+        ],
+      },
+    });
+    const execute = jest
+      .spyOn(service, 'executeWorkflow')
+      .mockResolvedValue({ instanceId: '23' } as any);
+
+    await service.retryInstanceFromNode(
+      BigInt(22),
+      'request',
+      'alice',
+      temporal,
+    );
+
+    expect(execute).toHaveBeenCalledWith(
+      workflowId,
+      {
+        workflow: { eventId: 'event-1' },
+        workflowVersionId: version.id,
+        idempotencyKey: 'retry:22',
+      },
+      'alice',
+      temporal,
+      {
+        operationScopeId: '21',
+        retryCheckpoint: {
+          startNodeId: 'request',
+          completedNodeIds: ['approval'],
+          outputs: { approval: approvalOutput },
+        },
+        retryOfInstanceId: BigInt(22),
+        retryFromNodeId: 'request',
+      },
+    );
+  });
+
+  it('does not retry from inside a private branch pipeline', async () => {
+    const { prisma, temporal, service } = setup();
+    prisma.workflowInstance.findUnique.mockResolvedValueOnce({
+      id: BigInt(22),
+      workflowId,
+      versionId: version.id,
+      status: 'FAILED',
+      context: { workflow: {}, nodes: {} },
+      nodeExecutions: [
+        { nodeId: 'branch-request', status: 'FAILED', output: null },
+      ],
+    });
+    prisma.workflowVersion.findUnique.mockResolvedValueOnce({
+      dsl: {
+        nodes: [
+          { id: 'start', type: 'event_trigger', label: '业务事件触发' },
+          { id: 'parallel', type: 'parallel', label: '并行执行' },
+          {
+            id: 'branch-request',
+            type: 'http_request',
+            label: '分支请求',
+          },
+        ],
+        edges: [
+          { source: 'start', target: 'parallel', kind: 'FLOW' },
+          {
+            source: 'parallel',
+            target: 'branch-request',
+            kind: 'CALL',
+            pairId: 'branch-a',
+          },
+        ],
+      },
+    });
+
+    await expect(
+      service.retryInstanceFromNode(
+        BigInt(22),
+        'branch-request',
+        'alice',
+        temporal,
+      ),
+    ).rejects.toThrow('暂不支持从循环或并行分支内部重试');
+  });
+
+  it('keeps inherited checkpoint outputs when a resumed run fails farther downstream', async () => {
+    const { prisma, temporal, service } = setup();
+    const approvalOutput = {
+      result: { requestId: '6', result: 'APPROVED', approved: true },
+    };
+    const requestOutput = { status: 200, data: { resolved: true } };
+    prisma.workflowInstance.findUnique.mockResolvedValueOnce({
+      id: BigInt(23),
+      workflowId,
+      versionId: version.id,
+      status: 'FAILED',
+      context: {
+        workflow: { eventId: 'event-1' },
+        nodes: {},
+        system: {
+          operationScopeId: '21',
+          retryCheckpoint: {
+            startNodeId: 'request',
+            completedNodeIds: ['approval'],
+            outputs: { approval: approvalOutput },
+          },
+        },
+      },
+      nodeExecutions: [
+        { nodeId: 'request', status: 'COMPLETED', output: requestOutput },
+        { nodeId: 'notify', status: 'FAILED', output: null },
+      ],
+    });
+    prisma.workflowVersion.findUnique.mockResolvedValueOnce({
+      dsl: {
+        nodes: [
+          { id: 'start', type: 'event_trigger', label: '业务事件触发' },
+          { id: 'approval', type: 'approval', label: '人工审批' },
+          { id: 'request', type: 'http_request', label: '确认报废' },
+          { id: 'notify', type: 'http_request', label: '发送通知' },
+        ],
+        edges: [
+          { source: 'start', target: 'approval', kind: 'FLOW' },
+          { source: 'approval', target: 'request', kind: 'FLOW' },
+          { source: 'request', target: 'notify', kind: 'FLOW' },
+        ],
+      },
+    });
+    const execute = jest
+      .spyOn(service, 'executeWorkflow')
+      .mockResolvedValue({ instanceId: '24' } as any);
+
+    await service.retryInstanceFromNode(
+      BigInt(23),
+      'notify',
+      'alice',
+      temporal,
+    );
+
+    expect(execute).toHaveBeenCalledWith(
+      workflowId,
+      expect.objectContaining({
+        idempotencyKey: 'retry:23',
+      }),
+      'alice',
+      temporal,
+      expect.objectContaining({
+        operationScopeId: '21',
+        retryCheckpoint: {
+          startNodeId: 'notify',
+          completedNodeIds: ['approval', 'request'],
+          outputs: {
+            approval: approvalOutput,
+            request: requestOutput,
+          },
+        },
+      }),
+    );
+  });
+
+  it('restarts a stale reserved instance when Temporal has no execution', async () => {
+    const { prisma, temporal, service } = setup();
+    const reserved = {
+      id: BigInt(21),
+      workflowId,
+      versionId: version.id,
+      status: 'PENDING',
+      context: { workflow: { orderId: 'O-1' }, nodes: {} },
+      temporalRunId: 'wf-7-21',
+    };
+    prisma.workflowInstance.findMany.mockResolvedValueOnce([reserved]);
+    prisma.workflowVersion.findUnique.mockResolvedValueOnce({
+      dsl: version.dsl,
+    });
+    temporal.inspectWorkflow
+      .mockResolvedValueOnce({ kind: 'MISSING' })
+      .mockResolvedValueOnce({
+        kind: 'FOUND',
+        status: 'RUNNING',
+        startedAt: new Date('2026-08-13T00:00:00.000Z'),
+      });
+    prisma.workflowInstance.updateMany
+      .mockResolvedValueOnce({ count: 0 })
+      .mockResolvedValueOnce({ count: 1 });
+
+    await service.reconcileUnstartedInstances();
+
+    expect(temporal.startWorkflow).toHaveBeenCalledWith({
+      instanceId: 21,
+      workflowId: 7,
+      versionId: 11,
+      dsl: version.dsl,
+      context: reserved.context,
+    });
+    expect(prisma.workflowInstance.updateMany).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          id: BigInt(21),
+          temporalRunId: 'wf-7-21',
+          status: 'PENDING',
+        }),
+        data: expect.objectContaining({ status: 'RUNNING' }),
+      }),
+    );
+  });
+
+  it('cancels a reconciled execution when cancellation wins the restart race', async () => {
+    const { prisma, temporal, service } = setup();
+    const reserved = {
+      id: BigInt(21),
+      workflowId,
+      versionId: version.id,
+      status: 'PENDING',
+      context: { workflow: {}, nodes: {} },
+      temporalRunId: 'wf-7-21',
+    };
+    prisma.workflowInstance.findMany.mockResolvedValueOnce([reserved]);
+    prisma.workflowVersion.findUnique.mockResolvedValueOnce({
+      dsl: version.dsl,
+    });
+    prisma.workflowInstance.updateMany
+      .mockResolvedValueOnce({ count: 0 })
+      .mockResolvedValueOnce({ count: 0 });
+    prisma.workflowInstance.findUnique.mockResolvedValueOnce({
+      ...reserved,
+      status: 'CANCELLED',
+    });
+    temporal.inspectWorkflow
+      .mockResolvedValueOnce({ kind: 'MISSING' })
+      .mockResolvedValueOnce({
+        kind: 'FOUND',
+        status: 'RUNNING',
+        startedAt: new Date('2026-08-13T00:00:00.000Z'),
+      });
+
+    await service.reconcileUnstartedInstances();
+
+    expect(temporal.cancelWorkflow).toHaveBeenCalledWith('wf-7-21');
+  });
+
+  it('recovers a completed Temporal result without exposing internal context', async () => {
+    const { prisma, temporal, service } = setup();
+    prisma.workflowInstance.findMany.mockResolvedValueOnce([
+      {
+        id: BigInt(21),
+        workflowId,
+        versionId: version.id,
+        status: 'PENDING',
+        context: { workflow: { orderId: 'O-1' }, nodes: {} },
+        temporalRunId: 'wf-7-21',
+      },
+    ]);
+    prisma.workflowInstance.updateMany
+      .mockResolvedValueOnce({ count: 0 })
+      .mockResolvedValueOnce({ count: 1 });
+    temporal.inspectWorkflow.mockResolvedValueOnce({
+      kind: 'FOUND',
+      status: 'COMPLETED',
+      startedAt: new Date('2026-08-13T00:00:00.000Z'),
+      finishedAt: new Date('2026-08-13T00:00:01.000Z'),
+      result: {
+        status: 'COMPLETED',
+        context: {
+          workflow: { orderId: 'O-1' },
+          nodes: { internalNodeId: { secret: true } },
+        },
+        output: { approved: true },
+      },
+    });
+
+    await service.reconcileUnstartedInstances();
+
+    expect(prisma.workflowInstance.updateMany).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          status: 'COMPLETED',
+          result: {
+            workflow: { orderId: 'O-1' },
+            output: { approved: true },
+          },
+        }),
+      }),
+    );
+  });
+
+  it('reconciles a stale RUNNING instance after Temporal reaches a terminal state', async () => {
+    const { prisma, temporal, service } = setup();
+    prisma.workflowInstance.findMany.mockResolvedValueOnce([
+      {
+        id: BigInt(21),
+        workflowId,
+        versionId: version.id,
+        status: 'RUNNING',
+        context: { workflow: { orderId: 'O-1' }, nodes: {} },
+        temporalRunId: 'wf-7-21',
+      },
+    ]);
+    temporal.inspectWorkflow.mockResolvedValueOnce({
+      kind: 'FOUND',
+      status: 'FAILED',
+      startedAt: new Date('2026-08-13T00:00:00.000Z'),
+      finishedAt: new Date('2026-08-13T00:00:01.000Z'),
+    });
+
+    await service.reconcileUnstartedInstances();
+
+    expect(prisma.workflowInstance.updateMany).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        where: {
+          id: BigInt(21),
+          status: { in: ['PENDING', 'RUNNING'] },
+          temporalRunId: 'wf-7-21',
+        },
+        data: expect.objectContaining({ status: 'FAILED' }),
+      }),
+    );
+    expect(temporal.startWorkflow).not.toHaveBeenCalled();
+  });
+
+  it('fails a stale RUNNING instance when its Temporal execution is missing', async () => {
+    const { prisma, temporal, service } = setup();
+    prisma.workflowInstance.findMany.mockResolvedValueOnce([
+      {
+        id: BigInt(21),
+        workflowId,
+        versionId: version.id,
+        status: 'RUNNING',
+        context: { workflow: {}, nodes: {} },
+        temporalRunId: 'wf-7-21',
+      },
+    ]);
+    temporal.inspectWorkflow.mockResolvedValueOnce({ kind: 'MISSING' });
+
+    await service.reconcileUnstartedInstances();
+
+    expect(prisma.workflowInstance.updateMany).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        where: {
+          id: BigInt(21),
+          status: 'RUNNING',
+          temporalRunId: 'wf-7-21',
+        },
+        data: expect.objectContaining({
+          status: 'FAILED',
+          result: expect.objectContaining({
+            code: 'TEMPORAL_EXECUTION_MISSING',
+          }),
+        }),
+      }),
+    );
+    expect(temporal.startWorkflow).not.toHaveBeenCalled();
+  });
+});