@shipfox/api-workflows 11.0.0 → 12.1.0

package/src/db/job-listener-events.test.ts

@@ -1,5 +1,6 @@
 import {WORKFLOWS_JOB_EVENT_DELIVERED} from '@shipfox/api-workflows-dto';
 import {eq} from 'drizzle-orm';
+import type {WorkflowRunTriggerReference} from '#core/entities/workflow-run.js';
 import {db} from '#db/db.js';
 import {jobListenerEvents} from '#db/schema/job-listener-events.js';
 import {jobs} from '#db/schema/jobs.js';
@@ -13,6 +14,7 @@ interface DeliverOverrides {
   disposition?: 'fire' | 'resolve';
   eventRef?: string;
   provider?: string;
+  triggerReference?: WorkflowRunTriggerReference | null;
 }
 
 function deliver(overrides: DeliverOverrides = {}) {
@@ -24,6 +26,7 @@ function deliver(overrides: DeliverOverrides = {}) {
     source: 'github',
     event: 'pull_request_review',
     provider: overrides.provider ?? 'github',
+    triggerReference: overrides.triggerReference,
     payload: {action: 'submitted'},
     receivedAt: new Date('2026-01-01T00:00:00.000Z'),
   });
@@ -56,6 +59,22 @@ describe('deliverEventToListener', () => {
     expect(rows[0]?.disposition).toBe(disposition);
   });
 
