@fluidgrids/workflows 2026.1029.1 → 2026.1030.1

package/dist/{workflow-O6e64ZcG.d.cts → workflow-DS32Gtws.d.cts}

@@ -1,5 +1,5 @@
-import { J as Json, a as JsonObject, b as WorkflowInterface } from './types-Bb2wRnJ5.cjs';
-import { ai as WorkflowInfoSnapshot, R as RetryPolicy, d as ActivityCancellationType, x as Headers, P as ParentClosePolicy, C as ChildCancellationType, ac as VersioningBehavior, ah as WorkflowIdReusePolicy, ag as WorkflowIdConflictPolicy, b as RunRetryPolicy } from './types-CQKOhPTa.cjs';
+import { a as Json, J as JsonObject, b as WorkflowInterface } from './types-V7jEEUaL.cjs';
+import { M as Headers, e as RetryPolicy, i as ActivityCancellationType, b as WorkflowInfoSnapshot, P as ParentClosePolicy, C as ChildCancellationType, at as VersioningBehavior, ay as WorkflowIdReusePolicy, ax as WorkflowIdConflictPolicy, f as RunRetryPolicy } from './types-Bv2i4cBX.cjs';
 
 /**
  * Node operation descriptors: what a builder call needs to know about the node
@@ -86,6 +86,10 @@ declare const internalNodes: {
     readonly sendAndWait: Operation<Record<string, Json>, Json>;
     readonly codeWorkflow: Operation<Record<string, Json>, Json>;
     readonly waitForSignal: Operation<Record<string, Json>, Json>;
+    /** Phase C: signal another run (`fluidgrids.run-control`). */
+    readonly signalRun: Operation<Record<string, Json>, Json>;
+    /** Phase C: upsert the run's search attributes (`fluidgrids.search-attributes`). */
+    readonly setSearchAttributes: Operation<Record<string, Json>, Json>;
 };
 /** Node clients that need no registry: the internal nodes and `custom()`. */
 declare const nodes: {
@@ -116,6 +120,10 @@ declare const nodes: {
         readonly sendAndWait: Operation<Record<string, Json>, Json>;
         readonly codeWorkflow: Operation<Record<string, Json>, Json>;
         readonly waitForSignal: Operation<Record<string, Json>, Json>;
+        /** Phase C: signal another run (`fluidgrids.run-control`). */
+        readonly signalRun: Operation<Record<string, Json>, Json>;
+        /** Phase C: upsert the run's search attributes (`fluidgrids.search-attributes`). */
+        readonly setSearchAttributes: Operation<Record<string, Json>, Json>;
     };
     /**
      * Any node type, including ones the registry snapshot does not know. Typed
@@ -124,6 +132,145 @@ declare const nodes: {
     readonly custom: (nodeType: string, operation?: string, version?: string) => Operation<Record<string, Json>, Json>;
 };
 
+/**
+ * User activities (Phase C, 11 §2.2, §2.29, CWD9): functions a self-hosted
+ * worker runs for workflow code.
+ *
+ * - {@link declareActivity} names an activity and its default task queue. The
+ *   declaration is all workflow code needs: `ctx.activity(decl, { args })`
+ *   issues `SCHEDULE_ACTIVITY` of kind `user`.
+ * - {@link implementActivity} attaches the function to a declaration, for the
+ *   worker. {@link defineActivity} does both in one step.
+ * - {@link dynamicActivity} handles every activity name the worker has no
+ *   implementation for.
+ *
+ * Implementations belong to the worker, not to the workflow bundle: `lower()`
+ * reports `durable.activityImplInBundle` when a workflow module pulls one in.
+ *
+ * Pure JavaScript; declarations run inside the isolate.
+ */
+
+declare const ACTIVITY_MARKER = "fluidgrids.activity";
+declare const ACTIVITY_IMPL_MARKER = "fluidgrids.activity-impl";
+declare const ACTIVITY_TYPES: unique symbol;
+/** The name `*` a dynamic activity is registered under. */
+declare const DYNAMIC_ACTIVITY_NAME = "*";
+interface ActivityDeclarationOptions {
+    /** The task queue the activity runs on unless the call names another; default the workflow's. */
+    taskQueue?: string;
+    input?: SchemaLike;
+    output?: SchemaLike;
+    description?: string;
+}
+/** A declared user activity. */
+interface ActivityDefinition<In = Json, Out = Json> {
+    readonly __fluidgrids: typeof ACTIVITY_MARKER;
+    readonly name: string;
+    readonly options: ActivityDeclarationOptions;
+    /** Type-level only (functions, so any definition is assignable to the `never`/`unknown` one). */
+    readonly [ACTIVITY_TYPES]?: {
+        args: (args: In) => void;
+        result: () => Out;
+    };
+}
+/** What a running activity attempt knows. */
+interface ActivityInfo {
+    readonly runId: string;
+    readonly workspaceId?: string;
+    readonly workflowKey?: string;
+    readonly activityId: string;
+    /** The activity name (for a dynamic activity, the requested one). */
+    readonly activityName: string;
+    readonly taskQueue: string;
+    /** 1-based. */
+    readonly attempt: number;
+    /** Details the previous attempt recorded with `heartbeat` (11 §2.4). */
+    readonly heartbeatDetails?: Json;
+    readonly headers: Headers;
+}
+/** The context an activity function receives. */
+interface ActivityContext {
+    readonly info: ActivityInfo;
+    /**
+     * Record progress (at most 32 KiB of details, kept for the next attempt)
+     * and learn whether to stop. When the attempt was paused (`pauseActivity`,
+     * 11 §2.28) `paused` is true; the activity should then throw
+     * `ActivityPausedError`, which is not retried while the activity is paused.
+     */
+    heartbeat(details?: unknown): Promise<{
+        cancelRequested: boolean;
+        paused: boolean;
+    }>;
+    /** Aborted when the workflow requests cancellation or the worker shuts down. */
+    readonly cancellationSignal: AbortSignalLike;
+    /**
+     * Hand completion to an outside system (11 §2.2): returns a task token and
+     * ends this attempt without completing it. The outside system finishes it
+     * with `completeActivityAsync(token, result)` or the activity webhook.
+     */
+    completeAsync(): Promise<string>;
+    /** Credentials of a connection the activity declares (H2 rules apply on self-hosted workers). */
+    connection(name: string): Promise<Record<string, Json>>;
+}
+/** The part of `AbortSignal` activities may rely on. */
+interface AbortSignalLike {
+    readonly aborted: boolean;
+    readonly reason?: unknown;
+    addEventListener(type: 'abort', listener: () => void): void;
+    removeEventListener(type: 'abort', listener: () => void): void;
+}
+type ActivityFunction<In = Json, Out = Json> = (ctx: ActivityContext, args: In) => Out | Promise<Out>;
+/** A user activity's implementation, for a worker. */
+interface ActivityImplementation<In = Json, Out = Json> extends ActivityDefinition<In, Out> {
+    readonly implementation: typeof ACTIVITY_IMPL_MARKER;
+    readonly fn: ActivityFunction<In, Out>;
+    /** True for {@link dynamicActivity}: `fn` receives `(ctx, args)` for any name. */
+    readonly dynamic: boolean;
+}
+/** Throw a `TypeError` unless `name` is a valid activity name. */
+declare function checkActivityName(name: string): void;
+/** Throw a `TypeError` unless `queue` is a valid task queue name. */
+declare function checkTaskQueueName(queue: string, what?: string): void;
+/** Declare a user activity for workflow code. */
+declare function declareActivity<In = Json, Out = Json>(name: string, options?: ActivityDeclarationOptions): ActivityDefinition<In, Out>;
+/** Attach the worker-side function to a declaration. */
+declare function implementActivity<In, Out>(definition: ActivityDefinition<In, Out>, fn: ActivityFunction<In, Out>): ActivityImplementation<In, Out>;
+/** Declare and implement a user activity in one step. */
+declare function defineActivity<In = Json, Out = Json>(name: string, options: ActivityDeclarationOptions, fn: ActivityFunction<In, Out>): ActivityImplementation<In, Out>;
+declare function defineActivity<In = Json, Out = Json>(name: string, fn: ActivityFunction<In, Out>): ActivityImplementation<In, Out>;
+/**
+ * Handle every activity name the worker has no implementation for (11
+ * §2.29); `ctx.info.activityName` is the requested name.
+ */
+declare function dynamicActivity<Out = Json>(fn: ActivityFunction<Json, Out>, options?: Pick<ActivityDeclarationOptions, 'taskQueue' | 'description'>): ActivityImplementation<Json, Out>;
+/** True for a value made by {@link declareActivity} (or an implementation). */
+declare function isActivityDefinition(value: unknown): value is ActivityDefinition<never, unknown>;
+/** True for a value made by {@link implementActivity}, {@link defineActivity} or {@link dynamicActivity}. */
+declare function isActivityImplementation(value: unknown): value is ActivityImplementation<never, unknown>;
+/** An activity attempt is about to run its function. */
+interface ActivityExecuteInput {
+    args: Json;
+    readonly headers: Headers;
+    readonly info: ActivityInfo;
+}
+/** Interceptors around an activity's execution, on the worker (11 §2.10). */
+interface ActivityInboundInterceptor {
+    execute?(input: ActivityExecuteInput, next: (input: ActivityExecuteInput) => Promise<unknown>): Promise<unknown>;
+}
+/** Interceptors of what an activity issues, on the worker. */
+interface ActivityOutboundInterceptor {
+    heartbeat?(details: unknown, next: (details: unknown) => Promise<unknown>): Promise<unknown>;
+    getLogAttributes?(input: Record<string, Json>, next: (input: Record<string, Json>) => Record<string, Json>): Record<string, Json>;
+    getMetricTags?(input: Record<string, string>, next: (input: Record<string, string>) => Record<string, string>): Record<string, string>;
+}
+/** The implementation that serves `name`: an exact one, else a dynamic one. */
+declare function findActivityImplementation(implementations: readonly ActivityImplementation<never, unknown>[], name: string): ActivityImplementation<never, unknown> | undefined;
+/**
+ * Run one activity attempt through the inbound interceptors (first
+ * outermost). Workers and the test environment use it.
+ */
+declare function executeActivity(implementation: ActivityImplementation<never, unknown>, ctx: ActivityContext, args: Json, interceptors?: readonly ActivityInboundInterceptor[]): Promise<unknown>;
+
 /**
  * Signal, query and update definitions (spec 02 §4, 05). Signals work in Phase
  * B; queries and updates can be declared (they appear in the interface) but
@@ -204,7 +351,58 @@ interface RunOptions<In> {
     /** Overrides the node version the descriptor carries. */
     nodeVersion?: string;
     headers?: Headers;
+    /** Fairness within the queue (11 §2.11); default the workspace id. */
+    fairnessKey?: string;
+    /** 0.1 to 10; default 1. */
+    fairnessWeight?: number;
 }
