@shipfox/api-workflows 2.0.0

package/src/db/job-listeners.ts

@@ -0,0 +1,564 @@
+import type {AgentDefaultsResolver} from '@shipfox/api-agent/core/resolve-agent-config';
+import {
+  WORKFLOWS_JOB_ACTIVATED,
+  type WorkflowsJobActivatedEventDto,
+} from '@shipfox/api-workflows-dto';
+import {and, asc, count, eq, inArray, isNull, notInArray, sql} from 'drizzle-orm';
+import {loadAgentToolMaterializationContext} from '#core/agent-tools.js';
+import {isJobTerminal, type JobStatus, type ResolutionReason} from '#core/entities/job.js';
+import type {JobExecutionStatus, WorkflowExecutionEvent} from '#core/entities/job-execution.js';
+import {type DeriveJobSuccessResult, deriveJobSuccess} from '#core/job-transition/index.js';
+import {
+  type MaterializedListenerExecution,
+  materializeListenerExecution,
+} from '#core/listener-execution-materialization.js';
+import {
+  applyListenerFilterSnapshots,
+  assembleListenerSnapshotContext,
+  type ListenerTriggerWithSnapshot,
+  planListenerFilterSnapshots,
+} from '#core/step-config/assemble-run-context.js';
+import {
+  recordListenerEventsCoalesced,
+  recordWorkflowJobExecutionStatusChanged,
+  recordWorkflowListenerResolved,
+} from '#metrics/instance.js';
+import {db, type Tx} from './db.js';
+import {writeWorkflowsOutboxEvent} from './outbox-writes.js';
+import {type JobExecutionDb, jobExecutions, toJobExecution} from './schema/job-executions.js';
+import {type JobListenerEventDb, jobListenerEvents} from './schema/job-listener-events.js';
+import {jobs, toJob} from './schema/jobs.js';
+import {steps} from './schema/steps.js';
+import {workflowRunAttempts} from './schema/workflow-run-attempts.js';
+import {toWorkflowRun, workflowRuns} from './schema/workflow-runs.js';
+import {
+  bulkUpdateStepStatuses,
+  getDirectDependencyJobContexts,
+  updateJobStatusAtVersion,
+} from './workflow-runs.js';
+
+const TERMINAL_EXECUTION_STATUSES: JobExecutionStatus[] = ['succeeded', 'failed', 'cancelled'];
+const MAX_LISTENER_RESOLUTION_ATTEMPTS = 3;
+
+export interface ActivateJobListenerParams {
+  jobId: string;
+  expectedVersion: number;
+}
+
+export interface ActivateJobListenerResult {
+  status: 'running' | 'terminal';
+  jobStatus: JobStatus;
+  jobVersion: number;
+  executionCount: number;
+}
+
+type JobActivatedListenerMatcher = Extract<
+  WorkflowsJobActivatedEventDto,
+  {mode: 'listening'}
+>['on'][number] &
+  ListenerTriggerWithSnapshot;
+
+function applyActivatedListenerFilterSnapshots(
+  plans: Parameters<typeof applyListenerFilterSnapshots>[0],
+  context: Parameters<typeof applyListenerFilterSnapshots>[1],
+): JobActivatedListenerMatcher[] {
+  return applyListenerFilterSnapshots(plans, context);
+}
+
+export async function activateJobListener(
+  params: ActivateJobListenerParams,
+): Promise<ActivateJobListenerResult> {
+  return await db().transaction(async (tx) => {
+    const [target] = await tx
+      .select({job: jobs, run: workflowRuns})
+      .from(jobs)
+      .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
+      .innerJoin(workflowRuns, eq(workflowRunAttempts.workflowRunId, workflowRuns.id))
+      .where(eq(jobs.id, params.jobId))
+      .limit(1)
+      .for('update');
+    if (!target) throw new Error(`Job not found: ${params.jobId}`);
+
+    const [{value: executionCount} = {value: 0}] = await tx
+      .select({value: count()})
+      .from(jobExecutions)
+      .where(eq(jobExecutions.jobId, params.jobId));
+
+    if (['succeeded', 'failed', 'cancelled', 'skipped'].includes(target.job.status)) {
+      return {
+        status: 'terminal',
+        jobStatus: target.job.status,
+        jobVersion: target.job.version,
+        executionCount,
+      };
+    }
+
+    let job = toJob(target.job);
+    if (target.job.status === 'pending') {
+      const updated = await updateJobStatusAtVersion(tx, {
+        jobId: params.jobId,
+        status: 'running',
+        expectedVersion: params.expectedVersion,
+      });
+      if (!updated) {
+        const [existing] = await tx.select().from(jobs).where(eq(jobs.id, params.jobId)).limit(1);
+        if (existing?.status !== 'running') {
+          throw new Error(
+            `Optimistic lock failure activating listener job ${params.jobId} version ${params.expectedVersion}`,
+          );
+        }
+        job = toJob(existing);
+      } else {
+        job = updated.job;
+      }
+    }
+
+    const listenerRows = await tx
+      .update(jobs)
+      .set({listenerStatus: 'listening', updatedAt: new Date()})
+      .where(and(eq(jobs.id, params.jobId), eq(jobs.listenerStatus, 'inactive')))
+      .returning();
+
+    if (listenerRows[0]) {
+      const matchers = {
+        on: target.job.listeningOn ?? [],
+        until: target.job.listeningUntil ?? null,
+      };
+      const snapshotPlan = planListenerFilterSnapshots(matchers);
+      const dependencyJobs =
+        snapshotPlan.jobKeys.size === 0
+          ? []
+          : await getDirectDependencyJobContexts(params.jobId, tx);
+      const snapshotContext = assembleListenerSnapshotContext({
+        job: toJob(target.job),
+        run: toWorkflowRun(target.run),
+        triggerPayload: target.run.triggerPayload,
+        inputs: target.run.inputs,
+        plan: snapshotPlan,
+        dependencyJobs,
+      });
+
+      await writeWorkflowsOutboxEvent(tx, {
+        type: WORKFLOWS_JOB_ACTIVATED,
+        payload: {
+          jobId: params.jobId,
+          workflowRunId: target.run.id,
+          workspaceId: target.run.workspaceId,
+          mode: 'listening',
+          on: applyActivatedListenerFilterSnapshots(snapshotPlan.on, snapshotContext),
+          until:
+            matchers.until === null
+              ? null
+              : applyActivatedListenerFilterSnapshots(snapshotPlan.until, snapshotContext),
+        },
+      });
+    }
+
+    return {status: 'running', jobStatus: job.status, jobVersion: job.version, executionCount};
+  });
+}
+
+export type DrainListenerEventsResult =
+  | {
+      kind: 'execution';
+      jobExecutionId: string;
+      executionVersion: number;
+      sequence: number;
+      requiredLabels: string[];
+      status: JobExecutionStatus;
+    }
+  | {kind: 'resolve-requested'}
+  | {kind: 'empty'};
+
+export interface DrainListenerEventsParams {
+  jobId: string;
+  expectedSequence: number;
+  maxSize?: number | undefined;
+  resolveAgentDefaults?: AgentDefaultsResolver | undefined;
+}
+
+export async function drainListenerEventsIntoExecution(
+  params: DrainListenerEventsParams,
+): Promise<DrainListenerEventsResult> {
+  const drained = await db().transaction(async (tx) => {
+    const existing = await findExistingExecution(params, tx);
+    if (existing) return {result: existing};
+
+    const resolveRequested = await hasPendingResolveEvent(params.jobId, tx);
+    if (resolveRequested) return {result: {kind: 'resolve-requested' as const}};
+
+    const bufferedEvents = await lockBufferedFireEvents(params, tx);
+    if (bufferedEvents.length === 0) return {result: {kind: 'empty' as const}};
+
+    const target = await loadListenerMaterializationTarget(params.jobId, tx);
+    const agentToolContext =
+      target.attempt.agentToolMaterialization === null
+        ? await loadAgentToolMaterializationContext({
+            model: target.attempt.model,
+            workspaceId: target.run.workspaceId,
+            projectId: target.run.projectId,
+          })
+        : undefined;
+    const materialized = materializeListenerExecution({
+      model: target.attempt.model,
+      run: toWorkflowRun(target.run),
+      job: toJob(target.job),
+      sequence: params.expectedSequence,
+      triggerEvents: listenerTriggerEvents(bufferedEvents),
+      priorExecutions: target.priorExecutions,
+      resolveAgentDefaults: params.resolveAgentDefaults,
+      agentToolContext,
+      agentToolSnapshot: target.attempt.agentToolMaterialization,
+    });
+    const execution = await persistMaterializedListenerExecution(tx, {
+      jobId: params.jobId,
+      sequence: params.expectedSequence,
+      bufferedEventIds: bufferedEvents.map((event) => event.id),
+      materialized,
+    });
+
+    if (materialized.status === 'failed') {
+      recordWorkflowJobExecutionStatusChanged(materialized.status);
+    }
+
+    return {
+      result: drainExecutionResult(execution),
+      batchSize: bufferedEvents.length,
+    };
+  });
+
+  if (drained.result.kind === 'execution' && drained.batchSize !== undefined) {
+    recordListenerEventsCoalesced(drained.batchSize);
+  }
+
+  return drained.result;
+}
+
+export interface ListenerBufferPeek {
+  fireCount: number;
+  resolvePending: boolean;
+  oldestAgeMs: number;
+  newestAgeMs: number;
+}
+
+export async function peekListenerBuffer(params: {jobId: string}): Promise<ListenerBufferPeek> {
+  const [row] = await db()
+    .select({
+      fireCount: sql<number>`count(*) filter (where ${jobListenerEvents.disposition} = 'fire')::integer`,
+      resolvePending: sql<boolean>`coalesce(bool_or(${jobListenerEvents.disposition} = 'resolve'), false)`,
+      oldestAgeMs: sql<number>`coalesce(floor(extract(epoch from (statement_timestamp() - min(${jobListenerEvents.receivedAt}) filter (where ${jobListenerEvents.disposition} = 'fire'))) * 1000), 0)::integer`,
+      newestAgeMs: sql<number>`coalesce(floor(extract(epoch from (statement_timestamp() - max(${jobListenerEvents.receivedAt}) filter (where ${jobListenerEvents.disposition} = 'fire'))) * 1000), 0)::integer`,
+    })
+    .from(jobListenerEvents)
+    .where(
+      and(
+        eq(jobListenerEvents.jobId, params.jobId),
+        isNull(jobListenerEvents.consumedByExecutionId),
+      ),
+    );
+
+  return {
+    fireCount: row?.fireCount ?? 0,
+    resolvePending: row?.resolvePending ?? false,
+    oldestAgeMs: row?.oldestAgeMs ?? 0,
+    newestAgeMs: row?.newestAgeMs ?? 0,
+  };
+}
+
+export async function resolveJobListener(params: {
+  jobId: string;
+  reason: ResolutionReason;
+}): Promise<{status: 'succeeded' | 'failed'; jobVersion: number}> {
+  let result: ApplyJobListenerResolutionResult | undefined;
+  for (let attempt = 0; attempt < MAX_LISTENER_RESOLUTION_ATTEMPTS; attempt += 1) {
+    const decision = await deriveJobListenerResolutionDecision(params.jobId);
+    result = await applyJobListenerResolution(params, decision);
+    if (result.kind === 'applied') break;
+  }
+
+  if (result?.kind !== 'applied') {
+    throw new Error(`Optimistic lock failure resolving listener job ${params.jobId}`);
+  }
+
+  if (result.changed) recordWorkflowListenerResolved(params.reason);
+  return {status: result.status, jobVersion: result.jobVersion};
+}
+
+type JobListenerResolutionDecision = DeriveJobSuccessResult & {
+  expectedVersion: number;
+};
+
+type ApplyJobListenerResolutionResult =
+  | {
+      kind: 'applied';
+      status: 'succeeded' | 'failed';
+      jobVersion: number;
+      changed: boolean;
+    }
+  | {kind: 'stale'};
+
+async function deriveJobListenerResolutionDecision(
+  jobId: string,
+): Promise<JobListenerResolutionDecision> {
+  const [jobRow] = await db().select().from(jobs).where(eq(jobs.id, jobId)).limit(1);
+  if (!jobRow) throw new Error(`Job not found: ${jobId}`);
+
+  const [executionRows, dependencyJobs] = await Promise.all([
+    db()
+      .select()
+      .from(jobExecutions)
+      .where(eq(jobExecutions.jobId, jobId))
+      .orderBy(asc(jobExecutions.sequence), asc(jobExecutions.id)),
+    getDirectDependencyJobContexts(jobId),
+  ]);
+  return {
+    expectedVersion: jobRow.version,
+    ...deriveJobSuccess({
+      success: jobRow.success,
+      executions: executionRows.map(toJobExecution),
+      jobs: dependencyJobs,
+    }),
+  };
+}
+
+async function applyJobListenerResolution(
+  params: {
+    jobId: string;
+    reason: ResolutionReason;
+  },
+  decision: JobListenerResolutionDecision,
+): Promise<ApplyJobListenerResolutionResult> {
+  return await db().transaction(async (tx) => {
+    const [jobRow] = await tx
+      .select()
+      .from(jobs)
+      .where(eq(jobs.id, params.jobId))
+      .limit(1)
+      .for('update');
+    if (!jobRow) throw new Error(`Job not found: ${params.jobId}`);
+
+    if (jobRow.version !== decision.expectedVersion && !isJobTerminal(jobRow.status)) {
+      return {kind: 'stale' as const};
+    }
+
+    const listenerRows = await tx
+      .update(jobs)
+      .set({
+        listenerStatus: 'resolved',
+        resolutionReason: params.reason,
+        updatedAt: new Date(),
+      })
+      .where(and(eq(jobs.id, params.jobId), notInArray(jobs.listenerStatus, ['resolved'])))
+      .returning({id: jobs.id});
+
+    const updated = await updateJobStatusAtVersion(tx, {
+      jobId: params.jobId,
+      status: decision.status,
+      expectedVersion: decision.expectedVersion,
+      statusReason: decision.statusReason,
+      evaluationTrace: decision.trace,
+    });
+    const job = updated?.job ?? toJob(jobRow);
+    const resolvedStatus: 'succeeded' | 'failed' =
+      job.status === 'succeeded' ? 'succeeded' : 'failed';
+    return {
+      kind: 'applied' as const,
+      status: resolvedStatus,
+      jobVersion: job.version,
+      changed: listenerRows.length > 0 || updated?.changed === true,
+    };
+  });
+}
+
+export async function settleListenerJobExecution(params: {
+  jobExecutionId: string;
+  status: Extract<JobExecutionStatus, 'failed' | 'cancelled'>;
+}): Promise<void> {
+  const changed = await db().transaction(async (tx) => {
+    const [execution] = await tx
+      .update(jobExecutions)
+      .set({
+        status: params.status,
+        statusReason: params.status === 'failed' ? 'step_failed' : 'run_cancelled',
+        version: sql`${jobExecutions.version} + 1`,
+        updatedAt: new Date(),
+        finishedAt: sql`now()`,
+      })
+      .where(
+        and(
+          eq(jobExecutions.id, params.jobExecutionId),
+          notInArray(jobExecutions.status, TERMINAL_EXECUTION_STATUSES),
+        ),
+      )
+      .returning();
+    if (!execution) return false;
+    await bulkUpdateStepStatuses(
+      {jobExecutionId: params.jobExecutionId, status: params.status},
+      tx,
+    );
+    return true;
+  });
+
+  if (changed) {
+    recordWorkflowJobExecutionStatusChanged(params.status);
+  }
+}
+
+export async function countActiveListeners(): Promise<number> {
+  const [row] = await db()
+    .select({value: count()})
+    .from(jobs)
+    .where(eq(jobs.listenerStatus, 'listening'));
+  return row?.value ?? 0;
+}
+
+async function findExistingExecution(
+  params: DrainListenerEventsParams,
+  tx: Tx,
+): Promise<Extract<DrainListenerEventsResult, {kind: 'execution'}> | undefined> {
+  const [existing] = await tx
+    .select()
+    .from(jobExecutions)
+    .where(
+      and(
+        eq(jobExecutions.jobId, params.jobId),
+        eq(jobExecutions.sequence, params.expectedSequence),
+      ),
+    )
+    .limit(1);
+  if (!existing) return undefined;
+  return drainExecutionResult(existing);
+}
+
+async function hasPendingResolveEvent(jobId: string, tx: Tx): Promise<boolean> {
+  const [resolveEvent] = await tx
+    .select({id: jobListenerEvents.id})
+    .from(jobListenerEvents)
+    .where(
+      and(
+        eq(jobListenerEvents.jobId, jobId),
+        eq(jobListenerEvents.disposition, 'resolve'),
+        isNull(jobListenerEvents.consumedByExecutionId),
+      ),
+    )
+    .orderBy(asc(jobListenerEvents.receivedAt), asc(jobListenerEvents.id))
+    .limit(1)
+    .for('update');
+  return resolveEvent !== undefined;
+}
+
+async function lockBufferedFireEvents(
+  params: DrainListenerEventsParams,
+  tx: Tx,
+): Promise<JobListenerEventDb[]> {
+  const bufferedQuery = tx
+    .select()
+    .from(jobListenerEvents)
+    .where(
+      and(
+        eq(jobListenerEvents.jobId, params.jobId),
+        eq(jobListenerEvents.disposition, 'fire'),
+        isNull(jobListenerEvents.consumedByExecutionId),
+      ),
+    )
+    .orderBy(asc(jobListenerEvents.receivedAt), asc(jobListenerEvents.id));
+  return await (params.maxSize === undefined
+    ? bufferedQuery
+    : bufferedQuery.limit(params.maxSize)
+  ).for('update');
+}
+
+function listenerTriggerEvents(
+  bufferedEvents: readonly JobListenerEventDb[],
+): WorkflowExecutionEvent[] {
+  return bufferedEvents.map((event) => ({
+    source: event.source,
+    event: event.event,
+    delivery_id: event.deliveryId,
+    received_at: event.receivedAt.toISOString(),
+    data: event.payload,
+  }));
+}
+
+async function persistMaterializedListenerExecution(
+  tx: Tx,
+  params: {
+    readonly jobId: string;
+    readonly sequence: number;
+    readonly bufferedEventIds: readonly string[];
+    readonly materialized: MaterializedListenerExecution;
+  },
+): Promise<JobExecutionDb> {
+  const [execution] = await tx
+    .insert(jobExecutions)
+    .values({
+      jobId: params.jobId,
+      sequence: params.sequence,
+      name: params.materialized.name,
+      runner: params.materialized.runner.length === 0 ? null : [...params.materialized.runner],
+      status: params.materialized.status,
+      statusReason: params.materialized.statusReason,
+      triggerEvents: [...params.materialized.triggerEvents],
+      evaluationTrace: params.materialized.evaluationTrace,
+      ...(params.materialized.status === 'failed' ? {finishedAt: sql`now()`} : {}),
+    })
+    .returning();
+  if (!execution) throw new Error('Insert returned no rows');
+
+  await tx
+    .update(jobListenerEvents)
+    .set({consumedByExecutionId: execution.id})
+    .where(inArray(jobListenerEvents.id, [...params.bufferedEventIds]));
+
+  if (params.materialized.status === 'pending' && params.materialized.steps.length > 0) {
+    await tx.insert(steps).values(
+      params.materialized.steps.map((step) => ({
+        jobExecutionId: execution.id,
+        key: step.key,
+        name: step.name,
+        sourceLocation: step.sourceLocation,
+        status: step.status,
+        type: step.type,
+        config: step.config,
+        configPlan: step.configPlan ?? null,
+        authoredConfig: step.authoredConfig,
+        condition: step.condition ?? null,
+        position: step.position,
+      })),
+    );
+  }
+
+  return execution;
+}
+
+function drainExecutionResult(
+  execution: JobExecutionDb,
+): Extract<DrainListenerEventsResult, {kind: 'execution'}> {
+  return {
+    kind: 'execution',
+    jobExecutionId: execution.id,
+    executionVersion: execution.version,
+    sequence: execution.sequence,
+    requiredLabels: execution.runner ?? [],
+    status: execution.status,
+  };
+}
+
+async function loadListenerMaterializationTarget(jobId: string, tx: Tx) {
+  const [target] = await tx
+    .select({job: jobs, attempt: workflowRunAttempts, run: workflowRuns})
+    .from(jobs)
+    .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
+    .innerJoin(workflowRuns, eq(workflowRunAttempts.workflowRunId, workflowRuns.id))
+    .where(eq(jobs.id, jobId))
+    .limit(1)
+    .for('update');
+  if (!target) throw new Error(`Job not found: ${jobId}`);
+
+  const priorExecutions = await tx
+    .select()
+    .from(jobExecutions)
+    .where(eq(jobExecutions.jobId, jobId))
+    .orderBy(asc(jobExecutions.sequence), asc(jobExecutions.id));
+  return {...target, priorExecutions: priorExecutions.map(toJobExecution)};
+}

