@shipfox/api-workflows 11.0.0 → 12.1.0

package/src/core/step-config/resolve-step-config.ts

@@ -1,4 +1,5 @@
 import type {WorkflowEnvTemplates, WorkflowModel} from '@shipfox/api-definitions-dto';
+import {WORKFLOW_MODEL_CHECKOUT_TARGET_FIELDS} from '@shipfox/api-definitions-dto';
 import {
   type AvailabilitySite,
   capTraceEntries,
@@ -14,6 +15,7 @@ import type {StepConfigDispatchPlan} from '#core/entities/step.js';
 import {resolveAgentStepConfig} from './agent.js';
 import {
   freezeStepField,
+  resolveStepField,
   type StepConfigField,
   type WorkflowStepEvaluationTraceEntry,
   type WorkflowStepTemplateDiagnostic,
@@ -25,6 +27,7 @@ type WorkflowModelJob = WorkflowModel['jobs'][number];
 type WorkflowModelStep = WorkflowModelJob['steps'][number];
 type WorkflowModelRunStep = Extract<WorkflowModelStep, {kind: 'run'}>;
 type WorkflowModelAgentStep = Extract<WorkflowModelStep, {kind: 'agent'}>;
+type WorkflowModelCheckoutStep = Extract<WorkflowModelStep, {kind: 'checkout'}>;
 
 export type {StepConfigField, WorkflowStepTemplateDiagnostic};
 
@@ -62,6 +65,22 @@ interface BuiltStepConfig {
   readonly hasTemplates: boolean;
 }
 
+interface WorkingDirectoryConfig {
+  readonly config: Record<string, unknown>;
+  readonly configPlan: Pick<StepConfigDispatchPlan, 'working_directory'> | undefined;
+  readonly diagnostics: readonly WorkflowStepTemplateDiagnostic[];
+  readonly trace: readonly WorkflowStepEvaluationTraceEntry[];
+  readonly hasTemplates: boolean;
+}
+
+interface CheckoutConfig {
+  readonly config: Record<string, unknown>;
+  readonly configPlan: Pick<StepConfigDispatchPlan, 'checkout'> | undefined;
+  readonly diagnostics: readonly WorkflowStepTemplateDiagnostic[];
+  readonly trace: readonly WorkflowStepEvaluationTraceEntry[];
+  readonly hasTemplates: boolean;
+}
+
 export async function resolveStepConfig(
   params: ResolveStepConfigParams,
 ): Promise<ResolvedStepConfig> {
@@ -87,17 +106,34 @@ async function buildStepConfig(
 ): Promise<BuiltStepConfig> {
   const gate = gateConfigForStep(params.step);
   const outputs = outputsConfigForStep(params.step);
+  const workingDirectory = resolveWorkingDirectoryConfig(params);
   const runStep = runStepOrNull(params.step);
   const isRunStep = runStep !== null;
 
   if (isRunStep) {
     const run = resolveRunStepConfig({...params, step: runStep});
     return {
-      config: {...run.config, ...gate, ...outputs},
-      configPlan: run.configPlan,
-      diagnostics: run.diagnostics,
-      trace: run.trace,
-      hasTemplates: run.hasTemplates,
+      config: {...workingDirectory.config, ...run.config, ...gate, ...outputs},
+      configPlan: mergeConfigPlans(run.configPlan, workingDirectory.configPlan),
+      diagnostics: [...workingDirectory.diagnostics, ...run.diagnostics],
+      trace: [...workingDirectory.trace, ...run.trace],
+      hasTemplates: run.hasTemplates || workingDirectory.hasTemplates,
+    };
+  }
+
+  const checkoutStep = checkoutStepOrNull(params.step);
+  if (checkoutStep !== null) {
+    const checkout = resolveCheckoutStepConfig({...params, step: checkoutStep});
+    return {
+      config: {
+        ...checkout.config,
+        ...gate,
+        ...outputs,
+      },
+      configPlan: checkout.configPlan === undefined ? null : checkout.configPlan,
+      diagnostics: checkout.diagnostics,
+      trace: checkout.trace,
+      hasTemplates: checkout.hasTemplates,
     };
   }
 
@@ -106,14 +142,81 @@ async function buildStepConfig(
 
   const agent = await resolveAgentStepConfig({...params, step: agentStep});
   return {
-    config: {...agent.config, ...gate, ...outputs},
-    configPlan: agent.configPlan,
-    diagnostics: agent.diagnostics,
-    trace: agent.trace,
-    hasTemplates: agent.hasTemplates,
+    config: {...workingDirectory.config, ...agent.config, ...gate, ...outputs},
+    configPlan: mergeConfigPlans(agent.configPlan, workingDirectory.configPlan),
+    diagnostics: [...workingDirectory.diagnostics, ...agent.diagnostics],
+    trace: [...workingDirectory.trace, ...agent.trace],
+    hasTemplates: agent.hasTemplates || workingDirectory.hasTemplates,
+  };
+}
+
+function resolveWorkingDirectoryConfig(
+  params: Omit<BuildStepConfigParams, 'context'> & {readonly context: WorkflowEvaluationContext},
+): WorkingDirectoryConfig {
+  const value = params.step.workingDirectory;
+  const template = params.step.templates?.workingDirectory;
+  if (value === undefined) {
+    return {
+      config: {},
+      configPlan: undefined,
+      diagnostics: [],
+      trace: [],
+      hasTemplates: template !== undefined,
+    };
+  }
+
+  if (template === undefined || params.mode === 'authored') {
+    return {
+      config: {working_directory: value},
+      configPlan: undefined,
+      diagnostics: [],
+      trace: [],
+      hasTemplates: template !== undefined,
+    };
+  }
+
+  const resolved = resolveStepField({
+    field: 'step.working_directory',
+    template: {segments: template},
+    context: params.context,
+    definitionId: params.definitionId,
+    errorField: 'step.working_directory',
+  });
+  const trace = resolved.trace.map((entry) => ({
+    ...entry,
+    field: 'step.working_directory' as const,
+  }));
+  const diagnostics = resolved.diagnostics.map((diagnostic) => ({
+    ...diagnostic,
+    field: 'step.working_directory' as const,
+  }));
+  if (resolved.kind === 'residual') {
+    return {
+      config: {},
+      configPlan: {working_directory: resolved.field},
+      diagnostics,
+      trace,
+      hasTemplates: true,
+    };
+  }
+
+  return {
+    config: {working_directory: resolved.value},
+    configPlan: undefined,
+    diagnostics,
+    trace,
+    hasTemplates: true,
   };
 }
 
+function mergeConfigPlans(
+  primary: StepConfigDispatchPlan | null,
+  secondary: Pick<StepConfigDispatchPlan, 'working_directory'> | undefined,
+): StepConfigDispatchPlan | null {
+  if (secondary === undefined) return primary;
+  return {...(primary ?? {}), ...secondary};
+}
+
 function evaluationContext(params: {
   readonly context: WorkflowExpressionEvaluationContext;
   readonly site: AvailabilitySite;
@@ -131,6 +234,68 @@ function agentStepOrNull(step: WorkflowModelStep): WorkflowModelAgentStep | null
   return isAgentStep ? step : null;
 }
 
+function checkoutStepOrNull(step: WorkflowModelStep): WorkflowModelCheckoutStep | null {
+  const isCheckoutStep = step.kind === 'checkout';
+  return isCheckoutStep ? step : null;
+}
+
+function resolveCheckoutStepConfig(
+  params: Omit<BuildStepConfigParams, 'context' | 'step'> & {
+    readonly context: WorkflowEvaluationContext;
+    readonly step: WorkflowModelCheckoutStep;
+  },
+): CheckoutConfig {
+  const checkout = params.step.checkout;
+  const config: Record<string, unknown> = {
+    fetch_depth: checkout.fetchDepth,
+    permissions: checkout.permissions,
+    persist_credentials: checkout.persistCredentials,
+    ...(checkout.force === undefined ? {} : {force: checkout.force}),
+  };
+  const checkoutConfig: Record<string, unknown> = config;
+  const checkoutPlan: NonNullable<StepConfigDispatchPlan['checkout']> = {};
+  const diagnostics: WorkflowStepTemplateDiagnostic[] = [];
+  const trace: WorkflowStepEvaluationTraceEntry[] = [];
+  let hasTemplates = false;
+
+  for (const [key, field] of WORKFLOW_MODEL_CHECKOUT_TARGET_FIELDS) {
+    const template = checkout.templates?.[key];
+    if (template !== undefined) hasTemplates = true;
+
+    const value = checkout[key];
+    if (value === undefined) continue;
+
+    if (template === undefined || params.mode === 'authored') {
+      checkoutConfig[key] = value;
+      continue;
+    }
+
+    const resolved = resolveStepField({
+      field,
+      template: {segments: template},
+      context: params.context,
+      definitionId: params.definitionId,
+      errorField: field,
+    });
+    trace.push(...resolved.trace.map((entry) => ({...entry, field})));
+    diagnostics.push(...resolved.diagnostics.map((diagnostic) => ({...diagnostic, field})));
+
+    if (resolved.kind === 'residual') {
+      checkoutPlan[key] = resolved.field;
+    } else {
+      checkoutConfig[key] = resolved.value;
+    }
+  }
+
+  return {
+    config: {checkout: config},
+    configPlan: Object.keys(checkoutPlan).length === 0 ? undefined : {checkout: checkoutPlan},
+    diagnostics,
+    trace,
+    hasTemplates,
+  };
+}
+
 function gateConfigForStep(step: WorkflowModelStep): Record<string, unknown> {
   const hasGate = step.gate !== undefined;
   return hasGate ? {gate: stepGateConfig(step.gate)} : {};

package/src/core/step-config/resolve-workflow-run-name.test.ts

@@ -0,0 +1,115 @@
+import {workflowModel} from '#test/index.js';
+import {resolveWorkflowRunName, sanitizeWorkflowDisplayText} from './resolve-workflow-run-name.js';
+
+function template(source: string): string {
+  return `\${{ ${source} }}`;
+}
+
+describe('resolveWorkflowRunName', () => {
+  it('leaves an omitted run name unset', () => {
+    expect(
+      resolveWorkflowRunName({
+        runName: undefined,
+        context: {},
+      }),
+    ).toEqual({value: null, trace: []});
+  });
+
+  it('resolves a run name from trigger-event context', () => {
+    const model = workflowModel({runName: `Deploy ${template('event.environment')}`});
+
+    const result = resolveWorkflowRunName({
+      runName: model.runName,
+      context: {event: {environment: 'production'}},
+    });
+
+    expect(result).toMatchObject({
+      value: 'Deploy production',
+      trace: [
+        {
+          field: 'workflow.run_name',
+          expression: 'event.environment',
+          evaluatedAt: 'run-creation',
+          value: 'production',
+        },
+      ],
+    });
+    expect(result.degradation).toBeUndefined();
+  });
+
+  it('loads and resolves input values through the same creation context', () => {
+    const model = workflowModel({runName: `Deploy ${template('inputs.environment')}`});
+
+    const result = resolveWorkflowRunName({
+      runName: model.runName,
+      context: {inputs: {environment: 'staging'}},
+    });
+
+    expect(result.value).toBe('Deploy staging');
+  });
+
+  it.each([
+    [{event: {}}, 'missing_value'],
+    [{event: {environment: ''}}, 'empty_value'],
+  ] as const)('falls back without throwing for %s', (context, cause) => {
+    const model = workflowModel({runName: template('event.environment')});
+
+    const result = resolveWorkflowRunName({
+      runName: model.runName,
+      context,
+    });
+
+    expect(result).toMatchObject({value: null, degradation: {cause}});
+  });
+
+  it('sanitizes control and format characters without failing the run', () => {
+    const model = workflowModel({runName: template('event.environment')});
+
+    const result = resolveWorkflowRunName({
+      runName: model.runName,
+      context: {event: {environment: 'prod\u202e\nblue'}},
+    });
+
+    expect(result).toMatchObject({
+      value: 'prod  blue',
+      degradation: {cause: 'sanitization'},
+    });
+  });
+
+  it('degrades when expression evaluation throws', () => {
+    const model = workflowModel({runName: template('1 / 0')});
+
+    const result = resolveWorkflowRunName({
+      runName: model.runName,
+      context: {},
+    });
+
+    expect(result).toMatchObject({
+      value: null,
+      degradation: {cause: 'evaluation_error', expression: '1 / 0'},
+    });
+  });
+
+  it('degrades when sanitization removes the complete resolved value', () => {
+    const model = workflowModel({runName: template('event.environment')});
+
+    const result = resolveWorkflowRunName({
+      runName: model.runName,
+      context: {event: {environment: '\u200b'}},
+    });
+
+    expect(result).toMatchObject({value: null, degradation: {cause: 'sanitization'}});
+  });
+});
+
+describe('sanitizeWorkflowDisplayText', () => {
+  it('trims and bounds display text', () => {
+    expect(sanitizeWorkflowDisplayText(`  ${'a'.repeat(300)}  `)).toBe('a'.repeat(255));
+  });
+
+  it('bounds by Unicode code point without splitting an emoji', () => {
+    const value = `${'a'.repeat(254)}😀`;
+
+    expect(sanitizeWorkflowDisplayText(value)).toBe(value);
+  });
+});

package/src/core/step-config/resolve-workflow-run-name.ts

@@ -0,0 +1,108 @@
+import type {WorkflowModel} from '@shipfox/api-definitions-dto';
+import {
+  capTraceEntries,
+  getWorkflowInterpolationFieldFailurePolicy,
+  type ResolvedFieldSegment,
+  resolveFieldAtSite,
+  type WorkflowExpressionEvaluationContext,
+  WorkflowTemplateResolutionError,
+} from '@shipfox/expression';
+import type {PersistedEvaluationTraceEntry} from '#core/entities/step.js';
+
+const DISALLOWED_DISPLAY_CHARACTER_RE = /[\p{Cc}\p{Cf}]/gu;
+const MAX_WORKFLOW_RUN_NAME_LENGTH = 255;
+
+export type WorkflowRunNameResolutionCause =
+  | 'missing_value'
+  | 'evaluation_error'
+  | 'empty_value'
+  | 'sanitization';
+
+export interface WorkflowRunNameDegradation {
+  readonly cause: WorkflowRunNameResolutionCause;
+  readonly expression?: string | undefined;
+}
+
+export interface ResolveWorkflowRunNameResult {
+  readonly value: string | null;
+  readonly trace: readonly PersistedEvaluationTraceEntry[];
+  readonly degradation?: WorkflowRunNameDegradation | undefined;
+}
+
+export function resolveWorkflowRunName(params: {
+  readonly runName: WorkflowModel['runName'];
+  readonly context: WorkflowExpressionEvaluationContext;
+}): ResolveWorkflowRunNameResult {
+  if (params.runName === undefined) return {value: null, trace: []};
+
+  try {
+    const resolved = resolveFieldAtSite({
+      field: {segments: params.runName},
+      site: 'run-creation',
+      context: params.context,
+      failurePolicy: getWorkflowInterpolationFieldFailurePolicy('workflow.run_name'),
+    });
+    const trace = capTraceEntries(
+      resolved.trace.map((entry) => ({...entry, field: 'workflow.run_name'})),
+    );
+
+    if (resolved.kind !== 'frozen' || resolved.diagnostics.length > 0) {
+      return degraded(trace, {
+        cause: 'missing_value',
+        expression: resolved.diagnostics[0]?.expression ?? firstExpressionSource(params.runName),
+      });
+    }
+
+    if (resolved.value === '') {
+      return degraded(trace, {
+        cause: 'empty_value',
+        expression: firstExpressionSource(params.runName),
+      });
+    }
+
+    const sanitized = sanitizeWorkflowDisplayText(resolved.value);
+    if (sanitized === '') {
+      return degraded(trace, {
+        cause: 'sanitization',
+        expression: firstExpressionSource(params.runName),
+      });
+    }
+
+    return {
+      value: sanitized,
+      trace,
+      ...(sanitized === resolved.value
+        ? {}
+        : {
+            degradation: {
+              cause: 'sanitization' as const,
+              expression: firstExpressionSource(params.runName),
+            },
+          }),
+    };
+  } catch (error) {
+    return degraded([], {
+      cause: 'evaluation_error',
+      expression:
+        error instanceof WorkflowTemplateResolutionError
+          ? error.source
+          : firstExpressionSource(params.runName),
+    });
+  }
+}
+
+export function sanitizeWorkflowDisplayText(value: string): string {
+  const sanitized = value.replace(DISALLOWED_DISPLAY_CHARACTER_RE, ' ').trim();
+  return Array.from(sanitized).slice(0, MAX_WORKFLOW_RUN_NAME_LENGTH).join('');
+}
+
+function degraded(
+  trace: readonly PersistedEvaluationTraceEntry[],
+  degradation: WorkflowRunNameDegradation,
+): ResolveWorkflowRunNameResult {
+  return {value: null, trace, degradation};
+}
+
+function firstExpressionSource(template: readonly ResolvedFieldSegment[]): string | undefined {
+  return template.find((segment) => segment.kind === 'deferred')?.expression.source;
+}

package/src/core/step-transition/decide-step-transition.ts

@@ -27,7 +27,7 @@ export interface StepReport {
 // Precomputed gate evaluation (the CEL engine runs in evaluate-gate.ts, never
 // here). `passed`/`failed` are clean evaluations; `uncheckable` means the gate
 // could not be evaluated (no exit code, or an evaluation error) and is treated
-// as a plain command failure — never a restart.
+// as a plain command failure. It is never a restart.
 export type GateOutcome =
   | {kind: 'no-gate'}
   | {kind: 'passed'; source: string; trace?: readonly PersistedEvaluationTraceEntry[]}
@@ -55,7 +55,7 @@ export interface DecideStepTransitionInput {
   // to DEFAULT_RESTART_ATTEMPT_CAP.
   maxAttempts?: number;
   // The gating step's own execution count (number of its attempts), used for the
-  // cap. Defaults to `reportedAttempt` — correct for a single-gate job, where the
+  // cap. Defaults to `reportedAttempt`: correct for a single-gate job, where the
   // two are equal; the service passes the real count so a downstream gate in a
   // multi-gate job isn't penalized for upstream-induced rewinds.
   gatingAttemptCount?: number;

package/src/core/step-transition/evaluate-gate.test.ts

@@ -144,6 +144,14 @@ describe('evaluateGate', () => {
     expect(evaluateGate(gate, {status: 'failed', exitCode: 0})).toMatchObject({kind: 'failed'});
   });
 
+  test('resolves vars from the run-creation snapshot', () => {
+    const gate = readStepGate(gateConfig('vars.ENABLED == "true"'));
+
+    expect(evaluateGate(gate, {status: 'succeeded', exitCode: 0}, {ENABLED: 'true'})).toMatchObject(
+      {kind: 'passed'},
+    );
+  });
+
   test('step.outputs gates on reported output values', () => {
     const gate = readStepGate(gateConfig('step.outputs.pass == true'));
 

package/src/core/step-transition/evaluate-gate.ts

@@ -69,7 +69,11 @@ export function readStepGate(config: Record<string, unknown>): StepGate | undefi
  * unless evaluation gets a budget outside the lock. The materializer only
  * persists CEL expressions, and this evaluator only needs the validated source.
  */
-export function evaluateGate(gate: StepGate | undefined, result: StepReport): GateOutcome {
+export function evaluateGate(
+  gate: StepGate | undefined,
+  result: StepReport,
+  vars?: Record<string, string> | undefined,
+): GateOutcome {
   if (!gate?.success) return {kind: 'no-gate'};
   const source = gate.success.source;
 
@@ -81,6 +85,7 @@ export function evaluateGate(gate: StepGate | undefined, result: StepReport): Ga
     status: result.status,
     exitCode: result.exitCode,
     output: result.output,
+    vars,
   });
   const outcome = evaluatePlannedPredicateAtSite({
     expression: gate.success,
@@ -110,6 +115,7 @@ export function evaluateGateFeedback(params: {
   readonly gate: StepGate;
   readonly result: StepReport;
   readonly definitionId: string;
+  readonly vars?: Record<string, string> | undefined;
 }): string {
   const feedbackTemplate = params.gate.onFailure?.feedbackTemplate;
   if (feedbackTemplate === undefined) {
@@ -120,6 +126,7 @@ export function evaluateGateFeedback(params: {
     status: params.result.status,
     exitCode: params.result.exitCode ?? null,
     output: params.result.output,
+    vars: params.vars,
   });
   return completeStepField({
     field: 'step.feedback',

package/src/core/workflow-run-creation.test.ts

@@ -19,7 +19,7 @@ describe('deriveInitialJobExecutionPlan', () => {
     const model = buildModel({
       jobs: {
         deploy: {
-          name: `Deploy ${template('inputs.environment')}`,
+          executionName: `Deploy ${template('inputs.environment')}`,
           runner: ['linux'],
           runnerTemplates: [template('inputs.runner')],
           steps: [{run: 'echo deploy'}],
@@ -47,10 +47,10 @@ describe('deriveInitialJobExecutionPlan', () => {
         {
           expression: 'inputs.environment',
           roots: ['inputs'],
-          fillTarget: 'run-creation',
+          fillTarget: 'execution-creation',
           evaluatedAt: 'execution-creation',
           value: 'prod',
-          field: 'job.name',
+          field: 'job.execution_name',
         },
       ],
     });
@@ -86,7 +86,7 @@ describe('deriveInitialJobExecutionPlan', () => {
     const model = buildModel({
       jobs: {
         deploy: {
-          name: `Current ${template('execution.name')}`,
+          executionName: `Current ${template('execution.name')}`,
           steps: [{run: 'echo deploy'}],
         },
       },
@@ -136,10 +136,13 @@ function workflowRun(params: {inputs?: Record<string, unknown> | null} = {}): Wo
   const now = new Date('2026-01-01T00:00:00.000Z');
   return {
     id: 'run-1',
+    number: 1,
     workspaceId: 'workspace-1',
     projectId: 'project-1',
     definitionId: 'definition-1',
     name: 'Test workflow',
+    workflowName: 'Test workflow',
+    nameOverride: null,
     status: 'pending',
     currentAttempt: 1,
     triggerProvider: null,

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

@@ -55,6 +55,7 @@ export function deriveInitialJobExecutionPlan(params: {
   inputs?: Record<string, unknown> | null | undefined;
   vars?: Record<string, string> | undefined;
 }): {
+  nameOverride: string | null;
   name: string;
   runner: readonly string[];
   evaluationTrace: JobExecution['evaluationTrace'];
@@ -64,8 +65,9 @@ export function deriveInitialJobExecutionPlan(params: {
     triggerPayload: params.triggerPayload,
     inputs: params.inputs ?? null,
     vars: params.vars,
-    jobId: params.jobId,
+    job: {id: params.jobId, key: params.job.key, name: params.job.name ?? null},
     sequence: params.sequence,
+    nameOverride: null,
     executionName: params.fallbackName,
     status: 'pending',
     triggerEvents: [],
@@ -73,8 +75,7 @@ export function deriveInitialJobExecutionPlan(params: {
   });
   const resolvedName = resolveJobExecutionName({
     definitionId: params.run.definitionId,
-    job: params.job,
-    fallbackName: params.fallbackName,
+    job: params.modelJob,
     context: nameContext.values,
   });
   const runnerContext = assembleExecutionCreationContext({
@@ -82,15 +83,17 @@ export function deriveInitialJobExecutionPlan(params: {
     triggerPayload: params.triggerPayload,
     inputs: params.inputs ?? null,
     vars: params.vars,
-    jobId: params.jobId,
+    job: {id: params.jobId, key: params.job.key, name: params.job.name ?? null},
     sequence: params.sequence,
-    executionName: resolvedName.value,
+    nameOverride: resolvedName.nameOverride,
+    executionName: resolvedName.nameOverride ?? params.fallbackName,
     status: 'pending',
     triggerEvents: [],
     priorExecutions: [],
   });
   return {
-    name: resolvedName.value,
+    nameOverride: resolvedName.nameOverride,
+    name: resolvedName.nameOverride ?? params.fallbackName,
     runner: materializeJobRunner({
       job: params.modelJob,
       context: runnerContext,
@@ -105,7 +108,9 @@ export function deriveJobExecutionRunner(params: {
   modelJob: WorkflowModel['jobs'][number];
   jobId: string;
   sequence: number;
+  nameOverride: string | null;
   executionName: string;
+  jobName?: string | null | undefined;
   status: JobExecution['status'];
   triggerEvents?: readonly JobExecution['triggerEvents'][number][] | undefined;
   priorExecutions?: readonly JobExecution[] | undefined;
@@ -116,8 +121,9 @@ export function deriveJobExecutionRunner(params: {
       run: params.run,
       triggerPayload: params.run.triggerPayload,
       inputs: params.run.inputs,
-      jobId: params.jobId,
+      job: {id: params.jobId, key: params.modelJob.key, name: params.jobName ?? null},
       sequence: params.sequence,
+      nameOverride: params.nameOverride,
       executionName: params.executionName,
       status: params.status,
       triggerEvents: params.triggerEvents ?? [],

package/src/db/db.ts

@@ -7,11 +7,13 @@ import {workflowsOutbox} from './schema/outbox.js';
 import {stepAttempts} from './schema/step-attempts.js';
 import {steps} from './schema/steps.js';
 import {workflowRunAttempts} from './schema/workflow-run-attempts.js';
+import {workflowRunCounters} from './schema/workflow-run-counters.js';
 import {workflowRuns} from './schema/workflow-runs.js';
 
 export const schema = {
   workflowRuns,
   workflowRunAttempts,
+  workflowRunCounters,
   jobs,
   jobExecutions,
   jobListenerEvents,

package/src/db/index.ts

@@ -23,6 +23,7 @@ export {
   settleListenerJobExecution,
 } from './job-listeners.js';
 export {workflowsOutbox} from './schema/outbox.js';
+export {workflowRunCounters} from './schema/workflow-run-counters.js';
 export type {
   BulkUpdateStepStatusesParams,
   CancelWorkflowRunParams,
@@ -40,6 +41,10 @@ export type {
   WorkflowJobExecutionDepthParams,
   WorkflowRunAggregates,
   WorkflowRunFilters,
+  WorkflowRunJobStatusCount,
+  WorkflowRunJobSummary,
+  WorkflowRunJobSummaryTarget,
+  WorkflowRunJobsSummary,
 } from './workflow-runs.js';
 export {
   bulkUpdateStepStatuses,
@@ -72,6 +77,7 @@ export {
   getWorkflowRunById,
   getWorkflowRunDetail,
   listRunAttempts,
+  listWorkflowRunJobSummaries,
   listWorkflowRuns,
   listWorkflowRunsByProject,
   recordJobExecutionQueuedAt,