@strav/durable 0.4.27

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# @strav/durable
+
+## 0.4.26
+
+Initial release — durable, crash-resumable workflow execution.
+
+- `durable(name)` builder mirroring the `@strav/workflow` authoring API
+  (`.step` / `.parallel` / `.route` / `.loop` + `compensate`), plus durable-only
+  step types `.sleep`, `.waitForSignal`, and `.childWorkflow`.
+- Explicit-journal execution model (DBOS/Inngest style, no determinism sandbox):
+  every step is checkpointed to `_strav_workflow_journal`; `UNIQUE (run_id, step_id)`
+  makes redelivery idempotent.
+- Queue-driven progression — one top-level step = one `durable:advance`
+  `@strav/queue` job; the journal write + run-row update + next-job enqueue
+  commit in a single transaction, so the engine inherits crash-safety from the
+  queue. A workflow killed mid-execution resumes from the first incomplete step.
+- Suspend/resume: `waitForSignal` parks a run for an unbounded time holding no
+  process; `Durable.resume()` delivers the signal.
+- Durable timers via `.sleep` (survives process restarts).
+- Independently durable, parent-linked child workflows.
+- Journaled saga compensation — rollback is itself crash-safe.
+- Composes with `@strav/brain` — a step returning a `SuspendedRun` suspends the
+  run; resume re-enters the step (duck-typed, no `@strav/brain` dependency).
+- `WorkflowRun` — a `stateful()` ORM model over the run record, with a
+  `@strav/machine` run-status lifecycle.
+- `Durable.start` / `resume` / `status` / `list` / `cancel` / `recover`.

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@strav/durable",
+  "version": "0.4.27",
+  "type": "module",
+  "description": "Durable, crash-resumable workflow execution for the Strav framework",
+  "license": "MIT",
+  "keywords": [
+    "bun",
+    "framework",
+    "typescript",
+    "strav",
+    "durable",
+    "workflow",
+    "orchestration"
+  ],
+  "exports": {
+    ".": "./src/index.ts",
+    "./engine": "./src/engine/index.ts",
+    "./engine/*": "./src/engine/*.ts",
+    "./models": "./src/models/index.ts",
+    "./models/*": "./src/models/*.ts",
+    "./providers": "./src/providers/index.ts",
+    "./providers/*": "./src/providers/*.ts",
+    "./*": "./src/*.ts"
+  },
+  "files": [
+    "src/",
+    "package.json",
+    "tsconfig.json",
+    "CHANGELOG.md"
+  ],
+  "peerDependencies": {
+    "@strav/kernel": "0.4.27",
+    "@strav/database": "0.4.27"
+  },
+  "dependencies": {
+    "@strav/queue": "0.4.27",
+    "@strav/machine": "0.4.27",
+    "@strav/workflow": "0.4.27",
+    "luxon": "^3.7.2"
+  },
+  "devDependencies": {
+    "@types/luxon": "^3.7.1"
+  },
+  "scripts": {
+    "test": "bun test tests/",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/builder.ts

@@ -0,0 +1,158 @@
+import { DurableError } from './errors.ts'
+import type {
+  DurableStep,
+  DurableStepHandler,
+  DurableLoopHandler,
+  DurableRouteResolver,
+  DurableParallelEntry,
+  DurableStepOptions,
+  DurableLoopOptions,
+} from './types.ts'
+
+const DEFAULT_MAX_RETRIES = 3
+
+/**
+ * Durable workflow builder.
+ *
+ * Mirrors the `@strav/workflow` authoring API (`.step` / `.parallel` /
+ * `.route` / `.loop` + `compensate`) so plain workflow code is copy-paste
+ * portable, and adds durable-only step types: `.sleep`, `.waitForSignal`,
+ * and `.childWorkflow`.
+ *
+ * Built workflows are flat ordered step lists — there is no re-runnable
+ * function body, so durability needs no determinism sandbox.
+ *
+ * @example
+ * durable('milestone')
+ *   .step('discover', async (ctx) => discover(ctx.input))
+ *   .parallel('build', [
+ *     { name: 'api', handler: async (ctx) => buildApi(ctx) },
+ *     { name: 'ui',  handler: async (ctx) => buildUi(ctx) },
+ *   ])
+ *   .waitForSignal('signoff', 'founder-signoff')
+ *   .step('ship', async (ctx) => ship(ctx))
+ */
+export class DurableWorkflow {
+  readonly name: string
+  private readonly _steps: DurableStep[] = []
+  private readonly _names = new Set<string>()
+
+  constructor(name: string) {
+    this.name = name
+  }
+
+  /** The ordered, immutable step list. */
+  get steps(): readonly DurableStep[] {
+    return this._steps
+  }
+
+  private claim(name: string): void {
+    if (this._names.has(name)) {
+      throw new DurableError(
+        `Duplicate step name "${name}" in durable workflow "${this.name}".`
+      )
+    }
+    this._names.add(name)
+  }
+
+  /** Add a sequential step. Its result is stored in `ctx.results[name]`. */
+  step(name: string, handler: DurableStepHandler, options?: DurableStepOptions): this {
+    this.claim(name)
+    this._steps.push({
+      type: 'step',
+      name,
+      handler,
+      compensate: options?.compensate,
+      maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,
+      retryBackoff: options?.retryBackoff ?? 'exponential',
+    })
+    return this
+  }
+
+  /** Run multiple handlers in parallel; each result is stored under its entry name. */
+  parallel(
+    name: string,
+    entries: DurableParallelEntry[],
+    options?: Pick<DurableStepOptions, 'maxRetries' | 'retryBackoff'>
+  ): this {
+    this.claim(name)
+    if (entries.length === 0) {
+      throw new DurableError(`Parallel step "${name}" must have at least one entry.`)
+    }
+    this._steps.push({
+      type: 'parallel',
+      name,
+      entries,
+      maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,
+      retryBackoff: options?.retryBackoff ?? 'exponential',
+    })
+    return this
+  }
+
+  /** Route to a branch based on a resolver's return value. */
+  route(
+    name: string,
+    resolver: DurableRouteResolver,
+    branches: Record<string, DurableStepHandler>,
+    options?: Pick<DurableStepOptions, 'maxRetries' | 'retryBackoff'>
+  ): this {
+    this.claim(name)
+    this._steps.push({
+      type: 'route',
+      name,
+      resolver,
+      branches,
+      maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,
+      retryBackoff: options?.retryBackoff ?? 'exponential',
+    })
+    return this
+  }
+
+  /** Run a handler in a loop until a condition is met or max iterations reached. */
+  loop(name: string, handler: DurableLoopHandler, options: DurableLoopOptions): this {
+    this.claim(name)
+    this._steps.push({
+      type: 'loop',
+      name,
+      handler,
+      maxIterations: options.maxIterations,
+      until: options.until,
+      feedback: options.feedback,
+      mapInput: options.mapInput,
+      maxRetries: options.maxRetries ?? DEFAULT_MAX_RETRIES,
+      retryBackoff: options.retryBackoff ?? 'exponential',
+    })
+    return this
+  }
+
+  /** Durable timer — suspend the run and resume after `duration` (ms or a Date). */
+  sleep(name: string, duration: number | Date): this {
+    this.claim(name)
+    this._steps.push({ type: 'sleep', name, duration })
+    return this
+  }
+
+  /**
+   * Suspend the run until `Durable.resume(runId, signal, data)` is called.
+   * Holds no process while suspended — resumes exactly, even days later.
+   */
+  waitForSignal(name: string, signal: string, options?: { timeout?: number }): this {
+    this.claim(name)
+    this._steps.push({ type: 'signal', name, signal, timeout: options?.timeout })
+    return this
+  }
+
+  /**
+   * Spawn an independently durable child workflow and wait for it to finish.
+   * The child result is stored in `ctx.results[name]`.
+   */
+  childWorkflow(
+    name: string,
+    childName: string,
+    mapInput?: (ctx: import('./types.ts').DurableContext) => Record<string, unknown>
+  ): this {
+    this.claim(name)
+    this._steps.push({ type: 'child', name, childName, mapInput })
+    return this
+  }
+}

package/src/config.ts

@@ -0,0 +1,36 @@
+/** Engine-wide configuration for `@strav/durable`. */
+export interface DurableConfig {
+  /**
+   * The `@strav/queue` queue name durable jobs are dispatched on. Run a
+   * `Worker({ queue })` on this name to process durable workflows. Keeping
+   * it separate from app jobs lets durable work be scaled independently.
+   */
+  queue: string
+  /**
+   * Per-job timeout (ms) for `durable:advance` / `durable:compensate` jobs.
+   * Must comfortably exceed the slowest single step (e.g. an LLM call).
+   */
+  jobTimeout: number
+  /**
+   * Queue-level max attempts for durable jobs. This insures against *process
+   * crashes* only — application-level step retries are handled by the engine
+   * via the journal `attempt` count, independently of this.
+   */
+  maxAttempts: number
+}
+
+const config: DurableConfig = {
+  queue: 'durable',
+  jobTimeout: 600_000,
+  maxAttempts: 5,
+}
+
+/** Read the current durable engine configuration. */
+export function getConfig(): DurableConfig {
+  return config
+}
+
+/** Override durable engine configuration. Call before booting workers. */
+export function configureDurable(patch: Partial<DurableConfig>): void {
+  Object.assign(config, patch)
+}

package/src/durable.ts

@@ -0,0 +1,268 @@
+import { sql, transaction } from '@strav/database'
+import { Queue } from '@strav/queue'
+import { registry } from './registry.ts'
+import { ensureTables } from './schema.ts'
+import { configureDurable, type DurableConfig } from './config.ts'
+import { RunNotFoundError } from './errors.ts'
+import type {
+  ResumeResult,
+  RunStatus,
+  RunStatusSnapshot,
+  StartResult,
+} from './types.ts'
+import { writeJournal } from './models/journal.ts'
+import {
+  advanceHandler,
+  applyPatch,
+  compensateHandler,
+  enqueueAdvance,
+  enqueueCompensate,
+  loadRun,
+  lockRun,
+  type AdvancePayload,
+  type CompensatePayload,
+  type Tx,
+} from './engine/index.ts'
+
+/** Drop engine-internal keys so `results` reads like a `@strav/workflow` context. */
+function publicResults(state: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(state)) {
+    if (!key.startsWith('__strav_')) out[key] = value
+  }
+  return out
+}
+
+async function cancelRecursive(trx: Tx, runId: number): Promise<void> {
+  await trx`
+    UPDATE "_strav_workflow_runs"
+    SET "status" = 'canceled', "updated_at" = NOW()
+    WHERE "id" = ${runId}
+      AND "status" IN ('pending', 'running', 'suspended', 'compensating')
+  `
+  const children = (await trx`
+    SELECT "id" FROM "_strav_workflow_runs" WHERE "parent_run_id" = ${runId}
+  `) as Record<string, unknown>[]
+  for (const child of children) {
+    await cancelRecursive(trx, Number(child.id))
+  }
+}
+
+/**
+ * Static facade for the durable execution engine.
+ *
+ * @example
+ * await Durable.start('milestone', { projectId: 42 })
+ * const snapshot = await Durable.status(runId)
+ * await Durable.resume(runId, 'founder-signoff', { approved: true })
+ */
+export class Durable {
+  /** Create the engine's tables (`_strav_workflow_runs`, `_strav_workflow_journal`). */
+  static async ensureTables(): Promise<void> {
+    await ensureTables()
+  }
+
+  /** Override engine configuration (queue name, job timeout, max attempts). */
+  static configure(patch: Partial<DurableConfig>): void {
+    configureDurable(patch)
+  }
+
+  /**
+   * Register the `durable:advance` / `durable:compensate` queue handlers.
+   * Called by `DurableProvider.boot`; idempotent.
+   */
+  static registerHandlers(): void {
+    Queue.handle('durable:advance', async (payload: unknown) => {
+      await advanceHandler(payload as AdvancePayload)
+    })
+    Queue.handle('durable:compensate', async (payload: unknown) => {
+      await compensateHandler(payload as CompensatePayload)
+    })
+  }
+
+  /**
+   * Start a new durable run. Inserts the run row and enqueues the first
+   * step's `durable:advance` job in a single transaction. Returns immediately
+   * — the workflow runs on the queue.
+   */
+  static async start(
+    workflowName: string,
+    input: Record<string, unknown> = {},
+    opts?: { parentRunId?: number; parentStepId?: string }
+  ): Promise<StartResult> {
+    registry.get(workflowName) // throws if not registered
+
+    return await transaction(async (trx: Tx) => {
+      const rows = (await trx`
+        INSERT INTO "_strav_workflow_runs"
+          ("workflow_name", "input", "status", "state", "current_step",
+           "parent_run_id", "parent_step_id")
+        VALUES (
+          ${workflowName}, ${JSON.stringify(input)}, 'running', '{}', 0,
+          ${opts?.parentRunId ?? null}, ${opts?.parentStepId ?? null}
+        )
+        RETURNING "id"
+      `) as Record<string, unknown>[]
+      const runId = Number(rows[0]!.id)
+      await enqueueAdvance(trx, runId, 0)
+      return { runId, status: 'running' as RunStatus }
+    })
+  }
+
+  /**
+   * Deliver a signal to a suspended run.
+   *
+   * - `waitForSignal` step → journals the payload, advances past the step.
+   * - A suspended brain-agent `.step` → stores the payload and re-enters the
+   *   step so the handler can call `runner.resume(...)`.
+   *
+   * Returns `{ accepted: false }` if the run is not suspended on a matching
+   * signal (idempotent — a duplicate or mismatched signal is a no-op).
+   */
+  static async resume(
+    runId: number,
+    signal: string,
+    data?: unknown
+  ): Promise<ResumeResult> {
+    return await transaction(async (trx: Tx) => {
+      const run = await lockRun(trx, runId)
+      if (!run) throw new RunNotFoundError(runId)
+      if (run.status !== 'suspended' || run.awaitingSignal !== signal) {
+        return { accepted: false, status: run.status }
+      }
+
+      const step = registry.get(run.workflowName).steps[run.currentStep]
+      if (!step) return { accepted: false, status: run.status }
+
+      if (step.type === 'signal') {
+        await writeJournal(trx, runId, [
+          { stepId: step.name, status: 'completed', result: data ?? null, attempt: 1 },
+        ])
+        const newState = applyPatch(run.state, { [step.name]: data ?? null })
+        const next = run.currentStep + 1
+        await trx`
+          UPDATE "_strav_workflow_runs"
+          SET "status" = 'running', "awaiting_signal" = NULL,
+              "state" = ${JSON.stringify(newState)}, "current_step" = ${next},
+              "updated_at" = NOW()
+          WHERE "id" = ${runId}
+        `
+        await enqueueAdvance(trx, runId, next)
+        return { accepted: true, status: 'running' as RunStatus }
+      }
+
+      if (step.type === 'step') {
+        // A suspended brain agent — re-enter the same step with the resume data.
+        const newState = applyPatch(run.state, { __strav_resume__: data ?? null })
+        await trx`
+          UPDATE "_strav_workflow_runs"
+          SET "status" = 'running', "awaiting_signal" = NULL,
+              "state" = ${JSON.stringify(newState)}, "updated_at" = NOW()
+          WHERE "id" = ${runId}
+        `
+        await enqueueAdvance(trx, runId, run.currentStep)
+        return { accepted: true, status: 'running' as RunStatus }
+      }
+
+      return { accepted: false, status: run.status }
+    })
+  }
+
+  /** Snapshot a run's live state (and one level of child runs). */
+  static async status(runId: number): Promise<RunStatusSnapshot> {
+    const run = await loadRun(runId)
+    if (!run) throw new RunNotFoundError(runId)
+
+    const totalSteps = registry.has(run.workflowName)
+      ? registry.get(run.workflowName).steps.length
+      : 0
+
+    const childRows = (await sql`
+      SELECT "id" FROM "_strav_workflow_runs"
+      WHERE "parent_run_id" = ${runId} ORDER BY "id"
+    `) as Record<string, unknown>[]
+    const children: RunStatusSnapshot[] = []
+    for (const child of childRows) {
+      children.push(await Durable.status(Number(child.id)))
+    }
+
+    return {
+      runId: run.id,
+      workflowName: run.workflowName,
+      status: run.status,
+      currentStep: run.currentStep,
+      totalSteps,
+      awaitingSignal: run.awaitingSignal,
+      wakeAt: run.wakeAt ? run.wakeAt.toISOString() : null,
+      results: publicResults(run.state),
+      error: run.error,
+      parentRunId: run.parentRunId,
+      children,
+    }
+  }
+
+  /** List runs, most recent first, optionally filtered by status / parent. */
+  static async list(filter?: {
+    status?: RunStatus
+    parentRunId?: number
+  }): Promise<RunStatusSnapshot[]> {
+    const status = filter?.status ?? null
+    const parentRunId = filter?.parentRunId ?? null
+    const rows = (await sql`
+      SELECT "id" FROM "_strav_workflow_runs"
+      WHERE (${status}::text IS NULL OR "status" = ${status})
+        AND (${parentRunId}::bigint IS NULL OR "parent_run_id" = ${parentRunId})
+      ORDER BY "id" DESC
+    `) as Record<string, unknown>[]
+
+    const snapshots: RunStatusSnapshot[] = []
+    for (const row of rows) {
+      snapshots.push(await Durable.status(Number(row.id)))
+    }
+    return snapshots
+  }
+
+  /** Cancel a run and all of its descendant child runs. */
+  static async cancel(runId: number): Promise<void> {
+    await transaction(async (trx: Tx) => {
+      await cancelRecursive(trx, runId)
+    })
+  }
+
+  /**
+   * Re-enqueue runs that are `running` / `compensating` but have no live
+   * `_strav_jobs` row — e.g. a job that dead-lettered. Returns the count
+   * recovered. Safe to run periodically (e.g. via the `@strav/queue` Scheduler).
+   */
+  static async recover(): Promise<number> {
+    const rows = (await sql`
+      SELECT r."id", r."status", r."current_step", r."compensation_cursor"
+      FROM "_strav_workflow_runs" r
+      WHERE r."status" IN ('running', 'compensating')
+        AND NOT EXISTS (
+          SELECT 1 FROM "_strav_jobs" j
+          WHERE j."job" IN ('durable:advance', 'durable:compensate')
+            AND (j."payload"->>'runId')::bigint = r."id"
+        )
+    `) as Record<string, unknown>[]
+
+    let recovered = 0
+    for (const row of rows) {
+      const runId = Number(row.id)
+      await transaction(async (trx: Tx) => {
+        if (row.status === 'running') {
+          await enqueueAdvance(trx, runId, Number(row.current_step))
+        } else if (row.compensation_cursor != null) {
+          await enqueueCompensate(trx, runId, Number(row.compensation_cursor))
+        }
+      })
+      recovered++
+    }
+    return recovered
+  }
+
+  /** Clear the workflow registry. For testing only. */
+  static reset(): void {
+    registry.reset()
+  }
+}