package/src/db/outbox-writes.ts

@@ -0,0 +1,40 @@
+import type {WorkflowsEventMapDto} from '@shipfox/api-workflows-dto';
+import {writeOutboxEvent, writeOutboxEvents} from '@shipfox/node-outbox';
+import type {Tx} from './db.js';
+import {workflowsOutbox} from './schema/outbox.js';
+
+type WorkflowsOutboxEvent = {
+  [K in keyof WorkflowsEventMapDto & string]: {
+    type: K;
+    payload: WorkflowsEventMapDto[K];
+  };
+}[keyof WorkflowsEventMapDto & string];
+
+export async function writeWorkflowsOutboxEvent(
+  tx: Tx,
+  event: WorkflowsOutboxEvent,
+): Promise<void> {
+  await writeOutboxEvent<WorkflowsEventMapDto>(tx, workflowsOutbox, {
+    ...event,
+    orderingKey: workflowRunOrderingKey(event),
+  });
+}
+
+export async function writeWorkflowsOutboxEvents(
+  tx: Tx,
+  events: WorkflowsOutboxEvent[],
+): Promise<void> {
+  await writeOutboxEvents<WorkflowsEventMapDto>(
+    tx,
+    workflowsOutbox,
+    events.map((event) => ({
+      ...event,
+      orderingKey: workflowRunOrderingKey(event),
+    })),
+  );
+}
+
+function workflowRunOrderingKey(event: WorkflowsOutboxEvent): string | undefined {
+  const workflowRunId = (event.payload as {workflowRunId?: unknown}).workflowRunId;
+  return typeof workflowRunId === 'string' ? workflowRunId : undefined;
+}