+/**
+ * Options of `ctx.activity` (Phase C, user activities). The task queue is
+ * the option, else the declaration's, else the workflow's own queue.
+ */
+interface ActivityOptions<In> {
+    args: In;
+    taskQueue?: string;
+    /** Default: 1 s, x2, at most 100 s, unlimited attempts (Temporal's policy). */
+    retry?: Partial<RetryPolicy>;
+    startToCloseTimeout?: Duration;
+    scheduleToCloseTimeout?: Duration;
+    scheduleToStartTimeout?: Duration;
+    heartbeatTimeout?: Duration;
+    cancellationType?: ActivityCancellationType;
+    /** 1 (highest) to 5; default 3. */
+    priority?: number;
+    fairnessKey?: string;
+    fairnessWeight?: number;
+    /** Label in the History tab (at most 200 characters). */
+    summary?: string;
+    /** Connections the worker may resolve for this activity (at most 16, H2). */
+    connections?: string[];
+    headers?: Headers;
+}
+/** Options of `ctx.handleUpdate` and `ctx.setDefaultUpdateHandler` (05 §6, 11 §2.39). */
+interface UpdateHandlerOptions<Args> {
+    /**
+     * Runs before the update is accepted, without changing the run; throw to
+     * reject it (nothing is written to history and the caller gets the error).
+     * It is skipped when a replay re-delivers an update that history accepted.
+     */
+    validate?: (args: Args) => void;
+    /** Default `WARN_AND_ABANDON`. */
+    unfinishedPolicy?: HandlerUnfinishedPolicy;
+    description?: string;
+}
+/** Options of `ctx.setDefaultUpdateHandler`. */
+interface DefaultUpdateHandlerOptions {
+    validate?: (name: string, args: unknown) => void;
+    unfinishedPolicy?: HandlerUnfinishedPolicy;
+}
+/**
+ * Fire-and-forget calls to worker-side code (11 §2.31, self-hosted workers):
+ * `ctx.sinks.<sink>.<fn>(...args)`. Calls are reported once, when the task
+ * completes, never during replay or in a query. Managed runs ignore them.
+ */
+type WorkflowSinks = Readonly<Record<string, Readonly<Record<string, (...args: Json[]) => void>>>>;
 /** Options of `ctx.localActivity` (11 §2.12). */
 interface LocalActivityOptions<In> {
     args: In;
@@ -286,6 +484,9 @@ interface ChildOptions {
     idReusePolicy?: WorkflowIdReusePolicy;
     idConflictPolicy?: WorkflowIdConflictPolicy;
     headers?: Headers;
+    /** Fairness of the child's tasks (11 §2.11). */
+    fairnessKey?: string;
+    fairnessWeight?: number;
 }
 /** A started child run. */
 interface ChildHandle<Out = Json> {
@@ -437,10 +638,14 @@ interface WorkflowContext {
     onCancel(fn: () => void): void;
     isCancellation(error: unknown): boolean;
     saga(): Saga;
-    /** Resolves when no asynchronous signal handler is running; cancellation does not interrupt the wait. */
+    /** Resolves when no asynchronous signal or update handler is running; cancellation does not interrupt the wait. */
     allHandlersFinished(): Promise<void>;
-    /** Phase C: user activities. Throws `PhaseCFeatureError`. */
-    activity(...args: unknown[]): Promise<never>;
+    /**
+     * Run a user activity on a self-hosted worker (Phase C,
+     * `SCHEDULE_ACTIVITY` of kind `user`). Needs `fluidgrids.self-hosted-workers`;
+     * the `managed` queue refuses user activities.
+     */
+    activity<In, Out>(activity: ActivityDefinition<In, Out> | string, options: ActivityOptions<In>): Promise<Out>;
     /**
      * Run a short, idempotent node operation inside the workflow task (11
      * §2.12): the worker that runs the task executes it and the task records one
@@ -452,12 +657,31 @@ interface WorkflowContext {
      */
     localActivity<In, Out>(operation: Operation<In, Out>, options: LocalActivityOptions<In>): Promise<Out>;
     localActivity(fn: (...args: never[]) => unknown, options?: unknown): Promise<never>;
-    /** Phase C: custom queries. Throws `PhaseCFeatureError`. */
-    handleQuery(...args: unknown[]): void;
-    /** Phase C: updates. Throws `PhaseCFeatureError`. */
-    handleUpdate(...args: unknown[]): void;
-    /** Phase C: search attributes. Throws `PhaseCFeatureError`. */
-    upsertSearchAttributes(...args: unknown[]): void;
+    /**
+     * Answer a custom query (Phase C): `handler` runs after the history is
+     * replayed and must return a value without changing the run (commands and
+     * sinks throw `QueryHandlerSideEffect`).
+     */
+    handleQuery<Result, Args>(query: QueryDefinition<Result, Args> | string, handler: (args: Args) => Result): void;
+    /** Answer queries no handler takes (Phase C). */
+    setDefaultQueryHandler(handler: (name: string, args: unknown) => unknown): void;
+    /**
+     * Handle an update (Phase C, 05 §6): `validate` may reject it (no history),
+     * the handler's result or failure completes it (`UPDATE_COMPLETED`). The
+     * handler may await activities, timers and children.
+     */
+    handleUpdate<Args, Result>(update: UpdateDefinition<Args, Result> | string, handler: (args: Args) => Result | Promise<Result>, options?: UpdateHandlerOptions<Args>): void;
+    /** Handle updates no handler takes (Phase C, 11 §2.29). */
+    setDefaultUpdateHandler(handler: (name: string, args: unknown) => unknown, options?: DefaultUpdateHandlerOptions): void;
+    setDefaultUpdateHandler(options: DefaultUpdateHandlerOptions, handler: (name: string, args: unknown) => unknown): void;
+    /**
+     * Upsert the run's search attributes (Phase C, 11 §2.8,
+     * `UPSERT_SEARCH_ATTRIBUTES`); a null value removes one. The service
+     * validates the values against the workspace definitions.
+     */
+    upsertSearchAttributes(attributes: JsonObject): void;
+    /** Worker-side sinks (Phase C, self-hosted workers). */
+    readonly sinks: WorkflowSinks;
 }
 
 /**
@@ -491,10 +715,20 @@ interface DurableWorkflowOptions {
     input?: SchemaLike;
     output?: SchemaLike;
     signals?: ReadonlyArray<SignalDefinition<never> | SignalDefinition<unknown>>;
-    /** Declared only; handlers are Phase C. */
+    /** Declared queries; `ctx.handleQuery` answers them (Phase C). */
     queries?: ReadonlyArray<QueryDefinition<unknown, unknown>>;
-    /** Declared only; handlers are Phase C. */
+    /** Declared updates; `ctx.handleUpdate` handles them (Phase C). */
     updates?: ReadonlyArray<UpdateDefinition<unknown, unknown>>;
+    /**
+     * Accept names the interface does not declare (11 §2.29), written as
+     * `interface.open`. `lower()` also sets a kind open when the declaring
+     * module registers a default handler for it.
+     */
+    open?: {
+        signals?: boolean;
+        queries?: boolean;
+        updates?: boolean;
+    };
     /** Default `managed`. */
     taskQueue?: string;
     /** Lowers to the trigger node of the standalone workflow (default `internal:api`). */
@@ -526,10 +760,23 @@ interface DurableWorkflow<In = Json, Out = Json> {
     readonly name: string;
     readonly options: DurableWorkflowOptions;
     readonly fn: (ctx: WorkflowContext, input: In) => Promise<Out>;
+    /**
+     * True for {@link dynamicWorkflow}: it serves every function name the
+     * bundle does not export (`code.exports.workflows["*"]`, 11 §2.29).
+     */
+    readonly dynamic?: boolean;
 }
 /** Declare a tier-2 workflow. `name` is its workflow key when it is standalone. */
 declare function workflow<In = Json, Out = Json>(name: string, options: DurableWorkflowOptions, fn: (ctx: WorkflowContext, input: In) => Promise<Out>): DurableWorkflow<In, Out>;
 declare function workflow<In = Json, Out = Json>(name: string, fn: (ctx: WorkflowContext, input: In) => Promise<Out>): DurableWorkflow<In, Out>;
+/**
+ * Declare a dynamic workflow (Phase C, 11 §2.29): it runs for every
+ * `workflowFn` the bundle does not export, and receives the requested name.
+ * `lower()` writes it to `code.exports.workflows["*"]`, so a start or a child
+ * naming any function of the workflow key reaches it. One per bundle.
+ */
+declare function dynamicWorkflow<Out = Json>(name: string, options: DurableWorkflowOptions, fn: (ctx: WorkflowContext, workflowFn: string, input: Json) => Promise<Out>): DurableWorkflow<Json, Out>;
+declare function dynamicWorkflow<Out = Json>(name: string, fn: (ctx: WorkflowContext, workflowFn: string, input: Json) => Promise<Out>): DurableWorkflow<Json, Out>;
 /** True for a value made by {@link workflow}. */
 declare function isDurableWorkflow(value: unknown): value is DurableWorkflow<never, unknown>;
 /** The JSON Schema of a {@link SchemaLike}, or undefined when it has none. */
@@ -553,4 +800,4 @@ declare function runRetryPolicyOf(retry: WorkflowRetryOptions): RunRetryPolicy;
  */
 declare function continueAsNewRetryOf(retry: WorkflowRetryOptions | LegacyContinueAsNewRetry): RunRetryPolicy | RetryPolicy;
 
-export { isDurableWorkflow as A, isOperation as B, type CancellationScope as C, DURABLE_MARKER as D, type ExternalRunHandle as E, type FileRef as F, jsonSchemaOf as G, type HandlerUnfinishedPolicy as H, nodes as I, op as J, runRetryPolicyOf as K, type LegacyContinueAsNewRetry as L, MAX_WORKFLOW_TASK_TIMEOUT_MS as M, toMs as N, type Operation as O, trigger as P, type QueryDefinition as Q, type RunOptions as R, type Saga as S, type TriggerOperation as T, type UpdateDefinition as U, triggers as V, type WorkflowContext as W, workflow as X, type CancellationScopeFunction as a, type CancellationScopeOptions as b, type ChildHandle as c, type ChildOptions as d, type ChildTarget as e, type ContinueAsNewOptions as f, type DefinitionOptions as g, type DurableWorkflow as h, type DurableWorkflowOptions as i, type Duration as j, type ExternalRunTarget as k, type LocalActivityOptions as l, type SchemaLike as m, type SignalDefinition as n, type SignalHandlerOptions as o, type TriggerSpec as p, type WorkflowIdTarget as q, type WorkflowInfo as r, type WorkflowLogger as s, type WorkflowRetryOptions as t, continueAsNewRetryOf as u, defineQuery as v, defineSignal as w, defineUpdate as x, interfaceOf as y, internalNodes as z };
+export { continueAsNewRetryOf as $, ACTIVITY_IMPL_MARKER as A, type SchemaLike as B, type CancellationScope as C, DURABLE_MARKER as D, type ExternalRunHandle as E, type FileRef as F, type SignalDefinition as G, type HandlerUnfinishedPolicy as H, type SignalHandlerOptions as I, type TriggerSpec as J, type UpdateHandlerOptions as K, type LegacyContinueAsNewRetry as L, MAX_WORKFLOW_TASK_TIMEOUT_MS as M, type WorkflowIdTarget as N, type Operation as O, type WorkflowInfo as P, type QueryDefinition as Q, type RunOptions as R, type Saga as S, type TriggerOperation as T, type UpdateDefinition as U, type WorkflowLogger as V, type WorkflowContext as W, type WorkflowRetryOptions as X, type WorkflowSinks as Y, checkActivityName as Z, checkTaskQueueName as _, ACTIVITY_MARKER as a, declareActivity as a0, defineActivity as a1, defineQuery as a2, defineSignal as a3, defineUpdate as a4, dynamicActivity as a5, dynamicWorkflow as a6, executeActivity as a7, findActivityImplementation as a8, implementActivity as a9, interfaceOf as aa, internalNodes as ab, isActivityDefinition as ac, isActivityImplementation as ad, isDurableWorkflow as ae, isOperation as af, jsonSchemaOf as ag, nodes as ah, op as ai, runRetryPolicyOf as aj, toMs as ak, trigger as al, triggers as am, workflow as an, type AbortSignalLike as b, type ActivityContext as c, type ActivityDeclarationOptions as d, type ActivityDefinition as e, type ActivityExecuteInput as f, type ActivityFunction as g, type ActivityImplementation as h, type ActivityInboundInterceptor as i, type ActivityInfo as j, type ActivityOptions as k, type ActivityOutboundInterceptor as l, type CancellationScopeFunction as m, type CancellationScopeOptions as n, type ChildHandle as o, type ChildOptions as p, type ChildTarget as q, type ContinueAsNewOptions as r, DYNAMIC_ACTIVITY_NAME as s, type DefaultUpdateHandlerOptions as t, type DefinitionOptions as u, type DurableWorkflow as v, type DurableWorkflowOptions as w, type Duration as x, type ExternalRunTarget as y, type LocalActivityOptions as z };

package/fixtures/histories/activity-options-updated.history.json

@@ -0,0 +1,159 @@
+{
+  "format": "fluidgrids.history",
+  "formatVersion": 1,
+  "name": "activity-options-updated",
+  "description": "updateActivityOptions changes the retry policy of a pending activity in place (ACTIVITY_OPTIONS_UPDATED); replay is unaffected.",
+  "source": "src/phase-c-control.ts",
+  "info": {
+    "workspaceId": "test-workspace",
+    "taskQueue": "managed",
+    "attempt": 1,
+    "startedAt": "2026-01-01T00:00:00.000Z",
+    "runStartedAt": "2026-01-01T00:00:00.000Z",
+    "runId": "run-1"
+  },
+  "nowMs": 1767225600000,
+  "workflowFn": "controlled",
+  "events": [
+    {
+      "seq": 1,
+      "type": "WORKFLOW_STARTED",
+      "payload": {
+        "workflowFn": "controlled",
+        "input": null,
+        "taskQueue": "managed",
+        "randomnessSeed": "run-1"
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z"
+    },
+    {
+      "seq": 2,
+      "type": "WORKFLOW_TASK_SCHEDULED",
+      "payload": {
+        "taskId": "run-1-task-1"
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z"
+    },
+    {
+      "seq": 3,
+      "type": "WORKFLOW_TASK_STARTED",
+      "payload": {
+        "taskId": "run-1-task-1",
+        "attempt": 1
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z"
+    },
+    {
+      "seq": 4,
+      "type": "WORKFLOW_TASK_COMPLETED",
+      "payload": {
+        "taskId": "run-1-task-1"
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z",
+      "taskId": "run-1-task-1"
+    },
+    {
+      "seq": 5,
+      "type": "ACTIVITY_SCHEDULED",
+      "payload": {
+        "activityId": "a1",
+        "kind": "node",
+        "nodeType": "internal:http",
+        "operation": "execute",
+        "args": {
+          "url": "https://example.test/flaky"
+        },
+        "retry": {
+          "retryDelay": 1000,
+          "backoffMultiplier": 2,
+          "maxDelay": 100000,
+          "maxRetries": 5
+        }
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z",
+      "taskId": "run-1-task-1"
+    },
+    {
+      "seq": 6,
+      "type": "ACTIVITY_OPTIONS_UPDATED",
+      "payload": {
+        "activityId": "a1",
+        "options": {
+          "retry": {
+            "retryDelay": 5000,
+            "maxRetries": 2
+          }
+        }
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z"
+    },
+    {
+      "seq": 7,
+      "type": "ACTIVITY_STARTED",
+      "payload": {
+        "activityId": "a1",
+        "attempt": 1
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z"
+    },
+    {
+      "seq": 8,
+      "type": "ACTIVITY_COMPLETED",
+      "payload": {
+        "activityId": "a1",
+        "attempt": 1,
+        "result": {
+          "status": 200,
+          "url": "https://example.test/flaky"
+        }
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z"
+    },
+    {
+      "seq": 9,
+      "type": "WORKFLOW_TASK_SCHEDULED",
+      "payload": {
+        "taskId": "run-1-task-2"
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z"
+    },
+    {
+      "seq": 10,
+      "type": "WORKFLOW_TASK_STARTED",
+      "payload": {
+        "taskId": "run-1-task-2",
+        "attempt": 1
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z"
+    },
+    {
+      "seq": 11,
+      "type": "WORKFLOW_TASK_COMPLETED",
+      "payload": {
+        "taskId": "run-1-task-2"
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z",
+      "taskId": "run-1-task-2"
+    },
+    {
+      "seq": 12,
+      "type": "WORKFLOW_COMPLETED",
+      "payload": {
+        "output": {
+          "first": {
+            "status": 200,
+            "url": "https://example.test/flaky"
+          }
+        }
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z",
+      "taskId": "run-1-task-2"
+    }
+  ],
+  "expected": {
+    "protocol": 1,
+    "outcome": "commands",
+    "commands": [],
+    "logs": []
+  }
+}

package/fixtures/histories/activity-paused-unpaused.history.json

@@ -0,0 +1,160 @@
+{
+  "format": "fluidgrids.history",
+  "formatVersion": 1,
+  "name": "activity-paused-unpaused",
+  "description": "An operator pauses and unpauses an activity between its attempts (ACTIVITY_PAUSED, ACTIVITY_UNPAUSED); the workflow sees only the result.",
+  "source": "src/phase-c-control.ts",
+  "info": {
+    "workspaceId": "test-workspace",
+    "taskQueue": "managed",
+    "attempt": 1,
+    "startedAt": "2026-01-01T00:00:00.000Z",
+    "runStartedAt": "2026-01-01T00:00:00.000Z",
+    "runId": "run-1"
+  },
+  "nowMs": 1767225601000,
+  "workflowFn": "controlled",
+  "events": [
+    {
+      "seq": 1,
+      "type": "WORKFLOW_STARTED",
+      "payload": {
+        "workflowFn": "controlled",
+        "input": null,
+        "taskQueue": "managed",
+        "randomnessSeed": "run-1"
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z"
+    },
+    {
+      "seq": 2,
+      "type": "WORKFLOW_TASK_SCHEDULED",
+      "payload": {
+        "taskId": "run-1-task-1"
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z"
+    },
+    {
+      "seq": 3,
+      "type": "WORKFLOW_TASK_STARTED",
+      "payload": {
+        "taskId": "run-1-task-1",
+        "attempt": 1
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z"
+    },
+    {
+      "seq": 4,
+      "type": "WORKFLOW_TASK_COMPLETED",
+      "payload": {
+        "taskId": "run-1-task-1"
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z",
+      "taskId": "run-1-task-1"
+    },
+    {
+      "seq": 5,
+      "type": "ACTIVITY_SCHEDULED",
+      "payload": {
+        "activityId": "a1",
+        "kind": "node",
+        "nodeType": "internal:http",
+        "operation": "execute",
+        "args": {
+          "url": "https://example.test/flaky"
+        },
+        "retry": {
+          "retryDelay": 1000,
+          "backoffMultiplier": 2,
+          "maxDelay": 100000,
+          "maxRetries": 5
+        }
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z",
+      "taskId": "run-1-task-1"
+    },
+    {
+      "seq": 6,
+      "type": "ACTIVITY_PAUSED",
+      "payload": {
+        "activityId": "a1",
+        "reason": "downstream outage"
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z"
+    },
+    {
+      "seq": 7,
+      "type": "ACTIVITY_UNPAUSED",
+      "payload": {
+        "activityId": "a1"
+      },
+      "createdAt": "2026-01-01T00:00:00.000Z"
+    },
+    {
+      "seq": 8,
+      "type": "ACTIVITY_STARTED",
+      "payload": {
+        "activityId": "a1",
+        "attempt": 2
+      },
+      "createdAt": "2026-01-01T00:00:01.000Z"
+    },
+    {
+      "seq": 9,
+      "type": "ACTIVITY_COMPLETED",
+      "payload": {
+        "activityId": "a1",
+        "attempt": 2,
+        "result": {
+          "status": 200
+        }
+      },
+      "createdAt": "2026-01-01T00:00:01.000Z"
+    },
+    {
+      "seq": 10,
+      "type": "WORKFLOW_TASK_SCHEDULED",
+      "payload": {
+        "taskId": "run-1-task-2"
+      },
+      "createdAt": "2026-01-01T00:00:01.000Z"
+    },
+    {
+      "seq": 11,
+      "type": "WORKFLOW_TASK_STARTED",
+      "payload": {
+        "taskId": "run-1-task-2",
+        "attempt": 1
+      },
+      "createdAt": "2026-01-01T00:00:01.000Z"
+    },
+    {
+      "seq": 12,
+      "type": "WORKFLOW_TASK_COMPLETED",
+      "payload": {
+        "taskId": "run-1-task-2"
+      },
+      "createdAt": "2026-01-01T00:00:01.000Z",
+      "taskId": "run-1-task-2"
+    },
+    {
+      "seq": 13,
+      "type": "WORKFLOW_COMPLETED",
+      "payload": {
+        "output": {
+          "first": {
+            "status": 200
+          }
+        }
+      },
+      "createdAt": "2026-01-01T00:00:01.000Z",
+      "taskId": "run-1-task-2"
+    }
+  ],
+  "expected": {
+    "protocol": 1,
+    "outcome": "commands",
+    "commands": [],
+    "logs": []
+  }
+}