package/src/engine/advance_handler.ts

@@ -0,0 +1,154 @@
+import { transaction } from '@strav/database'
+import { registry } from '../registry.ts'
+import { loadJournal, writeJournal } from '../models/journal.ts'
+import { buildContext } from './context.ts'
+import { enqueueAdvance } from './enqueue.ts'
+import { applyPatch, beginCompensation, completeRun } from './finalize.ts'
+import { loadRun, lockRun, type Tx } from './run_store.ts'
+import { runDurableStep, type StepOutcome } from './step_driver.ts'
+
+/** Payload of a `durable:advance` job. */
+export interface AdvancePayload {
+  runId: number
+  stepIndex: number
+  attempt?: number
+}
+
+/**
+ * The `durable:advance` queue handler — runs one top-level step of a run.
+ *
+ * Phase A (no lock): load the run, guard against stale redelivery, execute the
+ * step. The step handler may take minutes — no row lock is held during it.
+ * Phase B (`applyOutcome`, row-locked transaction): apply the outcome —
+ * journal, advance/suspend/retry/compensate, enqueue the continuation — atomically.
+ */
+export async function advanceHandler(payload: AdvancePayload): Promise<void> {
+  const { runId, stepIndex } = payload
+  const attempt = payload.attempt ?? 1
+
+  const run = await loadRun(runId)
+  if (!run) return
+  // Only a `running` run advances; `suspended`/terminal/`compensating` runs
+  // are handled by resume / the compensation chain / not at all.
+  if (run.status !== 'running') return
+  // Stale redelivery — the run already moved past this step.
+  if (run.currentStep !== stepIndex) return
+
+  const workflow = registry.get(run.workflowName)
+  const steps = workflow.steps
+
+  // Past the last step — the run is done.
+  if (stepIndex >= steps.length) {
+    await completeRun(runId)
+    return
+  }
+
+  const step = steps[stepIndex]!
+  const journal = await loadJournal(runId)
+  const ctx = buildContext(run, attempt, step.name)
+  const outcome = await runDurableStep(step, ctx, journal)
+  await applyOutcome(runId, stepIndex, outcome)
+}
+
+/** Phase B — apply a step outcome atomically under a `FOR UPDATE` lock. */
+async function applyOutcome(
+  runId: number,
+  stepIndex: number,
+  outcome: StepOutcome
+): Promise<void> {
+  await transaction(async (trx: Tx) => {
+    const run = await lockRun(trx, runId)
+    // Re-check under the lock: a resume / cancel / concurrent duplicate may
+    // have moved the run since Phase A.
+    if (!run || run.status !== 'running' || run.currentStep !== stepIndex) return
+
+    switch (outcome.kind) {
+      case 'advance': {
+        await writeJournal(trx, runId, outcome.journal)
+        const newState = applyPatch(run.state, outcome.resultPatch)
+        delete newState['__strav_resume__']
+        const next = stepIndex + 1
+        await trx`
+          UPDATE "_strav_workflow_runs"
+          SET "state" = ${JSON.stringify(newState)}, "current_step" = ${next},
+              "updated_at" = NOW()
+          WHERE "id" = ${runId}
+        `
+        await enqueueAdvance(trx, runId, next)
+        break
+      }
+
+      case 'sleep': {
+        await writeJournal(trx, runId, outcome.journal)
+        const newState = applyPatch(run.state, outcome.resultPatch)
+        const next = stepIndex + 1
+        const delay = Math.max(0, outcome.wakeAt.getTime() - Date.now())
+        await trx`
+          UPDATE "_strav_workflow_runs"
+          SET "state" = ${JSON.stringify(newState)}, "current_step" = ${next},
+              "wake_at" = ${outcome.wakeAt}, "updated_at" = NOW()
+          WHERE "id" = ${runId}
+        `
+        await enqueueAdvance(trx, runId, next, { delay })
+        break
+      }
+
+      case 'suspend-signal': {
+        await trx`
+          UPDATE "_strav_workflow_runs"
+          SET "status" = 'suspended', "awaiting_signal" = ${outcome.signal},
+              "updated_at" = NOW()
+          WHERE "id" = ${runId}
+        `
+        break
+      }
+
+      case 'suspend-agent': {
+        const newState = applyPatch(run.state, { [outcome.stepName]: outcome.snapshot })
+        await trx`
+          UPDATE "_strav_workflow_runs"
+          SET "status" = 'suspended', "awaiting_signal" = ${outcome.stepName},
+              "state" = ${JSON.stringify(newState)}, "updated_at" = NOW()
+          WHERE "id" = ${runId}
+        `
+        break
+      }
+
+      case 'await-child': {
+        const childRows = (await trx`
+          INSERT INTO "_strav_workflow_runs"
+            ("workflow_name", "input", "status", "state", "current_step",
+             "parent_run_id", "parent_step_id")
+          VALUES (
+            ${outcome.childName}, ${JSON.stringify(outcome.childInput)},
+            'running', '{}', 0, ${runId}, ${outcome.childStepId}
+          )
+          RETURNING "id"
+        `) as Record<string, unknown>[]
+        const childId = Number(childRows[0]!.id)
+        await enqueueAdvance(trx, childId, 0)
+        await trx`
+          UPDATE "_strav_workflow_runs"
+          SET "status" = 'suspended', "updated_at" = NOW()
+          WHERE "id" = ${runId}
+        `
+        break
+      }
+
+      case 'retry': {
+        await writeJournal(trx, runId, outcome.journal)
+        await enqueueAdvance(trx, runId, stepIndex, {
+          attempt: outcome.attempt,
+          delay: outcome.backoffMs,
+        })
+        break
+      }
+
+      case 'compensate': {
+        await writeJournal(trx, runId, outcome.journal)
+        await beginCompensation(trx, run, stepIndex, outcome.failure)
+        break
+      }
+    }
+  })
+}