@pikku/core 0.12.69 → 0.12.71

package/src/wirings/workflow/pikku-workflow-service.ts

@@ -11,7 +11,6 @@ import {
   pikkuState,
 } from '../../pikku-state.js'
 import { getDurationInMilliseconds } from '../../time-utils.js'
-import { createHttpScenarioActors } from '../../services/http-scenario-actors.js'
 
 const resolveWorkflowMeta = (
   name: string
@@ -46,10 +45,10 @@ const toKebab = (s: string) =>
   s.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase()
 import type { PikkuWire, SerializedError } from '../../types/core.types.js'
 import type { QueueService } from '../queue/queue.types.js'
-import { runScheduledTask } from '../scheduler/scheduler-runner.js'
 import type {
   ApprovalOutcome,
-  PikkuScenarioWire,
+  CoreWorkflow,
+  PikkuWorkflowWire,
   StepState,
   StepStatus,
   WorkflowApprovalOptions,
@@ -63,9 +62,6 @@ import type {
   WorkflowQueueOptions,
   WorkflowServiceConfig,
   WorkflowStepOptions,
-  WorkflowExpectEventuallyOptions,
-  WorkflowExpectErrorOptions,
-  WorkflowExpectServiceOptions,
 } from './workflow.types.js'
 import {
   continueGraph,
@@ -246,16 +242,174 @@ const WORKFLOW_END_STATES: ReadonlySet<string> = new Set([
   'suspended',
 ])
 
+/**
+ * Everything an extension needs to run something of its own around a run's
+ * function: the registration it was resolved from, the run itself (so `input`
+ * is the same object the function is called with), and the wire it is given.
+ */
+export interface RunLifecycleContext {
+  runId: string
+  run: WorkflowRun
+  workflowMeta: any
+  workflow: CoreWorkflow
+  wire: PikkuWire
+  packageName: string | null
+}
+
+/**
+ * The slice of the run engine an extension is allowed to drive, handed to it at
+ * construction. It exists so that recording a durable step stays available to
+ * an extension without `inlineStep` and friends becoming public API on every
+ * workflow service a production app instantiates.
+ */
+export interface WorkflowRunEngine {
+  inlineStep(
+    runId: string,
+    logicalStepName: string,
+    fn: Function,
+    stepOptions?: WorkflowStepOptions,
+    data?: any,
+    funcName?: string
+  ): Promise<any>
+  updateRunStatus(
+    runId: string,
+    status: WorkflowStatus,
+    output?: any,
+    error?: SerializedError
+  ): Promise<void>
+  onChildWorkflowFailed(run: WorkflowRun, error: unknown): Promise<void>
+  verifyStepName(stepName: unknown): void
+}
+
+/**
+ * A capability layered onto a run without being a workflow service itself.
+ *
+ * The engine names nothing about what an extension is for: a bundler drops an
+ * unused *module* but never an unused class member, so the alternative — a
+ * subclass carrying the capability — puts it in every server built on Pikku
+ * whether or not the app ever uses it. Scenarios are the one implementation
+ * today (`PikkuScenarioService` in `@pikku/core/scenario`).
+ */
+export interface WorkflowRunExtension {
+  /** Per-run state resolved once the run has an id. */
+  attachRunContext(
+    runId: string,
+    workflowMeta: any,
+    options?: Record<string, any>
+  ): Promise<void>
+  /** Release whatever `attachRunContext` stored. */
+  detachRunContext(runId: string): void
+  /** Contribute extra members to the wire a run's function is invoked with. */
+  decorateRunWire(
+    wire: PikkuWire,
+    context: {
+      runId: string
+      workflowMeta: any
+      workflowWire: PikkuWorkflowWire
+    }
+  ): void
+  /** Contribute extra members to the workflow wire itself, in place. */
+  decorateWorkflowWire(
+    workflowWire: PikkuWorkflowWire,
+    context: {
+      name: string
+      runId: string
+      rpcService: any
+      addonNamespace?: string | null
+    }
+  ): void
+  /**
+   * Called immediately before the run's function, inside the run lock. Throwing
+   * skips the function and fails the run.
+   */
+  onBeforeRunFunc(context: RunLifecycleContext): Promise<void>
+  /**
+   * Called once the run reaches a terminal state, in a `finally`, so it runs
+   * whether the function passed or threw. `interrupted` means the run suspended
+   * or went async and is still mid-flight. Throwing here propagates, replacing
+   * a pending failure, so an extension that must not mask one handles that
+   * itself.
+   */
+  onAfterRunFunc(
+    context: RunLifecycleContext,
+    outcome: 'completed' | 'failed' | 'interrupted',
+    failure: unknown
+  ): Promise<void>
+}
+
+/**
+ * States a run never leaves. `suspended` is deliberately absent: a suspended
+ * run stops a poll loop but can still be resumed, so anything the process holds
+ * for it has to survive.
+ */
+const WORKFLOW_TERMINAL_STATES: ReadonlySet<string> = new Set([
+  'completed',
+  'failed',
+  'cancelled',
+])
+
+/** First wait when polling a run, before the backoff starts widening it. */
+const WORKFLOW_POLL_MIN_MS = 10
+
+/** How much each successive wait grows, up to the caller's ceiling. */
+const WORKFLOW_POLL_FACTOR = 1.6
+
+/**
+ * Ceiling for the wait on an inline sub-workflow. Lower than a top-level run's
+ * default, because the parent step is blocked on it and every wait here is
+ * added latency in the middle of a workflow rather than at its edge.
+ */
+const WORKFLOW_CHILD_POLL_MAX_MS = 500
+
 /**
  * Abstract workflow state service
  * Implementations provide pluggable storage backends (SQLite, PostgreSQL, etc.)
  * Combines orchestration and step execution
  */
+/**
+ * Everything the engine holds in memory for a run that is executing in this
+ * process. One entry, one lifetime: created when the run starts executing here
+ * and dropped when nothing is holding it open any more.
+ *
+ * The `replay` half is rebuilt from scratch on every orchestrator tick; the
+ * rest outlives individual ticks and belongs to whoever started the run.
+ */
+type RunContext = {
+  /** Executing straight through in-process, without a queue. */
+  inline: boolean
+  replay?: {
+    /** How many times this walk has reached each logical step name. */
+    ordinals: Map<string, number>
+    /** The step key the walk last reached — the next step's predecessor. */
+    lastStep?: string
+    /** Every step of the run as this replay found it, keyed by step name. */
+    steps?: Map<string, StepState>
+    /** The run as this replay found it. Only its immutable half is reused. */
+    run?: WorkflowRun
+  }
+}
+
 export abstract class PikkuWorkflowService implements WorkflowService {
-  private inlineRuns = new Set<string>()
-  // User-flow actors per run: live authenticated clients (cookie jars) are
-  // process-local by nature, so they ride this map, never the persisted wire.
-  private runActors = new Map<string, ScenarioActors>()
+  private runExtension?: WorkflowRunExtension
+
+  private runContexts = new Map<string, RunContext>()
+
+  private contextFor(runId: string): RunContext {
+    let context = this.runContexts.get(runId)
+    if (!context) {
+      context = { inline: false }
+      this.runContexts.set(runId, context)
+    }
+    return context
+  }
+
+  /** Drop a run's context once nothing is holding it open. */
+  private releaseContext(runId: string): void {
+    const context = this.runContexts.get(runId)
+    if (!context) return
+    if (context.inline || context.replay) return
+    this.runContexts.delete(runId)
+  }
 
   protected get logger() {
     return getSingletonServices()?.logger
@@ -283,19 +437,36 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     }
   }
 
-  private async safeMirror(fn: () => Promise<void>): Promise<void> {
-    if (!this.mirror) return
-    try {
-      await fn()
-    } catch (err: any) {
+  /**
+   * Perform a state write, then shadow it to the mirror.
+   *
+   * The mirror is an observability sink, never a second source of truth, and
+   * both halves of that follow from this one shape: it is only ever told about
+   * a write that already landed, and a mirror that is down or throwing cannot
+   * fail — or even be seen by — the workflow it is watching.
+   *
+   * @param write - the authoritative write; its result is what the caller gets
+   * @param mirror - shadows the write, given the live mirror and what was written
+   */
+  private async mirrored<T>(
+    write: () => Promise<T>,
+    mirror: (mirror: WorkflowRunMirror, written: T) => Promise<void>
+  ): Promise<T> {
+    const written = await write()
+    if (this.mirror) {
       try {
-        this.logger?.warn?.(
-          `[pikku] WorkflowRunMirror write failed: ${err?.message ?? err}`
-        )
-      } catch {
-        // logger unavailable (e.g. singleton services not initialized) — swallow
+        await mirror(this.mirror, written)
+      } catch (err: any) {
+        try {
+          this.logger?.warn?.(
+            `[pikku] WorkflowRunMirror write failed: ${err?.message ?? err}`
+          )
+        } catch {
+          // logger unavailable (e.g. singleton services not initialized) — swallow
+        }
       }
     }
+    return written
   }
 
   /**
@@ -431,21 +602,24 @@ export abstract class PikkuWorkflowService implements WorkflowService {
    * Check if a run is executing inline (without queues)
    */
   protected isInline(runId: string): boolean {
-    return this.inlineRuns.has(runId)
+    return this.runContexts.get(runId)?.inline === true
   }
 
   /**
    * Register a run as inline (for graph-runner to use)
    */
   public registerInlineRun(runId: string): void {
-    this.inlineRuns.add(runId)
+    this.contextFor(runId).inline = true
   }
 
   /**
    * Unregister a run from inline tracking
    */
   public unregisterInlineRun(runId: string): void {
-    this.inlineRuns.delete(runId)
+    const context = this.runContexts.get(runId)
+    if (!context) return
+    context.inline = false
+    this.releaseContext(runId)
   }
 
   public async registerWorkflowVersions(): Promise<void> {
@@ -467,26 +641,27 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       plannedSteps?: WorkflowPlannedStep[]
     }
   ): Promise<string> {
-    const runId = await this.createRunImpl(
-      workflowName,
-      input,
-      inline,
-      graphHash,
-      wire,
-      options
-    )
-    await this.safeMirror(() =>
-      this.mirror!.createRun(
-        runId,
-        workflowName,
-        input,
-        inline,
-        graphHash,
-        wire,
-        options
-      )
+    return this.mirrored(
+      () =>
+        this.createRunImpl(
+          workflowName,
+          input,
+          inline,
+          graphHash,
+          wire,
+          options
+        ),
+      (mirror, runId) =>
+        mirror.createRun(
+          runId,
+          workflowName,
+          input,
+          inline,
+          graphHash,
+          wire,
+          options
+        )
     )
-    return runId
   }
 
   protected abstract createRunImpl(
@@ -613,10 +788,17 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     output?: any,
     error?: SerializedError
   ): Promise<void> {
-    await this.updateRunStatusImpl(id, status, output, error)
-    await this.safeMirror(() =>
-      this.mirror!.updateRunStatus(id, status, output, error)
+    await this.mirrored(
+      () => this.updateRunStatusImpl(id, status, output, error),
+      (mirror) => mirror.updateRunStatus(id, status, output, error)
     )
+    if (WORKFLOW_TERMINAL_STATES.has(status)) {
+      // The run is over: release whatever this process opened for it. Queued
+      // runs never pass through the inline path that does this, so their
+      // context was held for the life of the process.
+      this.runExtension?.detachRunContext(id)
+      this.releaseContext(id)
+    }
   }
 
   protected abstract updateRunStatusImpl(
@@ -631,7 +813,10 @@ export abstract class PikkuWorkflowService implements WorkflowService {
    * Creates pending step in both workflow_step and workflow_step_history
    * @param runId - Run ID
    * @param stepName - Step cache key
-   * @param rpcName - RPC function name
+   * @param rpcName - The name this step was dispatched by: an RPC for a
+   *   `workflow.do` step, a step function for a scenario step, null for a
+   *   closure. Nothing dispatches off this value — it is recorded so a reader
+   *   can join a step back to the function that ran it.
    * @param data - Step input data
    * @param stepOptions - Step options (retries, retryDelay)
    * @returns Step state with generated stepId
@@ -644,18 +829,19 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     stepOptions?: WorkflowStepOptions,
     fromStepName?: string
   ): Promise<StepState> {
-    const step = await this.insertStepStateImpl(
-      runId,
-      stepName,
-      rpcName,
-      data,
-      stepOptions,
-      fromStepName
-    )
-    await this.safeMirror(() =>
-      this.mirror!.insertStepState(runId, { ...step, stepName, rpcName, data })
+    return this.mirrored(
+      () =>
+        this.insertStepStateImpl(
+          runId,
+          stepName,
+          rpcName,
+          data,
+          stepOptions,
+          fromStepName
+        ),
+      (mirror, step) =>
+        mirror.insertStepState(runId, { ...step, stepName, rpcName, data })
     )
-    return step
   }
 
   protected abstract insertStepStateImpl(
@@ -681,8 +867,10 @@ export abstract class PikkuWorkflowService implements WorkflowService {
    * @param stepId - Step ID
    */
   public async setStepRunning(stepId: string): Promise<void> {
-    await this.setStepRunningImpl(stepId)
-    await this.safeMirror(() => this.mirror!.setStepRunning(stepId))
+    await this.mirrored(
+      () => this.setStepRunningImpl(stepId),
+      (mirror) => mirror.setStepRunning(stepId)
+    )
   }
 
   protected abstract setStepRunningImpl(stepId: string): Promise<void>
@@ -693,8 +881,10 @@ export abstract class PikkuWorkflowService implements WorkflowService {
    * @param stepId - Step ID
    */
   public async setStepScheduled(stepId: string): Promise<void> {
-    await this.setStepScheduledImpl(stepId)
-    await this.safeMirror(() => this.mirror!.setStepScheduled(stepId))
+    await this.mirrored(
+      () => this.setStepScheduledImpl(stepId),
+      (mirror) => mirror.setStepScheduled(stepId)
+    )
   }
 
   protected abstract setStepScheduledImpl(stepId: string): Promise<void>
@@ -706,8 +896,10 @@ export abstract class PikkuWorkflowService implements WorkflowService {
    * @param result - Step result
    */
   public async setStepResult(stepId: string, result: any): Promise<void> {
-    await this.setStepResultImpl(stepId, result)
-    await this.safeMirror(() => this.mirror!.setStepResult(stepId, result))
+    await this.mirrored(
+      () => this.setStepResultImpl(stepId, result),
+      (mirror) => mirror.setStepResult(stepId, result)
+    )
   }
 
   protected abstract setStepResultImpl(
@@ -724,9 +916,9 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     stepId: string,
     childRunId: string
   ): Promise<void> {
-    await this.setStepChildRunIdImpl(stepId, childRunId)
-    await this.safeMirror(() =>
-      this.mirror!.setStepChildRunId(stepId, childRunId)
+    await this.mirrored(
+      () => this.setStepChildRunIdImpl(stepId, childRunId),
+      (mirror) => mirror.setStepChildRunId(stepId, childRunId)
     )
   }
 
@@ -742,14 +934,18 @@ export abstract class PikkuWorkflowService implements WorkflowService {
    * @param error - Error object
    */
   public async setStepError(stepId: string, error: Error): Promise<void> {
-    await this.setStepErrorImpl(stepId, error)
-    const serialized: SerializedError = {
-      message: error.message,
-      stack: error.stack,
-      code: (error as any).code,
-      expected: isExpectedError(error),
-    }
-    await this.safeMirror(() => this.mirror!.setStepError(stepId, serialized))
+    await this.mirrored(
+      () => this.setStepErrorImpl(stepId, error),
+      (mirror) => {
+        const serialized: SerializedError = {
+          message: error.message,
+          stack: error.stack,
+          code: (error as any).code,
+          expected: isExpectedError(error),
+        }
+        return mirror.setStepError(stepId, serialized)
+      }
+    )
   }
 
   protected abstract setStepErrorImpl(
@@ -769,15 +965,14 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     failedStepId: string,
     status: 'pending' | 'running'
   ): Promise<StepState> {
-    const newStep = await this.createRetryAttemptImpl(failedStepId, status)
-    const stepName = (newStep as any).stepName ?? ''
-    await this.safeMirror(() =>
-      this.mirror!.createRetryAttempt(failedStepId, {
-        ...newStep,
-        stepName,
-      })
+    return this.mirrored(
+      () => this.createRetryAttemptImpl(failedStepId, status),
+      (mirror, newStep) =>
+        mirror.createRetryAttempt(failedStepId, {
+          ...newStep,
+          stepName: (newStep as any).stepName ?? '',
+        })
     )
-    return newStep
   }
 
   protected abstract createRetryAttemptImpl(
@@ -871,8 +1066,10 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     stepId: string,
     branchKey: string
   ): Promise<void> {
-    await this.setBranchTakenImpl(stepId, branchKey)
-    await this.safeMirror(() => this.mirror!.setBranchTaken(stepId, branchKey))
+    await this.mirrored(
+      () => this.setBranchTakenImpl(stepId, branchKey),
+      (mirror) => mirror.setBranchTaken(stepId, branchKey)
+    )
   }
 
   protected abstract setBranchTakenImpl(
@@ -891,8 +1088,10 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     name: string,
     value: unknown
   ): Promise<void> {
-    await this.updateRunStateImpl(runId, name, value)
-    await this.safeMirror(() => this.mirror!.updateRunState(runId, name, value))
+    await this.mirrored(
+      () => this.updateRunStateImpl(runId, name, value),
+      (mirror) => mirror.updateRunState(runId, name, value)
+    )
   }
 
   protected abstract updateRunStateImpl(
@@ -915,9 +1114,11 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     source: string,
     status?: WorkflowVersionStatus
   ): Promise<void> {
-    await this.upsertWorkflowVersionImpl(name, graphHash, graph, source, status)
-    await this.safeMirror(() =>
-      this.mirror!.upsertWorkflowVersion(name, graphHash, graph, source, status)
+    await this.mirrored(
+      () =>
+        this.upsertWorkflowVersionImpl(name, graphHash, graph, source, status),
+      (mirror) =>
+        mirror.upsertWorkflowVersion(name, graphHash, graph, source, status)
     )
   }
 
@@ -934,9 +1135,9 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     graphHash: string,
     status: WorkflowVersionStatus
   ): Promise<void> {
-    await this.updateWorkflowVersionStatusImpl(name, graphHash, status)
-    await this.safeMirror(() =>
-      this.mirror!.updateWorkflowVersionStatus(name, graphHash, status)
+    await this.mirrored(
+      () => this.updateWorkflowVersionStatusImpl(name, graphHash, status),
+      (mirror) => mirror.updateWorkflowVersionStatus(name, graphHash, status)
     )
   }
 
@@ -951,10 +1152,6 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     graphHash: string
   ): Promise<{ graph: any; source: string } | null>
 
-  abstract getAIGeneratedWorkflows(
-    agentName?: string
-  ): Promise<Array<{ workflowName: string; graphHash: string; graph: any }>>
-
   // ============================================================================
   // Workflow Lifecycle Methods
   // ============================================================================
@@ -1024,9 +1221,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     const queueService = this.verifyQueueService()
     await queueService.add(
       this.getStepWorkerQueueName(rpcName),
-      JSON.parse(
-        JSON.stringify({ runId, stepName, rpcName, data, fromStepName })
-      ),
+      { runId, stepName, rpcName, data, fromStepName },
       {
         ...this.resolveStepJobOptions(stepOptions),
         // Group by step function, mirroring how per-step queues split them —
@@ -1118,9 +1313,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     try {
       await getSingletonServices()!.queueService!.add(
         this.getStepWorkerQueueName(rpcName),
-        JSON.parse(
-          JSON.stringify({ runId, stepName, rpcName, data, fromStepName })
-        ),
+        { runId, stepName, rpcName, data, fromStepName },
         {
           ...this.resolveStepJobOptions(stepOptions),
           group: this.getJobGroup(rpcName),
@@ -1162,37 +1355,28 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     return true
   }
 
-  /** Build HTTP scenario actors for a run started without them; undefined when SCENARIO_ACTOR_SECRET or the API URL is missing */
-  private async resolveScenarioActors(): Promise<ScenarioActors | undefined> {
-    const services = getSingletonServices()
-    const variables = services?.variables
-    const metaService = services?.metaService
-    if (!variables || !metaService) {
-      return undefined
-    }
-    const secret = await variables.get('SCENARIO_ACTOR_SECRET')
-    const apiUrl = await variables.get('API_URL')
-    if (!secret || !apiUrl) {
-      services?.logger?.warn(
-        'A scenario was started without actors but SCENARIO_ACTOR_SECRET / API_URL is not configured — running without actors.'
-      )
-      return undefined
-    }
-    const actorsConfig = await metaService.getScenarioActorsMeta()
-    if (!actorsConfig || Object.keys(actorsConfig).length === 0) {
-      return undefined
+  /**
+   * Install the one extension a run may have, built from a handle onto the run
+   * engine so that `inlineStep` and friends stay protected rather than becoming
+   * public API. Returns the extension, so the caller keeps a typed reference to
+   * whatever it just built.
+   */
+  public setRunExtension<T extends WorkflowRunExtension>(
+    create: (engine: WorkflowRunEngine) => T
+  ): T {
+    const engine: WorkflowRunEngine = {
+      inlineStep: this.inlineStep.bind(this),
+      updateRunStatus: this.updateRunStatus.bind(this),
+      onChildWorkflowFailed: this.onChildWorkflowFailed.bind(this),
+      verifyStepName: this.verifyStepName.bind(this),
     }
-    const signInPath =
-      (await variables.get('SCENARIO_SIGN_IN_PATH')) ??
-      '/api/auth/sign-in/actor'
-    const rpcPath = (await variables.get('SCENARIO_RPC_PATH')) ?? '/rpc'
-    return createHttpScenarioActors({
-      apiUrl,
-      secret,
-      actors: actorsConfig,
-      signInPath,
-      rpcPath,
-    })
+    const extension = create(engine)
+    this.runExtension = extension
+    return extension
+  }
+
+  public getRunExtension(): WorkflowRunExtension | undefined {
+    return this.runExtension
   }
 
   /**
@@ -1200,35 +1384,32 @@ export abstract class PikkuWorkflowService implements WorkflowService {
    * Automatically detects workflow type (DSL or graph) from meta and executes accordingly
    * @param options.inline - If true, execute workflow directly without queue service
    * @param options.startNode - Starting node ID for graph workflows (from wire config)
+   * @param options.onRunCreated - Called with the run id the moment the run exists.
+   * An inline run that fails throws instead of returning, so this is the only
+   * way a caller can still read that run back — its steps, and which one failed.
    */
   public async startWorkflow<I>(
     name: string,
     input: I,
     wire: WorkflowRunWire,
     rpcService: any,
-    options?: { inline?: boolean; startNode?: string; actors?: ScenarioActors }
+    options?: {
+      inline?: boolean
+      startNode?: string
+      actors?: ScenarioActors
+      onRunCreated?: (runId: string) => void
+    }
   ): Promise<{ runId: string }> {
-    // Resolve workflow from static meta (root or addon namespace), then dynamic DB
+    // Resolve workflow from static meta (root or addon namespace)
     const resolved = resolveWorkflowMeta(name)
-    let workflowMeta = resolved?.meta
+    const workflowMeta = resolved?.meta
     const packageName = resolved?.packageName ?? null
 
-    if (!workflowMeta) {
-      const dynamicWorkflows = await this.getAIGeneratedWorkflows()
-      const match = dynamicWorkflows.find((w) => w.workflowName === name)
-      if (match?.graph) {
-        workflowMeta = match.graph
-      }
-    }
-
     if (!workflowMeta) {
       throw new WorkflowNotFoundError(name)
     }
 
-    if (
-      workflowMeta.source === 'graph' ||
-      workflowMeta.source === 'dynamic-workflow'
-    ) {
+    if (workflowMeta.source === 'graph') {
       const shouldInline =
         options?.inline || !getSingletonServices()?.queueService
       return runWorkflowGraph(
@@ -1270,17 +1451,12 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       }
     )
 
-    const actors =
-      options?.actors ??
-      (workflowMeta.source === 'scenario'
-        ? await this.resolveScenarioActors()
-        : undefined)
-    if (actors) {
-      this.runActors.set(runId, actors)
-    }
+    options?.onRunCreated?.(runId)
+
+    await this.runExtension?.attachRunContext(runId, workflowMeta, options)
 
     if (shouldInline) {
-      this.inlineRuns.add(runId)
+      this.registerInlineRun(runId)
       try {
         await this.runWorkflowJob(runId, rpcService)
       } catch (error: any) {
@@ -1313,8 +1489,8 @@ export abstract class PikkuWorkflowService implements WorkflowService {
           throw error
         }
       } finally {
-        this.inlineRuns.delete(runId)
-        this.runActors.delete(runId)
+        this.unregisterInlineRun(runId)
+        this.runExtension?.detachRunContext(runId)
       }
     } else {
       await this.resumeWorkflow(runId)
@@ -1329,7 +1505,6 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     rpcService: any,
     options?: { pollIntervalMs?: number; wire?: WorkflowRunWire }
   ): Promise<any> {
-    const pollInterval = options?.pollIntervalMs ?? 1000
     const { runId } = await this.startWorkflow(
       name,
       input,
@@ -1337,38 +1512,155 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       rpcService,
       { inline: true }
     )
+    const run = await this.awaitRunEnd(runId, options?.pollIntervalMs ?? 1000)
+    if (run.status === 'failed') {
+      throw new WorkflowRunFailedError(run.error?.message)
+    }
+    if (run.status === 'cancelled') {
+      throw new WorkflowRunCancelledError()
+    }
+    return run.output
+  }
+
+  /**
+   * Read a run until it reaches an end state, backing off as it drags on.
+   *
+   * A fixed interval is wrong at both ends: it makes a workflow that finished
+   * in milliseconds wait out the whole interval anyway, and it keeps reading a
+   * long-running one at full rate for as long as it lasts. Starting short and
+   * growing to `maxIntervalMs` returns quick runs promptly while a slow run's
+   * read cost grows logarithmically rather than linearly with its duration.
+   */
+  protected async awaitRunEnd(
+    runId: string,
+    maxIntervalMs: number
+  ): Promise<WorkflowRun> {
+    let interval = Math.min(WORKFLOW_POLL_MIN_MS, maxIntervalMs)
     while (true) {
       const run = await this.getRun(runId)
       if (!run) {
         throw new WorkflowRunNotFoundError(runId)
       }
       if (WORKFLOW_END_STATES.has(run.status)) {
-        if (run.status === 'failed') {
-          throw new WorkflowRunFailedError(run.error?.message)
-        }
-        if (run.status === 'cancelled') {
-          throw new WorkflowRunCancelledError()
-        }
-        return run.output
+        return run
       }
-      await new Promise((resolve) => setTimeout(resolve, pollInterval))
+      await this.waitBeforeNextRead(interval)
+      interval = Math.min(interval * WORKFLOW_POLL_FACTOR, maxIntervalMs)
     }
   }
 
-  // Per-run, per-replay ordinal counters (runId → stepName → count).
-  private stepOrdinals = new Map<string, Map<string, number>>()
-  // Previous step key reached in the current DSL walk (runId → stepName), so a
-  // new step records where it came from. Rebuilt each replay alongside ordinals.
-  private stepLineage = new Map<string, string>()
+  /**
+   * Wait between two reads of a run.
+   *
+   * Its own method so the backoff schedule can be asserted on directly. Timing
+   * a poll loop by the clock measures the host's scheduler as much as the
+   * policy — `setTimeout(40)` routinely returns late on a loaded runner — which
+   * makes the obvious test both slow and flaky.
+   */
+  protected async waitBeforeNextRead(ms: number): Promise<void> {
+    await new Promise((resolve) => setTimeout(resolve, ms))
+  }
 
-  private resetStepOrdinals(runId: string): void {
-    this.stepOrdinals.set(runId, new Map())
-    this.stepLineage.delete(runId)
+  /**
+   * Every step of a run in one read, or `null` if this backend has no bulk read.
+   *
+   * A replay walks the DSL body from the top, and each step it passes asks for
+   * its own row — so a run of N steps costs N reads per replay and O(N^2) over
+   * its lifetime. Backends that can answer this in a single query collapse that
+   * to one read per replay.
+   */
+  protected async listStepStates(
+    _runId: string
+  ): Promise<Array<StepState & { stepName: string }> | null> {
+    return null
+  }
+
+  /**
+   * Begin a replay pass: fresh ordinal counters, and one read of the steps the
+   * run has already taken so the walk back to where it left off is served from
+   * memory. Safe because a pass reaches each step key at most once, and the
+   * steps it replays past are `succeeded` and therefore immutable.
+   */
+  private async beginReplay(runId: string): Promise<void> {
+    const context = this.contextFor(runId)
+    context.replay = { ordinals: new Map() }
+    const steps = await this.listStepStates(runId)
+    if (steps) {
+      context.replay.steps = new Map(steps.map((step) => [step.stepName, step]))
+    }
+  }
+
+  private endReplay(runId: string): void {
+    const context = this.runContexts.get(runId)
+    if (!context) return
+    context.replay = undefined
+    this.releaseContext(runId)
+  }
+
+  /**
+   * The step row for `stepName`, creating it if the run has not reached it
+   * before. Served from the replay snapshot when one is loaded.
+   */
+  private async loadOrCreateStep(
+    runId: string,
+    stepName: string,
+    create: () => Promise<StepState>
+  ): Promise<StepState> {
+    const snapshot = this.runContexts.get(runId)?.replay?.steps
+    if (snapshot) {
+      const cached = snapshot.get(stepName)
+      if (cached) {
+        return cached
+      }
+    } else {
+      try {
+        return await this.getStepState(runId, stepName)
+      } catch {
+        // No row yet — fall through and create it.
+      }
+    }
+
+    let step: StepState
+    try {
+      step = await create()
+    } catch (error) {
+      // A concurrent replay of this run created the row after the snapshot was
+      // taken. Its state is the truth; if it isn't really there, the insert
+      // failed for its own reasons and that error is the one worth seeing.
+      try {
+        step = await this.getStepState(runId, stepName)
+      } catch {
+        throw error
+      }
+    }
+    snapshot?.set(stepName, step)
+    return step
+  }
+
+  /**
+   * The run's immutable half — which workflow it is, the wire it was started
+   * on, its input. `getRun` is otherwise called several times per step for
+   * answers that were all fixed at creation, so a replay reads it once and
+   * hands the same object to everyone who only needs that half.
+   *
+   * Anyone who needs `status`, `output`, `error` or `state` must call `getRun`:
+   * those move while the run executes, and a cached copy would be a lie.
+   */
+  private async getRunIdentity(runId: string): Promise<WorkflowRun | null> {
+    const replay = this.runContexts.get(runId)?.replay
+    if (replay?.run) {
+      return replay.run
+    }
+    const run = await this.getRun(runId)
+    if (run && replay) {
+      replay.run = run
+    }
+    return run
   }
 
   /** The step the DSL walk last reached (the predecessor for the next step). */
   private lastStepName(runId: string): string | undefined {
-    return this.stepLineage.get(runId)
+    return this.runContexts.get(runId)?.replay?.lastStep
   }
 
   /**
@@ -1378,26 +1670,26 @@ export abstract class PikkuWorkflowService implements WorkflowService {
    * the rows clobbering. Deterministic given a deterministic DSL body.
    */
   private nextStepKey(runId: string, logicalStepName: string): string {
-    let perRun = this.stepOrdinals.get(runId)
-    if (!perRun) {
-      perRun = new Map()
-      this.stepOrdinals.set(runId, perRun)
-    }
-    const ordinal = perRun.get(logicalStepName) ?? 0
-    perRun.set(logicalStepName, ordinal + 1)
+    const context = this.contextFor(runId)
+    const replay: NonNullable<RunContext['replay']> = (context.replay ??= {
+      ordinals: new Map(),
+    })
+    const ordinal = replay.ordinals.get(logicalStepName) ?? 0
+    replay.ordinals.set(logicalStepName, ordinal + 1)
     const stepName =
       ordinal === 0 ? logicalStepName : `${logicalStepName}#${ordinal}`
-    this.stepLineage.set(runId, stepName)
+    replay.lastStep = stepName
     return stepName
   }
 
   public async runWorkflowJob(runId: string, rpcService: any): Promise<void> {
-    // Fresh ordinal counters per replay so step keys are deterministic.
-    this.resetStepOrdinals(runId)
+    // Fresh ordinal counters per replay so step keys are deterministic, and one
+    // read of the steps the run has already taken.
+    await this.beginReplay(runId)
     try {
       await this.runWorkflowJobInner(runId, rpcService)
     } finally {
-      this.stepOrdinals.delete(runId)
+      this.endReplay(runId)
     }
   }
 
@@ -1405,7 +1697,9 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     runId: string,
     rpcService: any
   ): Promise<void> {
-    const run = await this.getRun(runId)
+    // Caches the run for the rest of this replay, so the steps it walks don't
+    // each re-read the workflow name and wire it already has.
+    const run = await this.getRunIdentity(runId)
     if (!run) {
       throw new WorkflowRunNotFoundError(runId)
     }
@@ -1423,10 +1717,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       return
     }
 
-    if (
-      workflowMeta?.source === 'graph' ||
-      workflowMeta?.source === 'dynamic-workflow'
-    ) {
+    if (workflowMeta?.source === 'graph') {
       await continueGraph(this, runId, run.workflow)
       const updatedRun = await this.getRun(runId)
       if (updatedRun?.status === 'completed') {
@@ -1443,29 +1734,6 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       return
     }
 
-    if (!workflowMeta) {
-      const dynamicWorkflows = await this.getAIGeneratedWorkflows()
-      const match = dynamicWorkflows.find(
-        (w) => w.workflowName === run.workflow
-      )
-      if (match?.graph) {
-        await continueGraph(this, runId, run.workflow, match.graph)
-        const updatedRun = await this.getRun(runId)
-        if (updatedRun?.status === 'completed') {
-          await this.onChildWorkflowCompleted(updatedRun, updatedRun.output)
-        } else if (
-          updatedRun?.status === 'failed' ||
-          updatedRun?.status === 'cancelled'
-        ) {
-          await this.onChildWorkflowFailed(
-            updatedRun,
-            new Error(updatedRun.error?.message || 'Child workflow failed')
-          )
-        }
-        return
-      }
-    }
-
     const registrations = pikkuState(pkgName, 'workflows', 'registrations')
     const workflow = registrations.get(resolved?.resolvedName ?? run.workflow)
     if (!workflow) {
@@ -1485,15 +1753,33 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       workflowWire.pikkuUserId = run.wire?.pikkuUserId
       const wire: PikkuWire = {
         workflow: workflowWire,
-        scenario:
-          workflowMeta?.source === 'scenario' ? workflowWire : undefined,
         pikkuUserId: run.wire?.pikkuUserId,
         session: rpcService?.wire?.session,
         rpc: rpcService?.wire?.rpc,
-        // User-flow actors registered for this run (see startWorkflow options)
-        actors: this.runActors.get(runId),
       }
+      this.runExtension?.decorateRunWire(wire, {
+        runId,
+        workflowMeta,
+        workflowWire,
+      })
+
+      const lifecycle: RunLifecycleContext = {
+        runId,
+        run,
+        workflowMeta,
+        workflow,
+        wire,
+        packageName: pkgName,
+      }
+
+      // `interrupted` means the run has not reached a terminal state — it is
+      // suspended or waiting — so teardown would run while the run is still
+      // mid-flight.
+      let outcome: 'completed' | 'failed' | 'interrupted' = 'completed'
+      let failure: any
       try {
+        await this.runExtension?.onBeforeRunFunc(lifecycle)
+
         const result = await runPikkuFunc(
           'workflow',
           workflowMeta.name,
@@ -1510,11 +1796,15 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         await this.updateRunStatus(runId, 'completed', result)
         await this.onChildWorkflowCompleted(run, result)
       } catch (error: any) {
+        failure = error
+
         if (error instanceof WorkflowAsyncException) {
+          outcome = 'interrupted'
           throw error
         }
 
         if (error instanceof WorkflowCancelledException) {
+          outcome = 'failed'
           await this.updateRunStatus(runId, 'cancelled', undefined, {
             message: error.message || 'Workflow cancelled',
             stack: '',
@@ -1525,6 +1815,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         }
 
         if (error instanceof WorkflowSuspendedException) {
+          outcome = 'interrupted'
           await this.updateRunStatus(runId, 'suspended', undefined, {
             message: error.message || 'Workflow suspended',
             stack: '',
@@ -1533,6 +1824,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
           throw error
         }
 
+        outcome = 'failed'
         await this.updateRunStatus(runId, 'failed', undefined, {
           message: error.message,
           stack: error.stack,
@@ -1541,6 +1833,8 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         await this.onChildWorkflowFailed(run, error)
 
         throw error
+      } finally {
+        await this.runExtension?.onAfterRunFunc(lifecycle, outcome, failure)
       }
     })
   }
@@ -1559,7 +1853,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     await this.resumeWorkflow(parentRunId)
   }
 
-  private async onChildWorkflowFailed(
+  protected async onChildWorkflowFailed(
     childRun: WorkflowRun,
     error: Error
   ): Promise<void> {
@@ -1652,9 +1946,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       const meta = pikkuState(null, 'workflows', 'meta')
       const workflowMeta = meta[run.workflow]
 
-      const isGraphWorkflow =
-        workflowMeta?.source === 'graph' ||
-        workflowMeta?.source === 'dynamic-workflow'
+      const isGraphWorkflow = workflowMeta?.source === 'graph'
       // Map the physical step key back to its logical node: a revisit instance
       // is `node#N` (ordinal), which isn't a literal key in `nodes`.
       let graphNodeId: string | undefined
@@ -1721,7 +2013,8 @@ export abstract class PikkuWorkflowService implements WorkflowService {
             stepState,
             rpcName,
             data,
-            rpcService
+            rpcService,
+            run
           )
         }
       }
@@ -1826,11 +2119,12 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     stepState: StepState,
     rpcName: string,
     data: any,
-    rpcService: any
+    rpcService: any,
+    knownRun?: WorkflowRun | null
   ): Promise<any> {
     // Carry the run's pikkuUserId onto the step wire so authed steps rehydrate their
     // session on the queued path too (the bare job wire lacks it; inline already has it).
-    const run = await this.getRun(runId)
+    const run = knownRun ?? (await this.getRunIdentity(runId))
     return rpcService.rpcWithWire(rpcName, data, {
       ...(run?.wire?.pikkuUserId ? { pikkuUserId: run.wire.pikkuUserId } : {}),
       workflowStep: {
@@ -1940,13 +2234,9 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       actor: stepOptions?.actor,
       onError: stepOptions?.onError,
     }
-    // Check if step already exists
-    let stepState: StepState
-    try {
-      stepState = await this.getStepState(runId, stepName)
-    } catch {
-      // Step doesn't exist - create it
-      stepState = await this.insertStepState(
+    // Reuse the step if the run already reached it, otherwise create it.
+    const stepState = await this.loadOrCreateStep(runId, stepName, () =>
+      this.insertStepState(
         runId,
         stepName,
         rpcName,
@@ -1954,7 +2244,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         resolvedStepOptions,
         fromStepName
       )
-    }
+    )
 
     if (stepState.status === 'succeeded') {
       // Return cached result
@@ -2048,24 +2338,17 @@ export abstract class PikkuWorkflowService implements WorkflowService {
           )
           await this.setStepChildRunId(currentStepState.stepId, childRunId)
           // Poll until child workflow completes
-          while (true) {
-            const childRun = await this.getRun(childRunId)
-            if (!childRun) {
-              throw new WorkflowRunNotFoundError(childRunId)
-            }
-            if (WORKFLOW_END_STATES.has(childRun.status)) {
-              if (childRun.status === 'failed') {
-                throw new Error(
-                  childRun.error?.message || 'Sub-workflow failed'
-                )
-              }
-              if (childRun.status === 'cancelled') {
-                throw new Error('Sub-workflow was cancelled')
-              }
-              return childRun.output
-            }
-            await new Promise((resolve) => setTimeout(resolve, 500))
+          const childRun = await this.awaitRunEnd(
+            childRunId,
+            WORKFLOW_CHILD_POLL_MAX_MS
+          )
+          if (childRun.status === 'failed') {
+            throw new Error(childRun.error?.message || 'Sub-workflow failed')
           }
+          if (childRun.status === 'cancelled') {
+            throw new Error('Sub-workflow was cancelled')
+          }
+          return childRun.output
         }
         return this.invokeStepRpc(
           runId,
@@ -2088,29 +2371,40 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     )
   }
 
-  private async inlineStep(
+  protected async inlineStep(
     runId: string,
     logicalStepName: string,
     fn: Function,
-    stepOptions?: WorkflowStepOptions
+    stepOptions?: WorkflowStepOptions,
+    /**
+     * The input this step was called with, recorded on the run so a reporter can
+     * name the values under test. A closure step has none; a scenario step does.
+     */
+    data: any = null,
+    /**
+     * The name this step was dispatched by, for the kinds of inline step that
+     * have one. A closure step has no name; a scenario step is a step RPC, so
+     * it records the step function that ran — which is the only way to join a
+     * step back to its declaration when its durable name was built at runtime
+     * (a step called in a loop reaches the run as `sees @pikku/addon-todos`,
+     * declared as `sees ${packageName}`).
+     */
+    rpcName: string | null = null
   ): Promise<any> {
     const fromStepName = this.lastStepName(runId)
     const stepName = this.nextStepKey(runId, logicalStepName)
-    // Check if step already exists
-    let stepState: StepState
-    try {
-      stepState = await this.getStepState(runId, stepName)
-    } catch {
-      // Step doesn't exist - create it (inline, no RPC)
-      stepState = await this.insertStepState(
+    // Reuse the step if the run already reached it, otherwise create it
+    // (inline, so never dispatched).
+    const stepState = await this.loadOrCreateStep(runId, stepName, () =>
+      this.insertStepState(
         runId,
         stepName,
-        null,
-        null,
+        rpcName,
+        data,
         stepOptions,
         fromStepName
       )
-    }
+    )
 
     if (stepState.status === 'succeeded') {
       // Return cached result
@@ -2162,13 +2456,10 @@ export abstract class PikkuWorkflowService implements WorkflowService {
   ) {
     const fromStepName = this.lastStepName(runId)
     const stepName = this.nextStepKey(runId, logicalStepName)
-    // Check if step already exists
-    let stepState: StepState
-    try {
-      stepState = await this.getStepState(runId, stepName)
-    } catch {
-      // Step doesn't exist - create it (sleep step, no RPC)
-      stepState = await this.insertStepState(
+    // Reuse the step if the run already reached it, otherwise create it
+    // (sleep step, no RPC).
+    const stepState = await this.loadOrCreateStep(runId, stepName, () =>
+      this.insertStepState(
         runId,
         stepName,
         null,
@@ -2176,7 +2467,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         undefined,
         fromStepName
       )
-    }
+    )
 
     if (stepState.status === 'succeeded') {
       // Sleep already completed, return immediately
@@ -2494,8 +2785,8 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     runId: string,
     rpcService: any,
     addonNamespace?: string | null
-  ): PikkuScenarioWire {
-    const workflowWire: PikkuScenarioWire = {
+  ): PikkuWorkflowWire {
+    const workflowWire: PikkuWorkflowWire = {
       name,
       runId,
       getRun: async () => (await this.getRun(runId)) as WorkflowRun,
@@ -2531,146 +2822,6 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         }
       },
 
-      // Durable polling step: invoke an RPC (as an actor when options.as is
-      // set) until the predicate passes or `within` elapses. The whole poll is
-      // ONE recorded step, so replay returns the cached outcome.
-      expectEventually: async (
-        stepName: string,
-        rpcName: string,
-        data: any,
-        predicate: (output: any) => boolean,
-        options?: WorkflowExpectEventuallyOptions
-      ) => {
-        this.verifyStepName(stepName)
-        const resolvedRpcName =
-          addonNamespace && !rpcName.includes(':')
-            ? `${addonNamespace}:${rpcName}`
-            : rpcName
-        const within = getDurationInMilliseconds(options?.within ?? '30s')
-        const interval = getDurationInMilliseconds(options?.interval ?? '1s')
-        return await this.inlineStep(
-          runId,
-          stepName,
-          async () => {
-            const deadline = Date.now() + within
-            let last: any
-            while (true) {
-              last = options?.actor
-                ? await options.actor.invoke(resolvedRpcName, data)
-                : await rpcService.rpcWithWire(resolvedRpcName, data, {})
-              if (predicate(last)) return last
-              if (Date.now() + interval > deadline) {
-                throw new Error(
-                  `[workflow] expectEventually '${stepName}' ('${resolvedRpcName}'` +
-                    `${options?.actor ? ` as '${options.actor.name}'` : ''}) did not pass within ${within}ms; ` +
-                    `last result: ${JSON.stringify(last)?.slice(0, 300)}`
-                )
-              }
-              await new Promise((resolve) => setTimeout(resolve, interval))
-            }
-          },
-          options
-        )
-      },
-
-      expectError: async (
-        stepName: string,
-        rpcName: string,
-        data: any,
-        options?: WorkflowExpectErrorOptions
-      ) => {
-        this.verifyStepName(stepName)
-        const resolvedRpcName =
-          addonNamespace && !rpcName.includes(':')
-            ? `${addonNamespace}:${rpcName}`
-            : rpcName
-        return await this.inlineStep(
-          runId,
-          stepName,
-          async () => {
-            let result: any
-            try {
-              result = options?.actor
-                ? await options.actor.invoke(resolvedRpcName, data)
-                : await rpcService.rpcWithWire(resolvedRpcName, data, {})
-            } catch (e: any) {
-              const message = e?.message ?? String(e)
-              if (options?.matches) {
-                const matched =
-                  typeof options.matches === 'string'
-                    ? message.includes(options.matches)
-                    : options.matches.test(message)
-                if (!matched) {
-                  throw new Error(
-                    `[workflow] expectError '${stepName}' ('${resolvedRpcName}') threw, but the message did not match ${options.matches}: ${message}`
-                  )
-                }
-              }
-              return message
-            }
-            throw new Error(
-              `[workflow] expectError '${stepName}' ('${resolvedRpcName}') expected an error but the call succeeded: ${JSON.stringify(result)?.slice(0, 300)}`
-            )
-          },
-          options
-        )
-      },
-
-      expectService: async (
-        stepName: string,
-        serviceMethod: string,
-        options?: WorkflowExpectServiceOptions
-      ) => {
-        this.verifyStepName(stepName)
-        const [service, method] = serviceMethod.split('.')
-        if (!service || !method) {
-          throw new Error(
-            `[workflow] expectService '${stepName}' needs 'service.method', got '${serviceMethod}'`
-          )
-        }
-        await this.inlineStep(
-          runId,
-          stepName,
-          async () => {
-            const rpcName = 'pikkuScenarioGetStubCalls'
-            const calls: Array<{
-              service: string
-              method: string
-              args: unknown[]
-            }> = options?.actor
-              ? await options.actor.invoke(rpcName, { service })
-              : await rpcService.rpcWithWire(rpcName, { service }, {})
-            const matching = (calls ?? []).filter(
-              (c) =>
-                c.service === service &&
-                c.method === method &&
-                (options?.calledWith === undefined ||
-                  JSON.stringify(c.args?.[0]) ===
-                    JSON.stringify(options.calledWith))
-            )
-            const expected = options?.times
-            const ok =
-              expected === undefined
-                ? matching.length > 0
-                : matching.length === expected
-            if (!ok) {
-              const seen =
-                (calls ?? [])
-                  .map(
-                    (c) =>
-                      `${c.service}.${c.method}(${JSON.stringify(c.args?.[0])?.slice(0, 120) ?? ''})`
-                  )
-                  .join('\n  ') || '(none)'
-              throw new Error(
-                `[workflow] expectService '${stepName}' expected ${expected ?? 'at least one'} call(s) to '${serviceMethod}'` +
-                  `${options?.calledWith !== undefined ? ` with ${JSON.stringify(options.calledWith)}` : ''}, found ${matching.length}. Recorded:\n  ${seen}`
-              )
-            }
-          },
-          options
-        )
-      },
-
       // Implement workflow.sleep()
       sleep: async (stepName: string, duration: string | number) => {
         this.verifyStepName(stepName)
@@ -2689,16 +2840,18 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       approval: (async (reason: string, options: WorkflowApprovalOptions) => {
         this.verifyStepName(reason)
         return await this.approvalStep(runId, reason, options)
-      }) as PikkuScenarioWire['approval'],
-
-      runScheduledTask: async (taskName: string) => {
-        await runScheduledTask({ name: taskName })
-      },
+      }) as PikkuWorkflowWire['approval'],
     }
+    this.runExtension?.decorateWorkflowWire(workflowWire, {
+      name,
+      runId,
+      rpcService,
+      addonNamespace,
+    })
     return workflowWire
   }
 
-  private verifyStepName(stepName: string) {
+  protected verifyStepName(stepName: string) {
     if (typeof stepName !== 'string') {
       throw new WorkflowStepNameNotString(stepName)
     }