@plumbus/core 0.7.1 → 0.8.0-beta.0

package/dist/flows/engine.js

@@ -3,8 +3,13 @@ import { and, eq, inArray, isNull, lte, or, sql } from 'drizzle-orm';
 import { randomUUID } from 'node:crypto';
 import { hostname } from 'node:os';
 import { parseDurationToMs } from '../config/duration.js';
-import { FlowCancelledError, LeaseLostError } from '../errors/index.js';
-import { BackoffStrategy } from '../types/enums.js';
+import { FlowCancelledError, LeaseLostError, PlumbusError } from '../errors/index.js';
+import { BUDGET_EXHAUSTED, consumeExecutionBudget, createExecutionBudgetLedger, writeExecutionBudget, } from './budget.js';
+import { BackoffStrategy, ErrorCode, FlowStepType } from '../types/enums.js';
+import { FRAMEWORK_SCHEMA } from '../data/schema-generator.js';
+import { ackSpineDispatch, casAdvanceExecution, claimSpineDispatch, insertDispatchOutbox, loadExecutionState, persistAcceptanceOnDb, publishOutboxToSpine, } from '../durable/index.js';
+import { flowDefinitionId, hydrateCompiledFlow } from './compile-flow.js';
+import { assertSupportedDefinitionStrategy, DefinitionInFlightStrategy, } from './definition-strategy.js';
 import { flowExecutionsTable } from './schema.js';
 import { assertTransition, FlowStatus, isTerminal, StepStatus, } from './state-machine.js';
 import { buildHistoryEntry, executeStep, } from './step-executor.js';
