@shipfox/api-workflows 12.1.0 → 12.3.0

package/src/db/workflow-runs/steps.test.ts

@@ -11,7 +11,10 @@ import {stepAttempts as stepAttemptsTable} from '../schema/step-attempts.js';
 import {steps as stepsTable} from '../schema/steps.js';
 import {
   createWorkflowRun,
+  getFirstJobExecutionByJobId,
+  getJobExecutionFailureOrigin,
   getJobsByWorkflowRunId,
+  getStepAttemptDetail,
   getStepAttempts,
   getStepsByJobId,
 } from '../workflow-runs.js';
@@ -60,6 +63,150 @@ describe('workflow run queries', () => {
     });
   });
 
+  describe('getStepAttemptDetail', () => {
+    test('joins a step attempt to its run for lazy troubleshooting reads', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({jobs: {build: {steps: [{run: 'echo hello'}]}}}),
+        triggerPayload: {
+          source: 'manual',
+          event: 'fire',
+          subscriptionId: crypto.randomUUID(),
+          userId: crypto.randomUUID(),
+        },
+      });
+      const [job] = await getJobsByWorkflowRunId(run.id);
+      if (!job) throw new Error('Expected a workflow job');
+      await stripSetupStep(job.id);
+      await nextStepForJob(job.id);
+
+      const [attempt] = await getStepAttempts(job.id);
+      if (!attempt) throw new Error('Expected a dispatched step attempt');
+
+      const detail = await getStepAttemptDetail({stepId: attempt.stepId, attempt: attempt.attempt});
+
+      expect(detail).toMatchObject({
+        workflowRunId: run.id,
+        workflowRunAttemptId: job.workflowRunAttemptId,
+        step: {id: attempt.stepId},
+        attempt: {id: attempt.id, attempt: attempt.attempt},
+      });
+    });
+  });
+
+  describe('getJobExecutionFailureOrigin', () => {
+    test('selects the current failed attempt instead of loading attempt history', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({
+          jobs: {build: {steps: [{run: 'echo hello'}, {run: 'echo goodbye'}]}},
+        }),
+        triggerPayload: {
+          source: 'manual',
+          event: 'fire',
+          subscriptionId: crypto.randomUUID(),
+          userId: crypto.randomUUID(),
+        },
+      });
+      const [job] = await getJobsByWorkflowRunId(run.id);
+      if (!job) throw new Error('Expected a workflow job');
+      await stripSetupStep(job.id);
+      const execution = await getFirstJobExecutionByJobId(job.id);
+      if (!execution) throw new Error('Expected a job execution');
+      await nextStepForJob(job.id);
+
+      const [step] = await getStepsByJobId(job.id);
+      const [attempt] = await getStepAttempts(job.id);
+      if (!step || !attempt) throw new Error('Expected a current step attempt');
+      await db()
+        .update(stepsTable)
+        .set({status: 'failed', error: {reason: 'command_failed', message: 'current failure'}})
+        .where(eq(stepsTable.id, step.id));
+      await db()
+        .update(stepAttemptsTable)
+        .set({
+          status: 'failed',
+          error: {reason: 'command_failed', message: 'current failure'},
+          finishedAt: new Date(),
+        })
+        .where(eq(stepAttemptsTable.id, attempt.id));
+
+      await expect(getJobExecutionFailureOrigin(execution.id)).resolves.toMatchObject({
+        jobExecutionId: execution.id,
+        stepId: step.id,
+        stepAttempt: attempt.attempt,
+        attemptStatus: 'failed',
+        attemptError: {message: 'current failure'},
+      });
+    });
+
+    test('returns the first step when the execution fails before any attempt starts', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({jobs: {build: {steps: [{run: 'echo hello'}]}}}),
+        triggerPayload: {
+          source: 'manual',
+          event: 'fire',
+          subscriptionId: crypto.randomUUID(),
+          userId: crypto.randomUUID(),
+        },
+      });
+      const [job] = await getJobsByWorkflowRunId(run.id);
+      if (!job) throw new Error('Expected a workflow job');
+      const execution = await getFirstJobExecutionByJobId(job.id);
+      if (!execution) throw new Error('Expected a job execution');
+
+      await expect(getJobExecutionFailureOrigin(execution.id)).resolves.toMatchObject({
+        jobExecutionId: execution.id,
+        stepAttempt: 1,
+        attemptStatus: null,
+      });
+    });
+
+    test('selects a condition-errored step before an earlier pending step', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({
+          jobs: {build: {steps: [{run: 'echo first'}, {run: 'echo second'}]}},
+        }),
+        triggerPayload: {
+          source: 'manual',
+          event: 'fire',
+          subscriptionId: crypto.randomUUID(),
+          userId: crypto.randomUUID(),
+        },
+      });
+      const [job] = await getJobsByWorkflowRunId(run.id);
+      if (!job) throw new Error('Expected a workflow job');
+      await stripSetupStep(job.id);
+      const execution = await getFirstJobExecutionByJobId(job.id);
+      if (!execution) throw new Error('Expected a job execution');
+
+      const steps = await getStepsByJobId(job.id);
+      const firstStep = steps[0];
+      const conditionErroredStep = steps[1];
+      if (!firstStep || !conditionErroredStep) throw new Error('Expected two workflow steps');
+      await db()
+        .update(stepsTable)
+        .set({status: 'skipped', statusReason: 'condition_errored'})
+        .where(eq(stepsTable.id, conditionErroredStep.id));
+
+      await expect(getJobExecutionFailureOrigin(execution.id)).resolves.toMatchObject({
+        stepId: conditionErroredStep.id,
+        stepStatus: 'skipped',
+      });
+      expect(firstStep.position).toBeLessThan(conditionErroredStep.position);
+    });
+  });
+
   describe('bulkUpdateStepStatuses', () => {
     test('updates all steps for a job to the given sweep status', async () => {
       const run = await createWorkflowRun({
@@ -183,6 +330,7 @@ describe('workflow run queries', () => {
           projectId,
           stepId: attempt?.stepId,
           attempt: 1,
+          status: 'cancelled',
           logOutcome: 'abandoned',
         },
       ]);

package/src/db/workflow-runs/steps.ts

@@ -1,5 +1,5 @@
 import type {LogOutcomeDto} from '@shipfox/api-workflows-dto';
-import {and, asc, count, eq, gte, inArray, sql} from 'drizzle-orm';
+import {and, asc, count, desc, eq, gte, inArray, sql} from 'drizzle-orm';
 import type {
   PersistedEvaluationTraceEntry,
   Step,
@@ -11,8 +11,11 @@ import type {
 import {deriveCompletion, isTerminal} from '#core/step-transition/decide-step-transition.js';
 import {db, type Tx} from '../db.js';
 import {jobExecutions} from '../schema/job-executions.js';
+import {jobs} from '../schema/jobs.js';
 import {stepAttempts, toStepAttempt} from '../schema/step-attempts.js';
 import {steps, toStep} from '../schema/steps.js';
+import {workflowRunAttempts} from '../schema/workflow-run-attempts.js';
+import {workflowRuns} from '../schema/workflow-runs.js';
 import {writeJobStepsSettledOutbox, writeStepAttemptTerminatedOutbox} from './outbox.js';
 import {NON_TERMINAL_STEP_STATUS_FILTER} from './shared.js';
 
@@ -39,6 +42,105 @@ export async function getStepById(stepId: string): Promise<Step | undefined> {
   return toStep(row);
 }
 
+export interface StepAttemptDetail {
+  workflowRunId: string;
+  workflowRunAttemptId: string;
+  step: Step;
+  attempt: StepAttempt;
+}
+
+export interface JobExecutionFailureOrigin {
+  jobExecutionId: string;
+  stepId: string;
+  stepName: string;
+  stepStatus: StepStatus;
+  stepAttempt: number;
+  stepError: Record<string, unknown> | null;
+  attemptStatus: StepAttemptStatus | null;
+  attemptError: Record<string, unknown> | null;
+  attemptExitCode: number | null;
+}
+
+/**
+ * Read only the current attempt for the most relevant step. The terminal job event identifies
+ * the execution, so this intentionally avoids hydrating the execution's complete attempt
+ * history. If no attempt was dispatched, the first step still gives the projection a stable
+ * troubleshooting origin for failures that happened before step work started.
+ */
+export async function getJobExecutionFailureOrigin(
+  jobExecutionId: string,
+): Promise<JobExecutionFailureOrigin | undefined> {
+  const rows = await db()
+    .select({
+      jobExecutionId: jobExecutions.id,
+      stepId: steps.id,
+      stepName: steps.name,
+      stepStatus: steps.status,
+      stepAttempt: steps.currentAttempt,
+      stepError: steps.error,
+      attemptStatus: stepAttempts.status,
+      attemptError: stepAttempts.error,
+      attemptExitCode: stepAttempts.exitCode,
+    })
+    .from(jobExecutions)
+    .innerJoin(steps, eq(steps.jobExecutionId, jobExecutions.id))
+    .leftJoin(
+      stepAttempts,
+      and(eq(stepAttempts.stepId, steps.id), eq(stepAttempts.attempt, steps.currentAttempt)),
+    )
+    .where(eq(jobExecutions.id, jobExecutionId))
+    .orderBy(
+      desc(
+        sql<number>`case when ${steps.status} = 'failed' or ${stepAttempts.status} = 'failed' or ${steps.statusReason} = 'condition_errored' then 1 else 0 end`,
+      ),
+      asc(steps.position),
+      asc(steps.id),
+    )
+    .limit(1);
+
+  const row = rows[0];
+  if (!row) return undefined;
+
+  return {
+    ...row,
+    stepError: (row.stepError as Record<string, unknown> | null) ?? null,
+    attemptError: (row.attemptError as Record<string, unknown> | null) ?? null,
+    attemptStatus: row.attemptStatus === null ? null : (row.attemptStatus as StepAttemptStatus),
+    attemptExitCode: row.attemptExitCode ?? null,
+  };
+}
+
+export async function getStepAttemptDetail(params: {
+  stepId: string;
+  attempt: number;
+}): Promise<StepAttemptDetail | undefined> {
+  const rows = await db()
+    .select({
+      workflowRunId: workflowRuns.id,
+      workflowRunAttemptId: workflowRunAttempts.id,
+      step: steps,
+      stepAttempt: stepAttempts,
+    })
+    .from(stepAttempts)
+    .innerJoin(steps, eq(stepAttempts.stepId, steps.id))
+    .innerJoin(jobExecutions, eq(steps.jobExecutionId, jobExecutions.id))
+    .innerJoin(jobs, eq(jobExecutions.jobId, jobs.id))
+    .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
+    .innerJoin(workflowRuns, eq(workflowRunAttempts.workflowRunId, workflowRuns.id))
+    .where(and(eq(stepAttempts.stepId, params.stepId), eq(stepAttempts.attempt, params.attempt)))
+    .limit(1);
+
+  const row = rows[0];
+  if (!row) return undefined;
+
+  return {
+    workflowRunId: row.workflowRunId,
+    workflowRunAttemptId: row.workflowRunAttemptId,
+    step: toStep(row.step),
+    attempt: toStepAttempt(row.stepAttempt),
+  };
+}
+
 export async function getStepsByJobId(jobId: string): Promise<Step[]> {
   const rows = await db()
     .select({step: steps})
@@ -105,6 +207,7 @@ export async function bulkUpdateStepStatuses(
       await writeStepAttemptTerminatedOutbox(tx, {
         stepId: attempt.stepId,
         attempt: attempt.attempt,
+        status: params.status,
         logOutcome: attempt.logOutcome ?? 'abandoned',
       });
     }
@@ -367,6 +470,7 @@ export async function finishStepAttempt(params: FinishStepAttemptParams, tx: Tx)
   await writeStepAttemptTerminatedOutbox(tx, {
     stepId: row.stepId,
     attempt: row.attempt,
+    status: params.status,
     logOutcome: row.logOutcome ?? params.logOutcome,
   });
 }

package/src/db/workflow-runs.ts

@@ -90,9 +90,11 @@ export type {
   DispatchStepWithCompletedConfigParams,
   FinishStepAttemptParams,
   InsertRunningStepAttemptParams,
+  JobExecutionFailureOrigin,
   MarkStepRunningParams,
   MarkStepSkippedParams,
   RewindStepsToPendingParams,
+  StepAttemptDetail,
 } from './workflow-runs/steps.js';
 export {
   applyStepResult,
@@ -101,6 +103,8 @@ export {
   countStepAttempts,
   dispatchStepWithCompletedConfig,
   finishStepAttempt,
+  getJobExecutionFailureOrigin,
+  getStepAttemptDetail,
   getStepAttempts,
   getStepAttemptsByJobExecutionId,
   getStepAttemptsByJobIds,

package/src/index.ts

@@ -17,6 +17,8 @@ import type {SecretsInterModuleClient} from '@shipfox/api-secrets-dto/inter-modu
 import {
   WORKFLOWS_JOB_EVENT_DELIVERED,
   WORKFLOWS_JOB_STEPS_SETTLED,
+  WORKFLOWS_JOB_TERMINATED,
+  WORKFLOWS_STEP_ATTEMPT_TERMINATED,
   WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED,
   WORKFLOWS_WORKFLOW_RUN_CANCELLED,
   type WorkflowsEventMapDto,
@@ -30,9 +32,11 @@ import {
   createWorkflowRoutes,
   onJobEventDelivered,
   onJobStepsSettled,
+  onJobTerminatedFailureAnnotation,
   onRunnerJobClaimed,
   onRunnerJobLeaseExpired,
   onRunnerJobQueued,
+  onStepAttemptTerminatedFailureAnnotation,
   onWorkflowRunAttemptCreated,
   onWorkflowRunCancelled,
 } from '#presentation/index.js';
@@ -118,6 +122,11 @@ export function createWorkflowsModule({
       subscriber(WORKFLOWS_WORKFLOW_RUN_CANCELLED, onWorkflowRunCancelled),
       subscriber(WORKFLOWS_JOB_EVENT_DELIVERED, onJobEventDelivered),
       subscriber(WORKFLOWS_JOB_STEPS_SETTLED, onJobStepsSettled),
+      subscriber(
+        WORKFLOWS_STEP_ATTEMPT_TERMINATED,
+        onStepAttemptTerminatedFailureAnnotation(annotations),
+      ),
+      subscriber(WORKFLOWS_JOB_TERMINATED, onJobTerminatedFailureAnnotation(annotations)),
       subscriber(RUNNER_JOB_LEASE_EXPIRED, onRunnerJobLeaseExpired),
       subscriber(RUNNER_JOB_QUEUED, onRunnerJobQueued),
       subscriber(RUNNER_JOB_CLAIMED, onRunnerJobClaimed),

package/src/metrics/instance.ts

@@ -91,6 +91,12 @@ const agentToolWarningFailedCount = meter.createCounter<{
   description: 'Agent tool capability warning failures by bounded reason',
 });
 
+const failureAnnotationFailedCount = meter.createCounter<{
+  reason: 'lookup' | 'budget' | 'write';
+}>('workflows_failure_annotation_failed', {
+  description: 'Failure annotation projection failures by bounded reason',
+});
+
 const listenerEventsCoalesced = meter.createHistogram<Record<string, never>>(
   'workflows_listener_events_coalesced',
   {
@@ -172,3 +178,7 @@ export function recordListenerEventsCoalesced(batchSize: number): void {
 export function recordWorkflowAgentToolWarningFailed(reason: 'budget' | 'lookup' | 'write'): void {
   agentToolWarningFailedCount.add(1, {reason});
 }
+
+export function recordWorkflowFailureAnnotationFailed(reason: 'lookup' | 'budget' | 'write'): void {
+  failureAnnotationFailedCount.add(1, {reason});
+}

package/src/presentation/dto/evaluation-trace.ts

@@ -0,0 +1,27 @@
+import type {EvaluationTraceDto, EvaluationTraceEntryDto} from '@shipfox/api-workflows-dto';
+import type {PersistedEvaluationTraceEntry} from '#core/entities/step.js';
+
+export function toEvaluationTraceDto(
+  trace: readonly PersistedEvaluationTraceEntry[] | null | undefined,
+): EvaluationTraceDto | null {
+  if (trace === null || trace === undefined) return null;
+  return trace.map(toEvaluationTraceEntryDto);
+}
+
+function toEvaluationTraceEntryDto(entry: PersistedEvaluationTraceEntry): EvaluationTraceEntryDto {
+  if ('dropped' in entry) return {truncated: true, dropped: entry.dropped};
+
+  return {
+    expression: entry.expression,
+    roots: [...entry.roots],
+    fill_target: entry.fillTarget,
+    evaluated_at: entry.evaluatedAt,
+    field: entry.field,
+    ...(entry.value === undefined ? {} : {value: entry.value}),
+    ...(entry.truncated === undefined ? {} : {truncated: entry.truncated}),
+    ...(entry.exprTruncated === undefined ? {} : {expr_truncated: entry.exprTruncated}),
+    ...(entry.reference === undefined ? {} : {reference: entry.reference}),
+    ...(entry.degraded === undefined ? {} : {degraded: entry.degraded}),
+    ...(entry.envKey === undefined ? {} : {env_key: entry.envKey}),
+  };
+}

package/src/presentation/dto/index.ts

@@ -1,3 +1,4 @@
+export {toEvaluationTraceDto} from './evaluation-trace.js';
 export {toJobDto, toJobExecutionDto} from './job.js';
-export {toStepAttemptDto, toStepDto} from './step.js';
+export {toStepAttemptDetailResponseDto, toStepAttemptDto, toStepDto} from './step.js';
 export {toRunAttemptDto, toRunDto, toRunListItemDto} from './workflow-run.js';

package/src/presentation/dto/job.ts

@@ -1,6 +1,7 @@
 import type {JobDto, JobExecutionDto} from '@shipfox/api-workflows-dto';
 import type {Job} from '#core/entities/job.js';
 import type {JobExecution} from '#core/entities/job-execution.js';
+import {toEvaluationTraceDto} from './evaluation-trace.js';
 
 export function toJobDto(job: Job): JobDto {
   return {
@@ -12,6 +13,9 @@ export function toJobDto(job: Job): JobDto {
     status: job.status,
     status_reason: job.statusReason,
     carried_over: job.carriedOver,
+    success: job.success ?? null,
+    runner: job.runner,
+    evaluation_trace: toEvaluationTraceDto(job.evaluationTrace),
     listening:
       job.listeningOn === null
         ? null
@@ -52,8 +56,10 @@ export function toJobExecutionDto(jobExecution: JobExecution): JobExecutionDto {
     name: jobExecution.name,
     status: jobExecution.status,
     status_reason: jobExecution.statusReason,
+    runner: jobExecution.runner,
     trigger_events: jobExecution.triggerEvents,
     outputs: jobExecution.outputs,
+    evaluation_trace: toEvaluationTraceDto(jobExecution.evaluationTrace),
     queued_at: jobExecution.queuedAt?.toISOString() ?? null,
     started_at: jobExecution.startedAt?.toISOString() ?? null,
     finished_at: jobExecution.finishedAt?.toISOString() ?? null,

package/src/presentation/dto/step.test.ts

@@ -1,5 +1,10 @@
 import type {Step, StepAttempt} from '#core/entities/step.js';
-import {fromStepErrorDto, toStepAttemptDto, toStepDto} from './step.js';
+import {
+  fromStepErrorDto,
+  toStepAttemptDetailResponseDto,
+  toStepAttemptDto,
+  toStepDto,
+} from './step.js';
 
 function step(overrides: Partial<Step> & {type: string}): Step {
   return {
@@ -102,6 +107,37 @@ describe('fromStepErrorDto', () => {
 });
 
 describe('toStepDto error category', () => {
+  it('surfaces status reasons and evaluation traces', () => {
+    const dto = toStepDto(
+      step({
+        type: 'run',
+        statusReason: 'condition_errored',
+        evaluationTrace: [
+          {
+            expression: 'inputs.environment',
+            roots: ['inputs.environment'],
+            fillTarget: 'step-dispatch',
+            evaluatedAt: 'step-dispatch',
+            field: 'condition',
+            value: 'production',
+          },
+        ],
+      }),
+    );
+
+    expect(dto.status_reason).toBe('condition_errored');
+    expect(dto.evaluation_trace).toEqual([
+      {
+        expression: 'inputs.environment',
+        roots: ['inputs.environment'],
+        fill_target: 'step-dispatch',
+        evaluated_at: 'step-dispatch',
+        field: 'condition',
+        value: 'production',
+      },
+    ]);
+  });
+
   it("derives category 'setup' for a setup step error and surfaces the reason", () => {
     const dto = toStepDto(
       step({type: 'setup', error: {message: 'mkdir denied', reason: 'workspace_prep_failed'}}),
@@ -222,6 +258,24 @@ const baseAttempt: StepAttempt = {
 };
 
 describe('toStepAttemptDto', () => {
+  it('keeps evaluation traces on the lazy detail response instead of run polling', () => {
+    const result = toStepAttemptDto({
+      ...baseAttempt,
+      evaluationTrace: [
+        {
+          expression: 'inputs.message',
+          roots: ['inputs.message'],
+          fillTarget: 'step-dispatch',
+          evaluatedAt: 'step-dispatch',
+          field: 'run',
+          value: 'hello',
+        },
+      ],
+    });
+
+    expect(result).not.toHaveProperty('evaluation_trace');
+  });
+
   it('maps passed gate payloads to typed gate results', () => {
     const attempt: StepAttempt = {
       ...baseAttempt,
@@ -337,3 +391,44 @@ describe('toStepAttemptDto', () => {
     });
   });
 });
+
+describe('toStepAttemptDetailResponseDto', () => {
+  it('returns authored config, resolved config, and attempt trace', () => {
+    const stepData = step({
+      type: 'run',
+      authoredConfig: {run: 'echo $' + '{{ inputs.message }}'},
+      config: {run: 'echo hello'},
+    });
+    const attempt: StepAttempt = {
+      ...baseAttempt,
+      config: {run: 'echo hello'},
+      evaluationTrace: [
+        {
+          expression: 'inputs.message',
+          roots: ['inputs.message'],
+          fillTarget: 'step-dispatch',
+          evaluatedAt: 'step-dispatch',
+          field: 'run',
+          value: 'hello',
+        },
+      ],
+    };
+
+    expect(toStepAttemptDetailResponseDto(stepData, attempt)).toEqual({
+      step_id: stepData.id,
+      attempt: 1,
+      authored_config: {run: 'echo $' + '{{ inputs.message }}'},
+      config: {run: 'echo hello'},
+      evaluation_trace: [
+        {
+          expression: 'inputs.message',
+          roots: ['inputs.message'],
+          fill_target: 'step-dispatch',
+          evaluated_at: 'step-dispatch',
+          field: 'run',
+          value: 'hello',
+        },
+      ],
+    });
+  });
+});

package/src/presentation/dto/step.ts

@@ -1,5 +1,6 @@
 import {
   agentConfigIssueSchema,
+  type StepAttemptDetailResponseDto,
   type StepAttemptDto,
   type StepDto,
   type StepErrorCategoryDto,
@@ -9,6 +10,7 @@ import {
 } from '@shipfox/api-workflows-dto';
 import type {Step, StepAttempt} from '#core/entities/step.js';
 import {GATE_EVALUATION_ERROR_REASON} from '#core/step-transition/evaluate-gate.js';
+import {toEvaluationTraceDto} from './evaluation-trace.js';
 
 // Domain `error` is loosely typed (jsonb), so narrow it to the fixed runner
 // contract rather than trusting whatever shape the row happens to hold. `category`
@@ -105,8 +107,10 @@ export function toStepDto(step: Step): StepDto {
     name: step.name,
     source_location: toStepSourceLocationDto(step.sourceLocation),
     status: step.status,
+    status_reason: step.statusReason,
     type: step.type,
     config: step.config,
+    evaluation_trace: toEvaluationTraceDto(step.evaluationTrace),
     error: toStepErrorDto(
       step.error,
       step.type === 'setup' || step.type === 'checkout' ? 'setup' : 'user',
@@ -146,3 +150,16 @@ export function toStepAttemptDto(attempt: StepAttempt): StepAttemptDto {
     finished_at: attempt.finishedAt ? attempt.finishedAt.toISOString() : null,
   };
 }
+
+export function toStepAttemptDetailResponseDto(
+  step: Step,
+  attempt: StepAttempt,
+): StepAttemptDetailResponseDto {
+  return {
+    step_id: step.id,
+    attempt: attempt.attempt,
+    authored_config: step.authoredConfig,
+    config: attempt.config,
+    evaluation_trace: toEvaluationTraceDto(attempt.evaluationTrace),
+  };
+}

package/src/presentation/index.ts

@@ -2,9 +2,11 @@ export {createWorkflowRoutes} from './routes/index.js';
 export {
   onJobEventDelivered,
   onJobStepsSettled,
+  onJobTerminatedFailureAnnotation,
   onRunnerJobClaimed,
   onRunnerJobLeaseExpired,
   onRunnerJobQueued,
+  onStepAttemptTerminatedFailureAnnotation,
   onWorkflowRunAttemptCreated,
   onWorkflowRunCancelled,
 } from './subscribers/index.js';