@shipfox/api-workflows 11.0.0 → 12.0.0

package/src/core/checkout.ts

@@ -1,58 +1,51 @@
 import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto/inter-module';
 import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module';
-import {getJobById, getWorkflowRunByAttemptId} from '#db/workflow-runs.js';
-import {
-  CheckoutIntentUnresolvedError,
-  JobNotFoundError,
-  WorkflowRunNotFoundError,
-} from './errors.js';
+import {checkoutTargetValidationIssues} from '@shipfox/workflow-document';
+import {z} from 'zod';
+import type {Step} from '#core/entities/step.js';
+import type {WorkflowRunTriggerReference} from '#core/entities/workflow-run.js';
+import {CheckoutConfigInvalidError, CheckoutIntentUnresolvedError} from './errors.js';
 
-export interface CheckoutIntent {
-  workspaceId: string;
-  connectionId: string;
-  externalRepositoryId: string;
-  persistCredentials: boolean;
-  permissions: {contents: 'read' | 'write'};
-}
-
-/**
- * Resolves what to check out for a job, keyed off the authoritative `jobId`
- * (`workflowRunId`/`workflowRunAttemptId`/`workspaceId` in the lease claim are informational).
- * Chain: job → attempt → run → project source metadata. Credential-free.
- */
-export async function resolveCheckoutIntent(
-  jobId: string,
-  projects: ProjectsModuleClient,
-): Promise<CheckoutIntent> {
-  const job = await getJobById(jobId);
-  if (!job) throw new JobNotFoundError(jobId);
-
-  const run = await getWorkflowRunByAttemptId(job.workflowRunAttemptId);
-  if (!run) throw new WorkflowRunNotFoundError(job.workflowRunAttemptId);
+const checkoutConfigSchema = z
+  .object({
+    project: z.string().uuid().optional(),
+    connection: z.string().min(1).optional(),
+    repository: z.string().min(1).optional(),
+    ref: z.string().min(1).optional(),
+    fetch_depth: z.number().int().nonnegative().optional(),
+    permissions: z.object({contents: z.enum(['read', 'write'])}).optional(),
+    persist_credentials: z.boolean().optional(),
+  })
+  .superRefine((checkout, context) => {
+    for (const validationIssue of checkoutTargetValidationIssues(checkout)) {
+      const message =
+        validationIssue.kind === 'project-with-connection'
+          ? 'Checkout project cannot be combined with a connection.'
+          : validationIssue.kind === 'project-with-repository'
+            ? 'Checkout project cannot be combined with a repository.'
+            : 'Checkout connection requires a repository.';
+      context.addIssue({
+        code: 'custom',
+        path: [validationIssue.path],
+        message,
+      });
+    }
+  });
 
-  const {project} = await projects.getProjectById({projectId: run.projectId});
-  if (project === null) throw new CheckoutIntentUnresolvedError(run.projectId);
+type CheckoutConfig = z.infer<typeof checkoutConfigSchema>;
 
-  return {
-    workspaceId: project.workspaceId,
-    connectionId: project.sourceConnectionId,
-    externalRepositoryId: project.sourceExternalRepositoryId,
-    persistCredentials: job.checkout.persistCredentials,
-    permissions: job.checkout.permissions,
-  };
-}
-
-/**
- * Resolves the job's checkout intent and exchanges it for a short-lived,
- * scoped checkout spec. Omitting `ref` lets the provider use the repository's
- * default branch while preserving the JSON-only inter-module boundary.
- */
-export async function createJobCheckoutSpec({
-  jobId,
+export async function createStepCheckoutSpec({
+  step,
+  workspaceId,
+  projectId,
+  triggerReference,
   integrations,
   projects,
 }: {
-  jobId: string;
+  step: Step;
+  workspaceId: string;
+  projectId: string;
+  triggerReference?: WorkflowRunTriggerReference | null | undefined;
   integrations: IntegrationsModuleClient;
   projects: ProjectsModuleClient;
 }): Promise<{
@@ -62,29 +55,119 @@ export async function createJobCheckoutSpec({
     credentials?: {username: string; token: string; expiresAt: Date};
     gitAuthor?: {name: string; email: string};
   };
+  fetchDepth: number;
   persistCredentials: boolean;
 }> {
-  const intent = await resolveCheckoutIntent(jobId, projects);
+  const checkout = parseCheckoutConfig(step);
+  const {project: defaultProject} = await projects.getProjectById({projectId});
+  if (defaultProject === null || defaultProject === undefined) {
+    throw new CheckoutIntentUnresolvedError({kind: 'project', value: projectId});
+  }
+
+  const target = await checkoutTarget({
+    checkout,
+    defaultProjectId: projectId,
+    defaultConnectionId: defaultProject.sourceConnectionId,
+    integrations,
+    workspaceId,
+  });
+  const resolvedTarget = await projects.resolveCheckoutTarget({
+    workspaceId,
+    defaults: {
+      connectionId: defaultProject.sourceConnectionId,
+      owner: defaultOwner(defaultProject.sourceRepositoryOwner, checkout.repository),
+    },
+    target,
+  });
+  const ref =
+    checkout.ref ??
+    (triggerReference?.project?.id === resolvedTarget.projectId
+      ? (triggerReference.commit ?? undefined)
+      : undefined);
   const response = await integrations.createCheckoutSpec({
-    workspaceId: intent.workspaceId,
-    connectionId: intent.connectionId,
-    externalRepositoryId: intent.externalRepositoryId,
-    permissions: intent.permissions,
+    workspaceId,
+    connectionId: resolvedTarget.connectionId,
+    externalRepositoryId: resolvedTarget.externalRepositoryId,
+    ...(ref === undefined ? {} : {ref}),
+    permissions: checkout.permissions ?? {contents: 'read'},
   });
-  const {credentials, gitAuthor, ...checkout} = response;
+
   return {
     spec: {
-      ...checkout,
-      ...(credentials
+      repositoryUrl: response.repositoryUrl,
+      ref: response.ref,
+      ...(response.credentials
         ? {
             credentials: {
-              ...credentials,
-              expiresAt: new Date(credentials.expiresAt),
+              ...response.credentials,
+              expiresAt: new Date(response.credentials.expiresAt),
             },
           }
         : {}),
-      ...(gitAuthor ? {gitAuthor} : {}),
+      ...(response.gitAuthor === undefined ? {} : {gitAuthor: response.gitAuthor}),
     },
-    persistCredentials: intent.persistCredentials,
+    fetchDepth: checkout.fetch_depth ?? 1,
+    persistCredentials: checkout.persist_credentials ?? true,
   };
 }
+
+function parseCheckoutConfig(step: Step): CheckoutConfig {
+  const result = checkoutConfigSchema.safeParse(step.config.checkout);
+  if (!result.success) {
+    throw new CheckoutConfigInvalidError(step.id);
+  }
+  return result.data;
+}
+
+async function checkoutTarget(params: {
+  checkout: CheckoutConfig;
+  defaultProjectId: string;
+  defaultConnectionId: string;
+  integrations: IntegrationsModuleClient;
+  workspaceId: string;
+}) {
+  const {checkout} = params;
+  if (checkout.project !== undefined) return {project: checkout.project};
+  if (checkout.repository !== undefined) {
+    const connection =
+      checkout.connection === undefined
+        ? undefined
+        : await resolveConnectionId({
+            integrations: params.integrations,
+            workspaceId: params.workspaceId,
+            defaultConnectionId: params.defaultConnectionId,
+            slug: checkout.connection,
+          });
+    return {
+      ...(connection === undefined ? {} : {connection}),
+      repository: checkout.repository,
+    };
+  }
+  return {project: params.defaultProjectId};
+}
+
+async function resolveConnectionId(params: {
+  integrations: IntegrationsModuleClient;
+  workspaceId: string;
+  defaultConnectionId: string;
+  slug: string;
+}): Promise<string> {
+  const connection = await params.integrations.resolveConnection({
+    workspaceId: params.workspaceId,
+    slug: params.slug,
+  });
+  if (connection === null) {
+    throw new CheckoutIntentUnresolvedError({kind: 'connection', value: params.slug});
+  }
+  return connection.id;
+}
+
+function defaultOwner(
+  projectOwner: string | null | undefined,
+  repository: string | undefined,
+): string {
+  if (projectOwner) return projectOwner;
+  const separator = repository?.indexOf('/') ?? -1;
+  if (separator > 0 && repository !== undefined) return repository.slice(0, separator);
+  return 'unknown';
+}

package/src/core/entities/job-execution.test.ts

@@ -0,0 +1,21 @@
+import {normalizeWorkflowExecutionEvent} from './job-execution.js';
+
+describe('normalizeWorkflowExecutionEvent', () => {
+  it('fills null reference fields for legacy persisted events', () => {
+    const legacyEvent = {
+      source: 'github',
+      event: 'push',
+      delivery_id: 'delivery-1',
+      received_at: '2026-07-20T12:00:00.000Z',
+      data: {ref: 'refs/heads/main'},
+    };
+
+    expect(normalizeWorkflowExecutionEvent(legacyEvent)).toEqual({
+      ...legacyEvent,
+      project: null,
+      repository: null,
+      ref: null,
+      commit: null,
+    });
+  });
+});

package/src/core/entities/job-execution.ts

@@ -1,5 +1,6 @@
 import type {JobStatus, JobStatusReason} from './job.js';
 import type {PersistedEvaluationTraceEntry} from './step.js';
+import type {WorkflowRunTriggerReference} from './workflow-run.js';
 
 export type JobExecutionStatus = Exclude<JobStatus, 'skipped'>;
 
@@ -8,13 +9,36 @@ export interface WorkflowExecutionEvent {
   event: string;
   delivery_id: string;
   received_at: string;
+  project: WorkflowRunTriggerReference['project'];
+  repository: WorkflowRunTriggerReference['repository'];
+  ref: WorkflowRunTriggerReference['ref'];
+  commit: WorkflowRunTriggerReference['commit'];
   data: unknown;
 }
 
+export function normalizeWorkflowExecutionEvent(
+  event: Omit<WorkflowExecutionEvent, 'project' | 'repository' | 'ref' | 'commit'> &
+    Partial<Pick<WorkflowExecutionEvent, 'project' | 'repository' | 'ref' | 'commit'>>,
+): WorkflowExecutionEvent {
+  return {
+    source: event.source,
+    event: event.event,
+    delivery_id: event.delivery_id,
+    received_at: event.received_at,
+    project: event.project ?? null,
+    repository: event.repository ?? null,
+    ref: event.ref ?? null,
+    commit: event.commit ?? null,
+    data: event.data,
+  };
+}
+
 export interface JobExecution {
   id: string;
   jobId: string;
   sequence: number;
+  /** A dynamically resolved name; null means use the parent job's fallback. */
+  nameOverride: string | null;
   name: string;
   runner: string[] | null;
   status: JobExecutionStatus;

package/src/core/entities/job-listener-event.ts

@@ -1,3 +1,5 @@
+import type {WorkflowRunTriggerReference} from './workflow-run.js';
+
 export type JobListenerEventDisposition = 'fire' | 'resolve';
 
 export interface JobListenerEvent {
@@ -8,6 +10,7 @@ export interface JobListenerEvent {
   deliveryId: string;
   source: string;
   event: string;
+  triggerReference: WorkflowRunTriggerReference | null;
   payload: unknown;
   receivedAt: Date;
   consumedByExecutionId: string | null;

package/src/core/entities/step.ts

@@ -8,11 +8,15 @@ import type {
   ResolvedField,
   WorkflowExpression,
 } from '@shipfox/expression';
-import type {AgentThinking, Harness} from '@shipfox/workflow-document';
+import type {Harness} from '@shipfox/workflow-document';
 import type {InterpolationUnresolvableField} from '../errors.js';
 
 export type StepStatus = 'pending' | 'running' | 'succeeded' | 'failed' | 'cancelled' | 'skipped';
 
+export const STEP_TYPES = ['setup', 'run', 'agent', 'checkout'] as const;
+
+export type StepType = (typeof STEP_TYPES)[number];
+
 export const STEP_STATUS_REASONS = [
   'default_gate_rejected',
   'condition_rejected',
@@ -61,14 +65,22 @@ export interface StepConfigEvaluationTraceEntry extends EvaluationTraceEntry {
 }
 
 export interface StepConfigDispatchPlan {
+  working_directory?: ResolvedField;
   run?: ResolvedField;
   env?: Readonly<Record<string, ResolvedField>>;
+  checkout?: {
+    project?: ResolvedField;
+    connection?: ResolvedField;
+    repository?: ResolvedField;
+    ref?: ResolvedField;
+    path?: ResolvedField;
+  };
   agent?: {
     prompt?: ResolvedField;
     model?: ResolvedField;
     provider?: ResolvedField;
     harness?: Harness;
-    thinking?: AgentThinking;
+    thinking?: ResolvedField;
     tools?: readonly string[];
     integrations?: readonly MaterializedAgentIntegrationConfigDto[];
     mcpServers?: readonly AgentIntegrationMcpServerConfigDto[];
@@ -85,7 +97,7 @@ export interface Step {
   status: StepStatus;
   statusReason: StepStatusReason | null;
   evaluationTrace: readonly PersistedEvaluationTraceEntry[] | null;
-  type: string;
+  type: StepType;
   config: Record<string, unknown>;
   condition: WorkflowExpression | null;
   configPlan: StepConfigDispatchPlan | null;

package/src/core/entities/workflow-run-attempt.ts

@@ -12,6 +12,7 @@ export interface WorkflowRunAttempt {
   rerunMode: RerunMode | null;
   rerunByUserId: string | null;
   model: WorkflowModel | null;
+  vars: Record<string, string> | null;
   agentToolMaterialization: AgentToolMaterializationSnapshot | null;
   version: number;
   createdAt: Date;

package/src/core/entities/workflow-run.ts

@@ -22,6 +22,14 @@ export function isWorkflowRunTerminal(
   return TERMINAL_WORKFLOW_RUN_STATUSES.has(status);
 }
 
+export interface WorkflowRunTriggerReference {
+  project: {id: string} | null;
+  repository: string | null;
+  ref: string | null;
+  commit: string | null;
+  actor: string | null;
+}
+
 export interface WorkflowSourceSnapshot {
   content: string;
   format: 'yaml';
@@ -57,13 +65,21 @@ export interface WorkflowRun {
   workspaceId: string;
   projectId: string;
   definitionId: string;
+  number: number;
+  /** Effective runtime name: the resolved override, or workflowName when absent. */
   name: string;
+  /** Static workflow-name snapshot preserved from the definition at creation. */
+  workflowName: string;
+  /** Nullable resolved override retained for rerun fidelity. */
+  nameOverride: string | null;
   status: WorkflowRunStatus;
   currentAttempt: number;
   triggerProvider: string | null;
   triggerSource: string;
   triggerEvent: string;
   triggerPayload: TriggerPayload;
+  /** Provider-neutral trigger facts captured at run creation, when available. */
+  triggerReference?: WorkflowRunTriggerReference | null | undefined;
   inputs: Record<string, unknown> | null;
   sourceSnapshot: WorkflowSourceSnapshot | null;
   triggerIdempotencyKey: string | null;

package/src/core/errors.ts

@@ -61,11 +61,19 @@ export type InterpolationUnresolvableField =
   | 'agent.prompt'
   | 'agent.model'
   | 'agent.provider'
+  | 'agent.thinking'
   | 'job.runner'
   | 'job.outputs'
-  | 'job.name'
+  | 'job.execution_name'
+  | 'workflow.run_name'
   | 'step.name'
-  | 'step.feedback';
+  | 'step.working_directory'
+  | 'step.feedback'
+  | 'checkout.project'
+  | 'checkout.connection'
+  | 'checkout.repository'
+  | 'checkout.ref'
+  | 'checkout.path';
 
 export class InterpolationUnresolvableError extends Error {
   readonly field: InterpolationUnresolvableField;
@@ -182,15 +190,21 @@ export class NoFailedJobsError extends Error {
   }
 }
 
-// The run's project (and therefore its source repository) cannot be resolved, so
-// there is nothing to check out.
+// The checkout target cannot be resolved, so there is nothing to check out.
 export class CheckoutIntentUnresolvedError extends Error {
-  constructor(projectId: string) {
-    super(`Checkout intent unresolved: project ${projectId} not found`);
+  constructor(target: {kind: 'project' | 'connection'; value: string}) {
+    super(`Checkout intent unresolved: ${target.kind} ${target.value} not found`);
     this.name = 'CheckoutIntentUnresolvedError';
   }
 }
 
+export class CheckoutConfigInvalidError extends Error {
+  constructor(readonly stepId: string) {
+    super(`Checkout config is invalid for step ${stepId}`);
+    this.name = 'CheckoutConfigInvalidError';
+  }
+}
+
 export class StepNotFoundError extends Error {
   constructor(stepId: string, jobId: string) {
     super(`Step ${stepId} not found in job ${jobId}`);
@@ -207,7 +221,7 @@ export class StepNotRunningError extends Error {
 
 // A report whose attempt is ahead of the step's current attempt. The host
 // allocates attempt numbers, so a runner can never report one it was not
-// dispatched — this is a protocol error, not an idempotent no-op.
+// dispatched: this is a protocol error, not an idempotent no-op.
 export class StepAttemptAheadError extends Error {
   constructor(
     readonly stepId: string,

package/src/core/job-execution.ts

@@ -15,6 +15,7 @@ import {
   getLatestJobExecutionByJobId,
   getStepAttemptsByJobExecutionId,
   getStepsByJobExecutionIdForUpdate,
+  getWorkflowContextForJob,
   insertRunningStepAttempt,
   markStepRunning,
   markStepSkipped,
@@ -91,6 +92,7 @@ interface ResolvePendingStepParams {
   readonly jobExecution: JobExecution;
   readonly attempts: Awaited<ReturnType<typeof getStepAttemptsByJobExecutionId>>;
   readonly jobs: Awaited<ReturnType<typeof getDirectDependencyJobContexts>>;
+  readonly vars: Record<string, string> | undefined;
   readonly tx: Tx;
   readonly agent?: AgentInterModuleClient | undefined;
 }
@@ -130,8 +132,18 @@ async function nextStepForJobExecutionInTransaction(
 
   const attempts = await getStepAttemptsByJobExecutionId(jobExecutionId, tx);
   const jobs = await getDirectDependencyJobContexts(jobExecution.jobId, tx);
+  const workflowContext = await getWorkflowContextForJob(jobExecution.jobId, tx);
 
-  return resolveNextPendingStep({jobExecutionId, steps, jobExecution, attempts, jobs, tx, agent});
+  return resolveNextPendingStep({
+    jobExecutionId,
+    steps,
+    jobExecution,
+    attempts,
+    jobs,
+    vars: workflowContext.vars ?? undefined,
+    tx,
+    agent,
+  });
 }
 
 async function resolveNextPendingStep({
@@ -140,6 +152,7 @@ async function resolveNextPendingStep({
   jobExecution,
   attempts,
   jobs,
+  vars,
   tx,
   agent,
 }: ResolvePendingStepParams): Promise<NextStep> {
@@ -167,6 +180,7 @@ async function resolveNextPendingStep({
       targetStepId: pending.id,
       jobExecution,
       jobs,
+      vars,
     });
     const condition = evaluateStepCondition({step: pending, context});
     if (condition.kind === 'run') {
@@ -454,11 +468,17 @@ async function recordStepResultInTransaction(
     };
   }
 
-  // Evaluate the gate (if any) at the service boundary — the only place the CEL
-  // engine runs — and pass the precomputed outcome into the pure decision.
+  // Evaluate the gate (if any) at the service boundary. This is the only place
+  // the CEL engine runs. Pass the precomputed outcome into the pure decision.
   const shouldEvaluateGate = outputCoercion.kind !== 'failed';
   const gate = shouldEvaluateGate ? readStepGate(target.config) : undefined;
-  const gateOutcome = shouldEvaluateGate ? evaluateGate(gate, result) : {kind: 'no-gate' as const};
+  const vars =
+    gate === undefined
+      ? undefined
+      : ((await getWorkflowContextForJob(jobExecution.jobId, tx)).vars ?? undefined);
+  const gateOutcome = shouldEvaluateGate
+    ? evaluateGate(gate, result, vars)
+    : {kind: 'no-gate' as const};
   const hasRestartPolicy = gate?.onFailure?.restartFrom !== undefined;
   // The restart cap is bounded on the gating step's OWN attempts, not its
   // current_attempt (which a rewind inflates for downstream steps).
@@ -479,6 +499,7 @@ async function recordStepResultInTransaction(
     gate,
     result,
     definitionId: jobExecution.jobId,
+    vars,
   });
 
   return applyStepTransition(
@@ -548,6 +569,7 @@ function resolveRestartFeedback(params: {
   gate: ReturnType<typeof readStepGate>;
   result: ReportedStepResult;
   definitionId: string;
+  vars?: Record<string, string> | undefined;
 }): StepTransitionDecision {
   if (params.decision.kind !== 'restart-job-from-step') return params.decision;
   if (params.gate === undefined) return params.decision;
@@ -559,6 +581,7 @@ function resolveRestartFeedback(params: {
         gate: params.gate,
         result: params.result,
         definitionId: params.definitionId,
+        vars: params.vars,
       }),
     };
   } catch (error) {

package/src/core/job-transition/decide-job-activation.test.ts

@@ -113,10 +113,13 @@ function expression(source: string) {
 function workflowRun(): WorkflowRun {
   return {
     id: crypto.randomUUID(),
+    number: 1,
     workspaceId: crypto.randomUUID(),
     projectId: crypto.randomUUID(),
     definitionId: crypto.randomUUID(),
     name: 'Run',
+    workflowName: 'Run',
+    nameOverride: null,
     status: 'pending',
     currentAttempt: 1,
     triggerProvider: null,
@@ -179,6 +182,7 @@ export function jobExecution(params: Partial<JobExecution> = {}): JobExecution {
     id: crypto.randomUUID(),
     jobId: params.jobId ?? crypto.randomUUID(),
     sequence: params.sequence ?? 1,
+    nameOverride: params.nameOverride ?? params.name ?? 'build',
     name: params.name ?? 'build',
     runner: null,
     status: params.status ?? 'succeeded',

package/src/core/job-transition/decide-job-activation.ts

@@ -34,6 +34,7 @@ export interface DecideJobActivationInput {
   job: Job;
   condition?: WorkflowExpression | undefined;
   dependencies: readonly JobContextInput[];
+  vars?: Record<string, string> | undefined;
 }
 
 export function decideJobActivation(input: DecideJobActivationInput): JobActivationDecision {
@@ -52,6 +53,7 @@ export function decideJobActivation(input: DecideJobActivationInput): JobActivat
     run: input.run,
     triggerPayload: input.run.triggerPayload,
     inputs: input.run.inputs,
+    vars: input.vars,
     jobs: input.dependencies,
   });
   const outcome = evaluatePlannedPredicateAtSite({

package/src/core/job-transition/derive-job-success.test.ts

@@ -52,6 +52,17 @@ describe('deriveJobSuccess', () => {
     expect(result).toMatchObject({status: 'succeeded', statusReason: null});
   });
 
+  test('resolves vars from the run-creation snapshot', () => {
+    const result = deriveJobSuccess({
+      success: 'vars.RELEASE == "yes"',
+      executions: [jobExecution({status: 'succeeded'})],
+      jobs: [],
+      vars: {RELEASE: 'yes'},
+    });
+
+    expect(result).toMatchObject({status: 'succeeded', statusReason: null});
+  });
+
   test('fails closed when the success expression throws at runtime', () => {
     const result = deriveJobSuccess({
       success: 'executions.all(e, 1 / 0 == 0)',
@@ -116,6 +127,7 @@ function jobExecution(params: Partial<JobExecution> = {}): JobExecution {
     id: crypto.randomUUID(),
     jobId: params.jobId ?? crypto.randomUUID(),
     sequence: params.sequence ?? 1,
+    nameOverride: params.nameOverride ?? params.name ?? 'build',
     name: params.name ?? 'build',
     runner: null,
     status: params.status ?? 'succeeded',

package/src/core/job-transition/derive-job-success.ts

@@ -9,8 +9,7 @@ import type {JobStatusReason} from '../entities/job.js';
 import type {JobExecution} from '../entities/job-execution.js';
 import type {PersistedEvaluationTraceEntry} from '../entities/step.js';
 import {
-  assembleExecutionsContext,
-  assembleJobsContext,
+  assembleJobResolutionContext,
   type JobContextInput,
 } from '../step-config/assemble-run-context.js';
 import type {RuntimeCompletionStatus} from '../workflow-scheduling/runtime-dag.js';
@@ -25,27 +24,25 @@ export function deriveJobSuccess(params: {
   success: string | null;
   executions: readonly JobExecution[];
   jobs: readonly JobContextInput[];
+  vars?: Record<string, string> | undefined;
 }): DeriveJobSuccessResult {
   const expression = createWorkflowExpression({
     source: params.success ?? DEFAULT_JOB_SUCCESS,
     check: {mode: 'syntax'},
   });
-  const context = {
-    ...assembleExecutionsContext(params.executions),
-    ...assembleJobsContext(params.jobs),
-  };
+  const context = assembleJobResolutionContext(params);
   const outcome = evaluatePlannedPredicateAtSite({
     expression,
     field: 'job.success',
-    site: 'job-resolution',
-    context,
+    site: context.site,
+    context: context.values,
   });
   const trace = capTraceEntries([
     {
       ...predicateTraceEntry({
         expression: expression.source,
         route: outcome.route,
-        site: 'job-resolution',
+        site: context.site,
         value: outcome.value,
         degraded: outcome.evaluationFailed,
       }),

package/src/core/listener-execution-materialization.test.ts

@@ -21,7 +21,9 @@ describe('materializeListenerExecution', () => {
       model,
       run: {
         id: crypto.randomUUID(),
+        number: 1,
         name: 'Review run',
+        workflowName: 'Review run',
         definitionId: crypto.randomUUID(),
         projectId: crypto.randomUUID(),
         workspaceId: crypto.randomUUID(),