@@ -68,13 +73,71 @@ export function generateWorkerId() {
  * across multiple workers sharing the same database.
  */
 export function createFlowEngine(config) {
-    const { db, registry, stepDeps, audit, onFlowError, createEventService } = config;
+    const { db, registry, audit, onFlowError, createEventService } = config;
+    const compiledRegistry = config.compiledRegistry;
+    const approvals = config.approvals;
+    const stepDeps = {
+        ...config.stepDeps,
+        findApprovalForExecution: config.stepDeps.findApprovalForExecution ??
+            (approvals ? (executionId) => approvals.findByExecutionId(executionId) : undefined),
+    };
     const workerId = config.workerId ?? generateWorkerId();
     const leaseDurationMs = config.flowLeaseDurationMs ?? DEFAULT_LEASE_DURATION_MS;
     const heartbeatIntervalMs = config.flowHeartbeatIntervalMs ?? Math.floor(leaseDurationMs / 3);
     const claimBatchSize = config.flowClaimBatchSize ?? DEFAULT_CLAIM_BATCH_SIZE;
     const logger = config.logger;
     const onFlowStepEnqueue = config.onFlowStepEnqueue;
+    const spineDispatch = config.spineDispatch;
+    const durableSchema = spineDispatch?.coreSchema ?? FRAMEWORK_SCHEMA;
+    const executionStores = new Map();
+    const claimedHints = new Map();
+    const executionPins = new Map();
+    function restorePinFromRow(row) {
+        if (executionPins.has(row.id))
+            return;
+        if (!row.definitionVersion)
+            return;
+        executionPins.set(row.id, {
+            flowDefinitionId: flowDefinitionId({ domain: row.domain, name: row.flowName }),
+            definitionVersion: row.definitionVersion,
+            definitionDigest: row.definitionDigest ?? undefined,
+        });
+    }
+    function resolveCompiledForStart(flow) {
+        if (!compiledRegistry)
+            return undefined;
+        const id = flowDefinitionId(flow);
+        const compiled = compiledRegistry.getLatest(id);
+        if (!compiled) {
+            throw new PlumbusError(ErrorCode.NotFound, `compiled definition required for "${id}"`, {
+                reason: 'compiled-definition-required',
+            });
+        }
+        return compiled;
+    }
+    function resolveExecutionFlow(executionId, flowName) {
+        const authoring = registry.get(flowName);
+        if (!authoring) {
+            throw new Error(`Flow "${flowName}" is not registered`);
+        }
+        if (!compiledRegistry)
+            return authoring;
+        const pin = executionPins.get(executionId);
+        if (!pin) {
+            throw new PlumbusError(ErrorCode.NotFound, `Flow "${flowName}" has no pinned compiled definition`, { reason: 'compiled-definition-missing', executionId });
+        }
+        const compiled = compiledRegistry.get(pin.flowDefinitionId, pin.definitionVersion);
+        if (!compiled) {
+            throw new PlumbusError(ErrorCode.NotFound, `compiled definition "${pin.flowDefinitionId}@${pin.definitionVersion}" is not in the registry`, { reason: 'compiled-definition-missing' });
+        }
+        if (pin.definitionDigest && compiled.definitionDigest !== pin.definitionDigest) {
+            throw new PlumbusError(ErrorCode.Conflict, `compiled definition digest mismatch for "${pin.flowDefinitionId}@${pin.definitionVersion}"`, { reason: 'compiled-definition-digest-mismatch' });
+        }
+        return hydrateCompiledFlow(compiled, authoring);
+    }
+    function storeFor(executionId) {
+        return executionStores.get(executionId) ?? db;
+    }
     const onFlowDelayedSchedule = config.onFlowDelayedSchedule;
     async function maybeEnqueueFlowStep(executionId, correlationId) {
         if (onFlowStepEnqueue) {
@@ -103,26 +166,56 @@ export function createFlowEngine(config) {
             throw new Error(`Flow "${flowName}": invalid input — ${parseResult.error.message}`);
         }
         const executionId = opts?.executionId ?? randomUUID();
-        const initialState = flow.state
+        const compiled = resolveCompiledForStart(flow);
+        const executionFlow = compiled ? hydrateCompiledFlow(compiled, flow) : flow;
+        const definitionVersion = compiled?.definitionVersion ?? '0.0.0';
+        if (compiled) {
+            executionPins.set(executionId, {
+                flowDefinitionId: compiled.flowDefinitionId,
+                definitionVersion: compiled.definitionVersion,
+                definitionDigest: compiled.definitionDigest,
+            });
+        }
+        let initialState = flow.state
             ? (() => {
                 const parsed = flow.state.safeParse({});
                 return parsed.success ? parsed.data : {};
             })()
             : null;
-        await db.insert(flowExecutionsTable).values({
+        if (flow.budget) {
+            initialState = writeExecutionBudget(initialState, createExecutionBudgetLedger({
+                executionId,
+                profileId: flow.budget.profileId,
+                allocated: flow.budget.allocated,
+                unitId: flow.budget.unitId,
+                dimensionId: flow.budget.dimensionId,
+            }));
+        }
+        let writeDb = db;
+        if (spineDispatch) {
+            if (!auth.tenantId) {
+                throw new PlumbusError(ErrorCode.Forbidden, 'spine dispatch requires a tenant reference on flow start', { reason: 'untenanted-flow-start' });
+            }
+            const handle = await spineDispatch.resolver.resolve(auth.tenantId);
+            writeDb = handle.db;
+            executionStores.set(executionId, writeDb);
+        }
+        await writeDb.insert(flowExecutionsTable).values({
             id: executionId,
             flowName,
             domain: flow.domain,
             status: FlowStatus.Created,
             input: parseResult.data,
             state: initialState,
-            currentStep: flow.steps[0]?.name ?? null,
+            currentStep: executionFlow.steps[0]?.name ?? null,
             stepHistory: [],
             actor: auth.userId ?? 'system',
             tenantId: auth.tenantId ?? null,
             authSnapshotJson: flowAuthSchema.parse(auth),
             correlationId: opts?.correlationId ?? null,
             triggerEventId: opts?.triggerEventId ?? null,
+            definitionVersion: compiled?.definitionVersion ?? null,
+            definitionDigest: compiled?.definitionDigest ?? null,
         });
         if (audit) {
             await audit.record(`flow.started.${flowName}`, {
@@ -134,6 +227,20 @@ export function createFlowEngine(config) {
             });
         }
         await maybeEnqueueFlowStep(executionId, opts?.correlationId);
+        if (spineDispatch && auth.tenantId) {
+            const nowIso = new Date().toISOString();
+            const firstStepId = executionFlow.steps[0]?.name ?? 'terminal';
+            const accepted = await persistAcceptanceOnDb(writeDb, {
+                executionId,
+                tenantRef: auth.tenantId,
+                definitionId: flowName,
+                definitionVersion,
+                firstStepId,
+                correlationId: opts?.correlationId ?? executionId,
+                nowIso,
+            }, durableSchema);
+            await publishOutboxToSpine(writeDb, spineDispatch.db, accepted.outbox, `disp:${executionId}:1`, nowIso, durableSchema);
+        }
         return {
             id: executionId,
             flowName,
@@ -145,7 +252,67 @@ export function createFlowEngine(config) {
      * Uses FOR UPDATE SKIP LOCKED so concurrent workers each get different rows.
      * Also reclaims rows whose lease has expired (crash recovery).
      */
+    async function claimNextFromSpine(batchSize) {
+        if (!spineDispatch)
+            return [];
+        const hints = await claimSpineDispatch(spineDispatch.db, {
+            workerId,
+            leaseDurationMs,
+            limit: batchSize ?? claimBatchSize,
+        });
+        const rows = [];
+        for (const hint of hints) {
+            try {
+                const handle = await spineDispatch.resolver.resolve(hint.tenantRouteId);
+                const tenantState = await loadExecutionState(handle.db, hint.executionId, durableSchema);
+                if (!tenantState ||
+                    tenantState.terminal ||
+                    tenantState.revision !== hint.expectedRevision ||
+                    tenantState.tenantEpoch !== hint.tenantEpoch) {
+                    await ackSpineDispatch(spineDispatch.db, hint.dispatchId);
+                    continue;
+                }
+                const execRows = await handle.db
+                    .select()
+                    .from(flowExecutionsTable)
+                    .where(eq(flowExecutionsTable.id, hint.executionId))
+                    .limit(1);
+                const row = execRows[0];
+                if (!row) {
+                    await ackSpineDispatch(spineDispatch.db, hint.dispatchId);
+                    continue;
+                }
+                executionStores.set(hint.executionId, handle.db);
+                claimedHints.set(hint.executionId, hint);
+                await handle.db
+                    .update(flowExecutionsTable)
+                    .set({
+                    status: FlowStatus.Running,
+                    leaseOwner: workerId,
+                    leaseExpiresAt: new Date(Date.now() + leaseDurationMs),
+                    updatedAt: new Date(),
+                })
+                    .where(eq(flowExecutionsTable.id, hint.executionId));
+                rows.push({
+                    ...row,
+                    status: FlowStatus.Running,
+                    leaseOwner: workerId,
+                });
+            }
+            catch (error) {
+                logger?.error('spine claim failed closed for one dispatch', {
+                    dispatchId: hint.dispatchId,
+                    executionId: hint.executionId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        return rows;
+    }
     async function claimNext(batchSize) {
+        if (spineDispatch) {
+            return claimNextFromSpine(batchSize);
+        }
         const limit = batchSize ?? claimBatchSize;
         const leaseDurationInterval = `${leaseDurationMs} milliseconds`;
         const result = await db.execute(sql `
@@ -235,7 +402,7 @@ export function createFlowEngine(config) {
      */
     async function extendLease(executionId) {
         const leaseDurationInterval = `${leaseDurationMs} milliseconds`;
-        const result = await db
+        const result = await storeFor(executionId)
             .update(flowExecutionsTable)
             .set({
             leaseExpiresAt: sql `now() + ${leaseDurationInterval}::interval`,
@@ -251,7 +418,7 @@ export function createFlowEngine(config) {
             // tell at a glance which dimension diverged. Best-effort: a failure
             // here must not break the heartbeat.
             try {
-                const rows = await db
+                const rows = await storeFor(executionId)
                     .select({
                     status: flowExecutionsTable.status,
                     leaseOwner: flowExecutionsTable.leaseOwner,
@@ -294,7 +461,12 @@ export function createFlowEngine(config) {
      * The execution must have been claimed by this worker (via claimNext) first.
      */
     async function runNext(executionId, ctx) {
-        const rows = await db
+        const result = await runNextUnsynced(executionId, ctx);
+        await syncSpineAfterRun(executionId, result);
+        return result;
+    }
+    async function runNextUnsynced(executionId, ctx) {
+        const rows = await storeFor(executionId)
             .select()
             .from(flowExecutionsTable)
             .where(eq(flowExecutionsTable.id, executionId))
@@ -306,10 +478,8 @@ export function createFlowEngine(config) {
         if (isTerminal(row.status)) {
             return { id: row.id, flowName: row.flowName, status: row.status };
         }
-        const flow = registry.get(row.flowName);
-        if (!flow) {
-            throw new Error(`Flow "${row.flowName}" is not registered`);
-        }
+        restorePinFromRow(row);
+        const flow = resolveExecutionFlow(executionId, row.flowName);
         // Do not auto-run event waits, and do not run delayed waits until due.
         if (row.status === FlowStatus.Waiting && row.waitingForEvent) {
             return { id: row.id, flowName: row.flowName, status: FlowStatus.Waiting };
@@ -340,6 +510,19 @@ export function createFlowEngine(config) {
             await failFlow(executionId, row.flowName, `Step "${currentStepName}" not found in flow definition`, row);
             return { id: executionId, flowName: row.flowName, status: FlowStatus.Failed };
         }
+        if (step.type === FlowStepType.Capability) {
+            const charged = consumeExecutionBudget(row.state, 1);
+            if (charged) {
+                row.state = charged.state;
+                if (charged.exhausted) {
+                    const history = Array.isArray(row.stepHistory)
+                        ? [...row.stepHistory]
+                        : [];
+                    return handleStepFailure(executionId, row, flow, history, BUDGET_EXHAUSTED);
+                }
+                await guardedUpdate(executionId, { state: charged.state });
+            }
+        }
         // Build flow-scoped context from stored auth snapshot (not worker systemAuth roles)
         const flowAuth = resolveFlowStepAuth(row);
         if (!flowAuth) {
@@ -641,7 +824,7 @@ export function createFlowEngine(config) {
      * Resume a waiting flow (e.g., after an event arrives or approval granted).
      */
     async function resume(executionId, signal) {
-        const rows = await db
+        const rows = await storeFor(executionId)
             .select()
             .from(flowExecutionsTable)
             .where(eq(flowExecutionsTable.id, executionId))
@@ -652,9 +835,8 @@ export function createFlowEngine(config) {
         if (row.status !== FlowStatus.Waiting) {
             throw new Error(`Cannot resume flow "${executionId}" — current status is "${row.status}"`);
         }
-        const flow = registry.get(row.flowName);
-        if (!flow)
-            throw new Error(`Flow "${row.flowName}" not registered`);
+        restorePinFromRow(row);
+        const flow = resolveExecutionFlow(executionId, row.flowName);
         // Advance past the wait/delay step — set to created so claimNext picks it up
         const nextStep = getNextStepName(flow.steps, row.currentStep ?? '');
         await updateExecution(executionId, {
@@ -716,10 +898,11 @@ export function createFlowEngine(config) {
         return rows.map((row) => row.id);
     }
     /**
-     * Cancel a running or waiting flow.
+     * Cancel a running or waiting flow. Completed steps with `compensate`
+     * run their compensation capability first (recovery CompensationState v1).
      */
-    async function cancel(executionId) {
-        const rows = await db
+    async function cancel(executionId, opts) {
+        const rows = await storeFor(executionId)
             .select()
             .from(flowExecutionsTable)
             .where(eq(flowExecutionsTable.id, executionId))
@@ -730,30 +913,124 @@ export function createFlowEngine(config) {
         if (isTerminal(row.status)) {
             throw new Error(`Cannot cancel flow "${executionId}" — already in terminal state "${row.status}"`);
         }
+        restorePinFromRow(row);
+        const flow = resolveExecutionFlow(executionId, row.flowName);
+        const history = Array.isArray(row.stepHistory)
+            ? [...row.stepHistory]
+            : [];
+        // Abort the in-flight step before compensation so it cannot commit.
+        const activeAc = activeStepAborts.get(executionId);
+        if (activeAc && !activeAc.signal.aborted) {
+            activeAc.abort(new FlowCancelledError(executionId));
+        }
+        if (!opts?.skipCompensation) {
+            await runCompensations(executionId, row, flow, history);
+        }
         assertTransition(row.status, FlowStatus.Cancelled);
         await updateExecution(executionId, {
             status: FlowStatus.Cancelled,
+            stepHistory: history,
             completedAt: new Date(),
         });
-        // Synchronously abort the step's AbortController if it is running in THIS
-        // engine instance. Cross-process cancellations still converge via the next
-        // heartbeat (which fails because status is no longer 'running').
-        const activeAc = activeStepAborts.get(executionId);
-        if (activeAc && !activeAc.signal.aborted) {
-            activeAc.abort(new FlowCancelledError(executionId));
-        }
         if (audit) {
             await audit.record(`flow.cancelled.${row.flowName}`, {
                 executionId,
                 flowName: row.flowName,
+                actor: opts?.actor ?? row.actor,
+                compensated: history.some((entry) => entry.step.startsWith('compensate:')),
             });
         }
     }
+    async function terminate(executionId, opts) {
+        return cancel(executionId, { actor: opts?.actor, skipCompensation: true });
+    }
+    async function runCompensations(executionId, row, flow, history) {
+        const completed = new Set(history.filter((entry) => entry.status === StepStatus.Completed).map((entry) => entry.step));
+        const compensable = [...flow.steps]
+            .reverse()
+            .filter((step) => {
+            return (step.type === FlowStepType.Capability &&
+                typeof step.compensate === 'string' &&
+                step.compensate.length > 0 &&
+                completed.has(step.name));
+        });
+        if (compensable.length === 0)
+            return;
+        // Compensations run as the verified initiating identity, never as the
+        // worker. A missing or invalid snapshot is recorded and left for operator
+        // review, matching the step path above.
+        const flowAuth = resolveFlowStepAuth(row);
+        if (!flowAuth) {
+            const at = new Date();
+            history.push(buildHistoryEntry('compensate', {
+                status: StepStatus.Failed,
+                error: 'Missing or invalid flow auth snapshot; compensations require a verified caller context',
+            }, at, at));
+            if (audit) {
+                await audit.record('flow.compensation_skipped', {
+                    executionId,
+                    flowName: row.flowName,
+                    reason: 'invalid-auth-snapshot',
+                    steps: compensable.map((step) => step.name),
+                });
+            }
+            return;
+        }
+        const ctx = {
+            auth: flowAuth,
+            data: config.createDataService ? config.createDataService(flowAuth) : {},
+            events: createEventService
+                ? createEventService(flowAuth)
+                : { emit: async () => undefined, emitMany: async () => undefined },
+            flows: {
+                start: async () => ({
+                    id: executionId,
+                    flowName: row.flowName,
+                    status: FlowStatus.Cancelled,
+                }),
+                resume: async () => undefined,
+                cancel: async () => undefined,
+                status: async () => ({ id: executionId, flowName: row.flowName, status: row.status }),
+            },
+            ai: {},
+            audit: audit ?? { record: async () => undefined },
+            errors: {},
+            logger: logger ?? { debug() { }, info() { }, warn() { }, error() { } },
+            time: { now: () => new Date() },
+            config: {},
+            security: {},
+            translations: { locale: 'en', t: (key) => key },
+            state: row.state,
+            flowId: executionId,
+        };
+        for (const step of compensable) {
+            const startedAt = new Date();
+            const result = await stepDeps.executeCapability(step.compensate, ctx, row.input);
+            const completedAt = new Date();
+            history.push(buildHistoryEntry(`compensate:${step.name}`, {
+                status: result.success ? StepStatus.Completed : StepStatus.Failed,
+                error: result.success
+                    ? undefined
+                    : typeof result.error === 'object' && result.error !== null
+                        ? JSON.stringify(result.error)
+                        : String(result.error),
+            }, startedAt, completedAt));
+            if (audit) {
+                await audit.record(`flow.compensated.${step.name}`, {
+                    executionId,
+                    flowName: row.flowName,
+                    sourceStep: step.name,
+                    compensation: step.compensate,
+                    outcome: result.success ? 'succeeded' : 'failed',
+                });
+            }
+        }
+    }
     /**
      * Get the current status of a flow execution.
      */
     async function status(executionId) {
-        const rows = await db
+        const rows = await storeFor(executionId)
             .select()
             .from(flowExecutionsTable)
             .where(eq(flowExecutionsTable.id, executionId))
@@ -820,7 +1097,7 @@ export function createFlowEngine(config) {
                     error: error ?? 'Unknown error',
                     tenantId: row?.tenantId,
                     actor: row?.actor,
-                    db,
+                    db: storeFor(executionId),
                 });
             }
             catch {
@@ -829,7 +1106,7 @@ export function createFlowEngine(config) {
         }
     }
     async function updateExecution(id, updates) {
-        await db
+        await storeFor(id)
             .update(flowExecutionsTable)
             .set({ ...updates, updatedAt: new Date() })
             .where(eq(flowExecutionsTable.id, id));
@@ -853,7 +1130,7 @@ export function createFlowEngine(config) {
      */
     async function markFailedFromRunner(executionId, error) {
         const message = error instanceof Error ? error.message : typeof error === 'string' ? error : 'Unknown error';
-        const result = await db
+        const result = await storeFor(executionId)
             .update(flowExecutionsTable)
             .set({
             status: FlowStatus.Failed,
@@ -884,13 +1161,77 @@ export function createFlowEngine(config) {
      * false if the lease was lost (0 rows affected).
      */
     async function guardedUpdate(id, updates) {
-        const result = await db
+        const result = await storeFor(id)
             .update(flowExecutionsTable)
             .set({ ...updates, updatedAt: new Date() })
             .where(and(eq(flowExecutionsTable.id, id), eq(flowExecutionsTable.leaseOwner, workerId)));
         const rowsAffected = getRowsAffected(result);
         return rowsAffected > 0;
     }
+    async function syncSpineAfterRun(executionId, result) {
+        if (!spineDispatch)
+            return;
+        const hint = claimedHints.get(executionId);
+        const tenantDb = executionStores.get(executionId);
+        if (!hint || !tenantDb)
+            return;
+        const nowIso = new Date().toISOString();
+        const flowRow = (await tenantDb
+            .select({ currentStep: flowExecutionsTable.currentStep })
+            .from(flowExecutionsTable)
+            .where(eq(flowExecutionsTable.id, executionId))
+            .limit(1))[0];
+        const nextStepId = flowRow?.currentStep ?? hint.stepId;
+        const terminal = result.status === FlowStatus.Completed ||
+            result.status === FlowStatus.Failed ||
+            result.status === FlowStatus.Cancelled;
+        const cas = await casAdvanceExecution(tenantDb, {
+            executionId,
+            expectedRevision: hint.expectedRevision,
+            nextStatus: terminal
+                ? result.status === FlowStatus.Completed
+                    ? 'succeeded'
+                    : result.status === FlowStatus.Cancelled
+                        ? 'cancelled'
+                        : 'failed'
+                : 'running',
+            nextStepId,
+            terminal,
+            nowIso,
+            sideEffectKey: `${executionId}:${hint.stepId}:${hint.expectedRevision}`,
+            sideEffectLabel: `${executionId}:${hint.stepId}`,
+        }, durableSchema);
+        await ackSpineDispatch(spineDispatch.db, hint.dispatchId);
+        claimedHints.delete(executionId);
+        if (cas !== 'ok' || terminal)
+            return;
+        const advanced = await loadExecutionState(tenantDb, executionId, durableSchema);
+        if (!advanced || advanced.terminal || !flowRow?.currentStep)
+            return;
+        const nextStep = flowRow.currentStep;
+        const outbox = await insertDispatchOutbox(tenantDb, advanced, nextStep, nowIso, durableSchema);
+        await publishOutboxToSpine(tenantDb, spineDispatch.db, outbox, `disp:${executionId}:${advanced.revision}`, nowIso, durableSchema);
+    }
+    async function applyDefinitionStrategy(executionId, strategy) {
+        assertSupportedDefinitionStrategy(strategy);
+        const rows = await storeFor(executionId)
+            .select()
+            .from(flowExecutionsTable)
+            .where(eq(flowExecutionsTable.id, executionId))
+            .limit(1);
+        const row = rows[0];
+        if (!row)
+            throw new Error(`Flow execution "${executionId}" not found`);
+        if (strategy === DefinitionInFlightStrategy.CompleteOnOriginal) {
+            restorePinFromRow(row);
+            return { strategy, applied: true };
+        }
+        if (!isTerminal(row.status)) {
+            await cancel(executionId);
+        }
+        await updateExecution(executionId, { lastError: DefinitionInFlightStrategy.StopAndRecover });
+        return { strategy: DefinitionInFlightStrategy.StopAndRecover, applied: true };
+    }
     return {
         start,
         runNext,
@@ -900,8 +1241,10 @@ export function createFlowEngine(config) {
         claimNext,
         claimExecution,
         cancel,
+        terminate,
         status,
         markFailedFromRunner,
+        applyDefinitionStrategy,
         get workerId() {
             return workerId;
         },