package/src/db/rerun-listener.test.ts

@@ -0,0 +1,64 @@
+import {and, desc, eq} from 'drizzle-orm';
+import {db} from '#db/db.js';
+import {jobExecutions} from '#db/schema/job-executions.js';
+import {jobs} from '#db/schema/jobs.js';
+import {workflowRunAttempts} from '#db/schema/workflow-run-attempts.js';
+import {createRerunWorkflowRun, getWorkflowRunByAttemptId} from '#db/workflow-runs.js';
+import {jobFactory} from '#test/index.js';
+
+describe('createRerunWorkflowRun with a failed listener', () => {
+  it('re-creates the listener fresh without carrying it over', async () => {
+    const job = await jobFactory.create({}, {transient: {status: 'failed'}});
+    await db()
+      .update(jobs)
+      .set({
+        mode: 'listening',
+        status: 'failed',
+        statusReason: 'timed_out',
+        listenerStatus: 'resolved',
+        resolutionReason: 'timeout',
+        maxExecutions: 5,
+        onResolve: 'cancel',
+      })
+      .where(eq(jobs.id, job.id));
+    await db()
+      .update(workflowRunAttempts)
+      .set({status: 'failed'})
+      .where(eq(workflowRunAttempts.id, job.workflowRunAttemptId));
+    const sourceRun = await getWorkflowRunByAttemptId(job.workflowRunAttemptId);
+    if (!sourceRun) throw new Error('source run not found');
+
+    const rerun = await createRerunWorkflowRun({
+      workflowRunId: sourceRun.id,
+      mode: 'failed',
+      actorUserId: crypto.randomUUID(),
+    });
+
+    const [newAttempt] = await db()
+      .select()
+      .from(workflowRunAttempts)
+      .where(eq(workflowRunAttempts.workflowRunId, rerun.id))
+      .orderBy(desc(workflowRunAttempts.attempt))
+      .limit(1);
+    if (!newAttempt) throw new Error('new attempt not found');
+    const [clonedJob] = await db()
+      .select()
+      .from(jobs)
+      .where(and(eq(jobs.workflowRunAttemptId, newAttempt.id), eq(jobs.mode, 'listening')));
+    if (!clonedJob) throw new Error('cloned listener job not found');
+    const clonedExecutions = await db()
+      .select()
+      .from(jobExecutions)
+      .where(eq(jobExecutions.jobId, clonedJob.id));
+
+    expect(clonedJob.status).toBe('pending');
+    expect(clonedJob.carriedOver).toBe(false);
+    expect(clonedJob.listenerStatus).toBe('inactive');
+    expect(clonedJob.resolutionReason).toBeNull();
+    // Listener config carries over so the retried run behaves identically.
+    expect(clonedJob.maxExecutions).toBe(5);
+    expect(clonedJob.onResolve).toBe('cancel');
+    // A fresh listener starts with no firings to re-run.
+    expect(clonedExecutions).toHaveLength(0);
+  });
+});