+  it('persists the normalized trigger reference with the listener event', async () => {
+    const job = await jobFactory.create({}, {transient: {status: 'pending'}});
+    const triggerReference: WorkflowRunTriggerReference = {
+      project: {id: crypto.randomUUID()},
+      repository: 'acme/api',
+      ref: 'refs/heads/main',
+      commit: 'a'.repeat(40),
+      actor: 'octocat',
+    };
+
+    await deliver({jobId: job.id, triggerReference});
+
+    const rows = await listEvents(job.id);
+    expect(rows[0]?.triggerReference).toEqual(triggerReference);
+  });
+
   it('skips terminal jobs without throwing or buffering', async () => {
     const job = await jobFactory.create({}, {transient: {status: 'succeeded'}});
 

package/src/db/job-listener-events.ts

@@ -2,6 +2,7 @@ import {WORKFLOWS_JOB_EVENT_DELIVERED} from '@shipfox/api-workflows-dto';
 import {eq} from 'drizzle-orm';
 import {isJobTerminal} from '#core/entities/job.js';
 import type {JobListenerEventDisposition} from '#core/entities/job-listener-event.js';
+import type {WorkflowRunTriggerReference} from '#core/entities/workflow-run.js';
 import {recordListenerEventReceived} from '#metrics/instance.js';
 import {db} from './db.js';
 import {writeWorkflowsOutboxEvent} from './outbox-writes.js';
@@ -16,6 +17,7 @@ export interface DeliverEventToListenerParams {
   source: string;
   event: string;
   provider: string;
+  triggerReference?: WorkflowRunTriggerReference | null | undefined;
   payload: unknown;
   receivedAt: Date;
 }
@@ -47,6 +49,7 @@ export async function deliverEventToListener(
         deliveryId: params.deliveryId,
         source: params.source,
         event: params.event,
+        triggerReference: params.triggerReference ?? null,
         payload: params.payload,
         receivedAt: params.receivedAt,
       })

package/src/db/job-listeners.test.ts

@@ -6,6 +6,7 @@ import {createWorkflowExpression} from '@shipfox/expression';
 import {and, asc, eq, isNull} from 'drizzle-orm';
 import type {JobListeningTrigger, JobStatus} from '#core/entities/job.js';
 import type {JobExecutionStatus} from '#core/entities/job-execution.js';
+import type {WorkflowRunTriggerReference} from '#core/entities/workflow-run.js';
 import {nextStepForJob, recordStepResult} from '#core/job-execution.js';
 import {db} from '#db/db.js';
 import {deliverEventToListener} from '#db/job-listener-events.js';
@@ -83,6 +84,7 @@ function bufferEvent(
   disposition: 'fire' | 'resolve' = 'fire',
   eventRef = crypto.randomUUID(),
   receivedAt = new Date('2026-01-01T00:00:00.000Z'),
+  triggerReference?: WorkflowRunTriggerReference | null,
 ) {
   return deliverEventToListener({
     jobId,
@@ -92,6 +94,7 @@ function bufferEvent(
     source: 'github',
     event: 'pull_request',
     provider: 'github',
+    triggerReference,
     payload: {action: 'opened'},
     receivedAt,
   });
@@ -324,9 +327,16 @@ describe('activateJobListener', () => {
     const snapshot = payload.on[0]?.filter_snapshot;
     expect(snapshot).toEqual({
       run: expect.objectContaining({id: expect.any(String), name: 'Test Workflow'}),
-      trigger: {source: 'github', event: 'pull_request'},
+      trigger: {
+        source: 'github',
+        event: 'pull_request',
+        project: null,
+        repository: null,
+        ref: null,
+        commit: null,
+      },
       inputs: {environment: 'prod'},
-      job: {key: 'await'},
+      job: {key: 'await', name: 'await'},
       jobs: {
         build: expect.objectContaining({
           status: 'succeeded',
@@ -473,6 +483,69 @@ describe('drainListenerEventsIntoExecution', () => {
     ]);
   });
 
+  it('exposes each buffered event reference on its execution event', async () => {
+    const job = await createListeningJob({status: 'running', listenerStatus: 'listening'});
+    const firstReference: WorkflowRunTriggerReference = {
+      project: {id: crypto.randomUUID()},
+      repository: 'acme/one',
+      ref: 'refs/heads/main',
+      commit: '1'.repeat(40),
+      actor: 'octocat',
+    };
+    const secondReference: WorkflowRunTriggerReference = {
+      project: {id: crypto.randomUUID()},
+      repository: 'acme/two',
+      ref: 'refs/pull/12/head',
+      commit: '2'.repeat(40),
+      actor: 'octocat',
+    };
+
+    await bufferEvent(
+      job.id,
+      'fire',
+      crypto.randomUUID(),
+      new Date('2026-01-01T00:00:00.000Z'),
+      firstReference,
+    );
+    await bufferEvent(
+      job.id,
+      'fire',
+      crypto.randomUUID(),
+      new Date('2026-01-01T00:01:00.000Z'),
+      secondReference,
+    );
+
+    await drainListenerEventsIntoExecution({jobId: job.id, expectedSequence: 1});
+
+    const [execution] = await db()
+      .select()
+      .from(jobExecutions)
+      .where(and(eq(jobExecutions.jobId, job.id), eq(jobExecutions.sequence, 1)));
+    // The execution event carries the reference's location fields, not its actor:
+    // `WorkflowExecutionEvent` enumerates its own shape and the trigger actor is not part of
+    // it. Widening that is the listening-jobs contract's call, not this branch's.
+    const {actor: _firstActor, ...firstEventFields} = firstReference;
+    const {actor: _secondActor, ...secondEventFields} = secondReference;
+    expect(execution?.triggerEvents).toEqual([
+      {
+        source: 'github',
+        event: 'pull_request',
+        delivery_id: expect.any(String),
+        received_at: '2026-01-01T00:00:00.000Z',
+        ...firstEventFields,
+        data: {action: 'opened'},
+      },
+      {
+        source: 'github',
+        event: 'pull_request',
+        delivery_id: expect.any(String),
+        received_at: '2026-01-01T00:01:00.000Z',
+        ...secondEventFields,
+        data: {action: 'opened'},
+      },
+    ]);
+  });
+
   it('materializes a pending execution from buffered fire events and consumes them', async () => {
     const job = await createListeningJob({status: 'running', listenerStatus: 'listening'});
     await bufferEvent(job.id);
@@ -493,6 +566,97 @@ describe('drainListenerEventsIntoExecution', () => {
     expect(events.every((event) => event.consumedByExecutionId === executions[0]?.id)).toBe(true);
   });
 
+  it('persists a failed execution when listener variables are missing', async () => {
+    const job = await createListeningJobFromModel({
+      jobs: {
+        review: {
+          executionName: `Review ${template('vars.REGION')}`,
+          steps: [{run: `echo ${template('vars.MISSING')}`}],
+        },
+      },
+    });
+    await bufferEvent(job.id);
+
+    const result = await drainListenerEventsIntoExecution({
+      jobId: job.id,
+      expectedSequence: 1,
+      secrets: {
+        getVariablesByNamespace: async () => ({values: {}}),
+      },
+    });
+
+    const [execution] = await db()
+      .select()
+      .from(jobExecutions)
+      .where(eq(jobExecutions.jobId, job.id));
+    expect(result).toMatchObject({kind: 'execution', sequence: 1, status: 'failed'});
+    expect(execution).toMatchObject({
+      status: 'failed',
+      name: null,
+      evaluationTrace: [
+        expect.objectContaining({
+          expression: 'vars.MISSING',
+          roots: ['vars'],
+          fillTarget: 'execution-creation',
+          evaluatedAt: 'execution-creation',
+          field: 'run',
+          degraded: true,
+        }),
+      ],
+    });
+  });
+
+  it('resolves a distinct name for each listener firing with boundary variables', async () => {
+    const job = await createListeningJobFromModel({
+      jobs: {
+        review: {
+          name: 'Process review',
+          executionName: `Review ${template('vars.REGION')} ${template('execution.index')}`,
+          steps: [{run: 'echo review'}],
+        },
+      },
+    });
+    await db().update(jobs).set({name: 'Process review'}).where(eq(jobs.id, job.id));
+    const secrets = {
+      getVariablesByNamespace: async () => ({values: {REGION: 'eu-west'}}),
+    };
+    await bufferEvent(job.id);
+    await drainListenerEventsIntoExecution({
+      jobId: job.id,
+      expectedSequence: 1,
+      secrets,
+    });
+    await bufferEvent(job.id);
+    await drainListenerEventsIntoExecution({
+      jobId: job.id,
+      expectedSequence: 2,
+      secrets,
+    });
+
+    const executions = await db()
+      .select()
+      .from(jobExecutions)
+      .where(eq(jobExecutions.jobId, job.id))
+      .orderBy(asc(jobExecutions.sequence));
+    const stored = await readJob(job.id);
+
+    expect(stored?.name).toBe('Process review');
+    expect(executions.map((execution) => execution.name)).toEqual([
+      'Review eu-west 0',
+      'Review eu-west 1',
+    ]);
+    expect(executions.map((execution) => execution.evaluationTrace)).toEqual([
+      expect.arrayContaining([
+        expect.objectContaining({field: 'job.execution_name', expression: 'vars.REGION'}),
+        expect.objectContaining({field: 'job.execution_name', expression: 'execution.index'}),
+      ]),
+      expect.arrayContaining([
+        expect.objectContaining({field: 'job.execution_name', expression: 'vars.REGION'}),
+        expect.objectContaining({field: 'job.execution_name', expression: 'execution.index'}),
+      ]),
+    ]);
+  });
+
   it('uses the frozen agent tool materialization snapshot for listener executions', async () => {
     const model = workflowModel({
       jobs: {
@@ -823,12 +987,30 @@ describe('drainListenerEventsIntoExecution', () => {
     expect(stored?.outputs).toEqual({message: 'hello'});
   });
 
-  it('reports empty when nothing is buffered', async () => {
-    const job = await createListeningJob({status: 'running', listenerStatus: 'listening'});
+  it('reports empty without loading external state when nothing is buffered', async () => {
+    const job = await createListeningJobFromModel({
+      jobs: {
+        review: {
+          executionName: template('vars.REGION'),
+          steps: [{run: 'echo review'}],
+        },
+      },
+    });
+    let variableLoads = 0;
 
-    const result = await drainListenerEventsIntoExecution({jobId: job.id, expectedSequence: 1});
+    const result = await drainListenerEventsIntoExecution({
+      jobId: job.id,
+      expectedSequence: 1,
+      secrets: {
+        getVariablesByNamespace: () => {
+          variableLoads += 1;
+          return Promise.resolve({values: {REGION: 'eu-west'}});
+        },
+      },
+    });
 
     expect(result).toEqual({kind: 'empty'});
+    expect(variableLoads).toBe(0);
   });
 
   it('returns the existing execution when the sequence was already materialized', async () => {

package/src/db/job-listeners.ts

@@ -2,6 +2,7 @@ import type {AgentInterModuleClient} from '@shipfox/api-agent-dto/inter-module';
 import {readPersistedWorkflowModel} from '@shipfox/api-definitions-dto';
 import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto/inter-module';
 import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module';
+import type {SecretsInterModuleClient} from '@shipfox/api-secrets-dto/inter-module';
 import {
   WORKFLOWS_JOB_ACTIVATED,
   type WorkflowsJobActivatedEventDto,
@@ -10,7 +11,13 @@ import {and, asc, count, eq, inArray, isNull, notInArray, sql} from 'drizzle-orm
 import {type AgentDefaultsResolver, createAgentDefaultsResolver} from '#core/agent-defaults.js';
 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 {
+  JobExecution,
+  JobExecutionStatus,
+  WorkflowExecutionEvent,
+} from '#core/entities/job-execution.js';
+import {normalizeWorkflowExecutionEvent} from '#core/entities/job-execution.js';
+import {InterpolationUnresolvableError} from '#core/errors.js';
 import {type DeriveJobSuccessResult, deriveJobSuccess} from '#core/job-transition/index.js';
 import {
   type MaterializedListenerExecution,
@@ -38,6 +45,7 @@ import {toWorkflowRun, workflowRuns} from './schema/workflow-runs.js';
 import {
   bulkUpdateStepStatuses,
   getDirectDependencyJobContexts,
+  loadReferencedVariables,
   updateJobStatusAtVersion,
 } from './workflow-runs.js';
 
@@ -74,7 +82,7 @@ export async function activateJobListener(
 ): Promise<ActivateJobListenerResult> {
   return await db().transaction(async (tx) => {
     const [target] = await tx
-      .select({job: jobs, run: workflowRuns})
+      .select({job: jobs, attempt: workflowRunAttempts, run: workflowRuns})
       .from(jobs)
       .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
       .innerJoin(workflowRuns, eq(workflowRunAttempts.workflowRunId, workflowRuns.id))
@@ -138,6 +146,7 @@ export async function activateJobListener(
         run: toWorkflowRun(target.run),
         triggerPayload: target.run.triggerPayload,
         inputs: target.run.inputs,
+        vars: target.attempt.vars ?? undefined,
         plan: snapshotPlan,
         dependencyJobs,
       });
@@ -182,11 +191,61 @@ export interface DrainListenerEventsParams {
   projects?: ProjectsModuleClient | undefined;
   resolveAgentDefaults?: AgentDefaultsResolver | undefined;
   agent?: AgentInterModuleClient | undefined;
+  secrets?: Pick<SecretsInterModuleClient, 'getVariablesByNamespace'> | undefined;
 }
 
 export async function drainListenerEventsIntoExecution(
   params: DrainListenerEventsParams,
 ): Promise<DrainListenerEventsResult> {
+  const probeResult = await db().transaction(async (tx) => {
+    const existing = await findExistingExecution(params, tx);
+    if (existing) return existing;
+
+    const resolveRequested = await hasPendingResolveEvent(params.jobId, tx);
+    if (resolveRequested) return {kind: 'resolve-requested' as const};
+
+    const hasBufferedFire = await hasBufferedFireEvent(params.jobId, tx);
+    return hasBufferedFire ? null : {kind: 'empty' as const};
+  });
+  if (probeResult !== null) return probeResult;
+
+  // Resolve external state before opening the persistence transaction. The
+  // secrets module uses the shared pool and cannot reuse this transaction's
+  // connection across the inter-module boundary.
+  const materializationTarget = await loadListenerMaterializationTarget(params.jobId);
+  const model =
+    materializationTarget.attempt.model === null
+      ? null
+      : readPersistedWorkflowModel(materializationTarget.attempt.model);
+  const modelJob = model?.jobs.find((job) => job.key === materializationTarget.job.key);
+  let vars: Record<string, string> | undefined;
+  let variableResolutionError: InterpolationUnresolvableError | undefined;
+  if (model !== null && modelJob !== undefined) {
+    try {
+      vars = await loadReferencedVariables({
+        model,
+        jobs: [modelJob],
+        workspaceId: materializationTarget.run.workspaceId,
+        projectId: materializationTarget.run.projectId,
+        definitionId: materializationTarget.run.definitionId,
+        secrets: params.secrets,
+      });
+    } catch (error) {
+      if (!(error instanceof InterpolationUnresolvableError)) throw error;
+      variableResolutionError = error;
+    }
+  }
+  const agentToolContext =
+    materializationTarget.attempt.agentToolMaterialization === null
+      ? await loadAgentToolMaterializationContext({
+          model,
+          workspaceId: materializationTarget.run.workspaceId,
+          projectId: materializationTarget.run.projectId,
+          integrations: params.integrations,
+          projects: params.projects,
+        })
+      : undefined;
+
   const drained = await db().transaction(async (tx) => {
     const existing = await findExistingExecution(params, tx);
     if (existing) return {result: existing};
@@ -198,25 +257,20 @@ export async function drainListenerEventsIntoExecution(
     if (bufferedEvents.length === 0) return {result: {kind: 'empty' as const}};
 
     const target = await loadListenerMaterializationTarget(params.jobId, tx);
-    const model =
-      target.attempt.model === null ? null : readPersistedWorkflowModel(target.attempt.model);
-    const agentToolContext =
-      target.attempt.agentToolMaterialization === null
-        ? await loadAgentToolMaterializationContext({
-            model,
-            workspaceId: target.run.workspaceId,
-            projectId: target.run.projectId,
-            integrations: params.integrations,
-            projects: params.projects,
-          })
-        : undefined;
+    const priorExecutions = await loadListenerPriorExecutions(
+      params.jobId,
+      target.job.name ?? target.job.key,
+      tx,
+    );
     const materialized = await materializeListenerExecution({
       model,
       run: toWorkflowRun(target.run),
       job: toJob(target.job),
+      vars,
+      variableResolutionError,
       sequence: params.expectedSequence,
       triggerEvents: listenerTriggerEvents(bufferedEvents),
-      priorExecutions: target.priorExecutions,
+      priorExecutions,
       resolveAgentDefaults:
         params.resolveAgentDefaults ??
         (params.agent
@@ -315,7 +369,13 @@ type ApplyJobListenerResolutionResult =
 async function deriveJobListenerResolutionDecision(
   jobId: string,
 ): Promise<JobListenerResolutionDecision> {
-  const [jobRow] = await db().select().from(jobs).where(eq(jobs.id, jobId)).limit(1);
+  const [target] = await db()
+    .select({job: jobs, attempt: workflowRunAttempts})
+    .from(jobs)
+    .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
+    .where(eq(jobs.id, jobId))
+    .limit(1);
+  const jobRow = target?.job;
   if (!jobRow) throw new Error(`Job not found: ${jobId}`);
 
   const [executionRows, dependencyJobs] = await Promise.all([
@@ -330,8 +390,11 @@ async function deriveJobListenerResolutionDecision(
     expectedVersion: jobRow.version,
     ...deriveJobSuccess({
       success: jobRow.success,
-      executions: executionRows.map(toJobExecution),
+      executions: executionRows.map((execution) =>
+        toJobExecution(execution, jobRow.name ?? jobRow.key),
+      ),
       jobs: dependencyJobs,
+      vars: target.attempt.vars ?? undefined,
     }),
   };
 }
@@ -462,6 +525,21 @@ async function hasPendingResolveEvent(jobId: string, tx: Tx): Promise<boolean> {
   return resolveEvent !== undefined;
 }
 
+async function hasBufferedFireEvent(jobId: string, tx: Tx): Promise<boolean> {
+  const [fireEvent] = await tx
+    .select({id: jobListenerEvents.id})
+    .from(jobListenerEvents)
+    .where(
+      and(
+        eq(jobListenerEvents.jobId, jobId),
+        eq(jobListenerEvents.disposition, 'fire'),
+        isNull(jobListenerEvents.consumedByExecutionId),
+      ),
+    )
+    .limit(1);
+  return fireEvent !== undefined;
+}
+
 async function lockBufferedFireEvents(
   params: DrainListenerEventsParams,
   tx: Tx,
@@ -486,13 +564,19 @@ async function lockBufferedFireEvents(
 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,
-  }));
+  return bufferedEvents.map((event) =>
+    normalizeWorkflowExecutionEvent({
+      source: event.source,
+      event: event.event,
+      delivery_id: event.deliveryId,
+      received_at: event.receivedAt.toISOString(),
+      project: event.triggerReference?.project ?? null,
+      repository: event.triggerReference?.repository ?? null,
+      ref: event.triggerReference?.ref ?? null,
+      commit: event.triggerReference?.commit ?? null,
+      data: event.payload,
+    }),
+  );
 }
 
 async function persistMaterializedListenerExecution(
@@ -509,7 +593,7 @@ async function persistMaterializedListenerExecution(
     .values({
       jobId: params.jobId,
       sequence: params.sequence,
-      name: params.materialized.name,
+      name: params.materialized.nameOverride,
       runner: params.materialized.runner.length === 0 ? null : [...params.materialized.runner],
       status: params.materialized.status,
       statusReason: params.materialized.statusReason,
@@ -559,21 +643,29 @@ function drainExecutionResult(
   };
 }
 
-async function loadListenerMaterializationTarget(jobId: string, tx: Tx) {
-  const [target] = await tx
+async function loadListenerMaterializationTarget(jobId: string, tx?: Tx) {
+  const query = (tx ?? db())
     .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');
+    .limit(1);
+  const [target] = tx === undefined ? await query : await query.for('update');
   if (!target) throw new Error(`Job not found: ${jobId}`);
 
+  return target;
+}
+
+async function loadListenerPriorExecutions(
+  jobId: string,
+  fallbackName: string,
+  tx: Tx,
+): Promise<JobExecution[]> {
   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)};
+  return priorExecutions.map((execution) => toJobExecution(execution, fallbackName));
 }

package/src/db/schema/job-executions.ts

@@ -11,7 +11,11 @@ import {
   uuid,
 } from 'drizzle-orm/pg-core';
 import {toJobStatusReason} from '#core/entities/job.js';
-import type {JobExecution, WorkflowExecutionEvent} from '#core/entities/job-execution.js';
+import {
+  type JobExecution,
+  normalizeWorkflowExecutionEvent,
+  type WorkflowExecutionEvent,
+} from '#core/entities/job-execution.js';
 import type {PersistedEvaluationTraceEntry} from '#core/entities/step.js';
 import {pgTable} from './common.js';
 import {jobStatusReasonEnum, jobs} from './jobs.js';
@@ -32,7 +36,9 @@ export const jobExecutions = pgTable(
       .notNull()
       .references(() => jobs.id, {onDelete: 'cascade'}),
     sequence: integer('sequence').notNull(),
-    name: text('name').notNull(),
+    // A null value means no dynamic override was resolved. The core entity
+    // exposes the parent job's static name/key as the effective name.
+    name: text('name'),
     runner: jsonb('runner').$type<string[]>(),
     status: jobExecutionStatusEnum('status').notNull().default('pending'),
     statusReason: jobStatusReasonEnum('status_reason'),
@@ -62,16 +68,17 @@ export const jobExecutions = pgTable(
 export type JobExecutionDb = typeof jobExecutions.$inferSelect;
 export type JobExecutionCreateDb = typeof jobExecutions.$inferInsert;
 
-export function toJobExecution(row: JobExecutionDb): JobExecution {
+export function toJobExecution(row: JobExecutionDb, fallbackName: string): JobExecution {
   return {
     id: row.id,
     jobId: row.jobId,
     sequence: row.sequence,
-    name: row.name,
+    nameOverride: row.name,
+    name: row.name ?? fallbackName,
     runner: row.runner as string[] | null,
     status: row.status,
     statusReason: toJobStatusReason(row.statusReason),
-    triggerEvents: row.triggerEvents,
+    triggerEvents: row.triggerEvents.map(normalizeWorkflowExecutionEvent),
     outputs: row.outputs,
     evaluationTrace: row.evaluationTrace ?? null,
     version: row.version,

package/src/db/schema/job-listener-events.ts

@@ -1,6 +1,7 @@
 import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
 import {index, jsonb, pgEnum, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
 import type {JobListenerEvent} from '#core/entities/job-listener-event.js';
+import type {WorkflowRunTriggerReference} from '#core/entities/workflow-run.js';
 import {pgTable} from './common.js';
 import {jobExecutions} from './job-executions.js';
 import {jobs} from './jobs.js';
@@ -22,6 +23,7 @@ export const jobListenerEvents = pgTable(
     deliveryId: text('delivery_id').notNull(),
     source: text('source').notNull(),
     event: text('event').notNull(),
+    triggerReference: jsonb('trigger_reference').$type<WorkflowRunTriggerReference>(),
     payload: jsonb('payload').notNull(),
     receivedAt: timestamp('received_at', {withTimezone: true}).notNull(),
     consumedByExecutionId: uuid('consumed_by_execution_id').references(() => jobExecutions.id, {
@@ -50,6 +52,7 @@ export function toJobListenerEvent(row: JobListenerEventDb): JobListenerEvent {
     deliveryId: row.deliveryId,
     source: row.source,
     event: row.event,
+    triggerReference: row.triggerReference ?? null,
     payload: row.payload,
     receivedAt: row.receivedAt,
     consumedByExecutionId: row.consumedByExecutionId,

package/src/db/schema/step-attempts.ts

@@ -21,8 +21,8 @@ import {stepStatusEnum, steps} from './steps.js';
 
 // Append-only execution history. One row per dispatched attempt of a step,
 // inserted `running` at dispatch and finalized terminal at report. `steps` holds
-// the fast current projection; this table is the audit trail and — via the
-// unique (step_id, attempt) constraint — the idempotency anchor.
+// the fast current projection; this table is the audit trail. The unique
+// (step_id, attempt) constraint is the idempotency anchor.
 export const stepAttempts = pgTable(
   'step_attempts',
   {

package/src/db/schema/steps.ts

@@ -18,6 +18,7 @@ import {
   STEP_STATUS_REASONS,
   type Step,
   type StepConfigDispatchPlan,
+  type StepType,
   toStepStatusReason,
 } from '#core/entities/step.js';
 import {pgTable} from './common.js';
@@ -45,7 +46,7 @@ export const steps = pgTable(
     status: stepStatusEnum('status').notNull().default('pending'),
     statusReason: stepStatusReasonEnum('status_reason'),
     evaluationTrace: jsonb('evaluation_trace').$type<readonly PersistedEvaluationTraceEntry[]>(),
-    type: text('type').notNull(),
+    type: text('type').notNull().$type<StepType>(),
     config: jsonb('config').notNull().$type<Record<string, unknown>>(),
     condition: jsonb('condition').$type<WorkflowExpression>(),
     configPlan: jsonb('config_plan').$type<StepConfigDispatchPlan>(),