@fluidgrids/workflows 2026.1028.2 → 2026.1029.1

package/dist/{file-yuPCFU5b.d.ts → file-olQudcx5.d.ts}

@@ -1,5 +1,5 @@
-import { E as ErrorType, a as Json, J as JsonObject } from './types-BGoPzgcl.js';
-import { d as BuiltInQueryName, m as CommandType, W as WorkflowCommand, F as Failure, P as ParentClosePolicy, T as RunEventDraft, a as WorkflowTaskFailureCause, U as RunEventRecord, v as HISTORY_PROTOCOL, a6 as WorkflowInfoSnapshot, a8 as WorkflowTaskResult } from './types-DV-HX_Gt.js';
+import { E as ErrorType, J as Json, a as JsonObject } from './types-Bb2wRnJ5.js';
+import { e as BuiltInQueryName, W as WorkflowCommand, n as CommandType, F as Failure, P as ParentClosePolicy, Y as RunEventDraft, a as WorkflowTaskFailureCause, Z as RunEventRecord, w as HISTORY_PROTOCOL, ai as WorkflowInfoSnapshot, ak as WorkflowTaskResult } from './types-CnIOinoz.js';
 
 declare const RUN_EVENT_SCHEMA_ID = "https://docs.fluidgrids.ai/schemas/run-event.schema.json";
 declare const WORKFLOW_COMMAND_SCHEMA_ID = "https://docs.fluidgrids.ai/schemas/workflow-command.schema.json";
@@ -123,6 +123,7 @@ declare const RUN_EVENT_SCHEMA: {
             }, {
                 readonly type: "object";
                 readonly required: readonly ["workflowKey", "workflowId"];
+                readonly description: "The open run of a workflow id, following its continue-as-new chain; firstRunId pins the chain (R2).";
                 readonly properties: {
                     readonly workflowKey: {
                         readonly type: "string";
@@ -134,10 +135,70 @@ declare const RUN_EVENT_SCHEMA: {
                         readonly minLength: 1;
                         readonly maxLength: 256;
                     };
+                    readonly firstRunId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 256;
+                    };
                 };
                 readonly additionalProperties: false;
             }];
         };
+        readonly runRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["initialDelayMs"];
+            readonly description: "Run-level retry (11 §2.17), in milliseconds. maxAttempts counts every attempt; absent means unlimited, bounded by the execution timeout.";
+            readonly properties: {
+                readonly maxAttempts: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly initialDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+                readonly maxDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly enum: readonly ErrorType[];
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly timeouts: {
+            readonly type: "object";
+            readonly description: "The three workflow timeouts (11 §2.20), in milliseconds.";
+            readonly properties: {
+                readonly executionTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly runTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+            };
+            readonly additionalProperties: false;
+        };
         readonly childOptions: {
             readonly type: "object";
             readonly required: readonly ["parentClosePolicy"];
@@ -189,8 +250,81 @@ declare const RUN_EVENT_SCHEMA: {
                     readonly type: "integer";
                     readonly minimum: 0;
                 };
+                readonly retry: {
+                    readonly $ref: "#/$defs/runRetryPolicy";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
+                readonly idReusePolicy: {
+                    readonly enum: readonly ["ALLOW_DUPLICATE", "ALLOW_DUPLICATE_FAILED_ONLY", "REJECT_DUPLICATE"];
+                };
+                readonly idConflictPolicy: {
+                    readonly enum: readonly ["FAIL", "USE_EXISTING", "TERMINATE_EXISTING"];
+                };
             };
         };
+        readonly legacyCanRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["retryDelay"];
+            readonly description: "The R1 activity-shaped CONTINUE_AS_NEW retry: whatever explicitRetryPolicy wrote from a Partial<RetryPolicy>, so numbers carry no integer or minimum constraint. It never had a meaning, and the service ignores it.";
+            readonly properties: {
+                readonly maxRetries: {
+                    readonly type: "number";
+                };
+                readonly retryDelay: {
+                    readonly type: "number";
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                };
+                readonly maxDelay: {
+                    readonly type: "number";
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly canOptions: {
+            readonly type: "object";
+            readonly description: "Options of a CONTINUE_AS_NEW command (C-SCHEMA, frozen in R2). retry is the R2 run-retry policy of the new run, or the R1 activity shape (retryDelay, maxRetries, maxDelay) that R1 bundles wrote and R2 bundles still write for that shape: it never had a meaning, and the service ignores it instead of reading it as a run-retry policy.";
+            readonly properties: {
+                readonly taskQueue: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly retry: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/$defs/runRetryPolicy";
+                    }, {
+                        readonly $ref: "#/$defs/legacyCanRetryPolicy";
+                    }];
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly context: {
+                    readonly type: "object";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
+            };
+            readonly additionalProperties: false;
+        };
         readonly headers: {
             readonly type: "object";
             readonly additionalProperties: {
@@ -360,6 +494,7 @@ declare const WORKFLOW_COMMAND_SCHEMA: {
             }, {
                 readonly type: "object";
                 readonly required: readonly ["workflowKey", "workflowId"];
+                readonly description: "The open run of a workflow id, following its continue-as-new chain; firstRunId pins the chain (R2).";
                 readonly properties: {
                     readonly workflowKey: {
                         readonly type: "string";
@@ -371,10 +506,70 @@ declare const WORKFLOW_COMMAND_SCHEMA: {
                         readonly minLength: 1;
                         readonly maxLength: 256;
                     };
+                    readonly firstRunId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 256;
+                    };
                 };
                 readonly additionalProperties: false;
             }];
         };
+        readonly runRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["initialDelayMs"];
+            readonly description: "Run-level retry (11 §2.17), in milliseconds. maxAttempts counts every attempt; absent means unlimited, bounded by the execution timeout.";
+            readonly properties: {
+                readonly maxAttempts: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly initialDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+                readonly maxDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly enum: readonly ErrorType[];
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly timeouts: {
+            readonly type: "object";
+            readonly description: "The three workflow timeouts (11 §2.20), in milliseconds.";
+            readonly properties: {
+                readonly executionTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly runTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+            };
+            readonly additionalProperties: false;
+        };
         readonly childOptions: {
             readonly type: "object";
             readonly required: readonly ["parentClosePolicy"];
@@ -426,7 +621,80 @@ declare const WORKFLOW_COMMAND_SCHEMA: {
                     readonly type: "integer";
                     readonly minimum: 0;
                 };
+                readonly retry: {
+                    readonly $ref: "#/$defs/runRetryPolicy";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
+                readonly idReusePolicy: {
+                    readonly enum: readonly ["ALLOW_DUPLICATE", "ALLOW_DUPLICATE_FAILED_ONLY", "REJECT_DUPLICATE"];
+                };
+                readonly idConflictPolicy: {
+                    readonly enum: readonly ["FAIL", "USE_EXISTING", "TERMINATE_EXISTING"];
+                };
+            };
+        };
+        readonly legacyCanRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["retryDelay"];
+            readonly description: "The R1 activity-shaped CONTINUE_AS_NEW retry: whatever explicitRetryPolicy wrote from a Partial<RetryPolicy>, so numbers carry no integer or minimum constraint. It never had a meaning, and the service ignores it.";
+            readonly properties: {
+                readonly maxRetries: {
+                    readonly type: "number";
+                };
+                readonly retryDelay: {
+                    readonly type: "number";
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                };
+                readonly maxDelay: {
+                    readonly type: "number";
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly canOptions: {
+            readonly type: "object";
+            readonly description: "Options of a CONTINUE_AS_NEW command (C-SCHEMA, frozen in R2). retry is the R2 run-retry policy of the new run, or the R1 activity shape (retryDelay, maxRetries, maxDelay) that R1 bundles wrote and R2 bundles still write for that shape: it never had a meaning, and the service ignores it instead of reading it as a run-retry policy.";
+            readonly properties: {
+                readonly taskQueue: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly retry: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/$defs/runRetryPolicy";
+                    }, {
+                        readonly $ref: "#/$defs/legacyCanRetryPolicy";
+                    }];
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly context: {
+                    readonly type: "object";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
             };
+            readonly additionalProperties: false;
         };
         readonly headers: {
             readonly type: "object";
@@ -561,10 +829,17 @@ declare const WORKFLOW_TASK_SCHEMA: {
                 readonly businessId: {
                     readonly type: "string";
                 };
+                readonly workflowId: {
+                    readonly type: "string";
+                };
                 readonly attempt: {
                     readonly type: "integer";
                     readonly minimum: 1;
                 };
+                readonly runAttempt: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
                 readonly taskQueue: {
                     readonly type: "string";
                 };
@@ -628,8 +903,72 @@ declare const WORKFLOW_TASK_SCHEMA: {
                 readonly context: {
                     readonly type: "object";
                 };
+                readonly memo: {
+                    readonly type: "object";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
+                readonly retry: {
+                    readonly $ref: "#/$defs/runRetryPolicy";
+                };
             };
         };
+        readonly localActivityRequest: {
+            readonly type: "object";
+            readonly required: readonly ["localActivityId", "kind", "nodeType", "operation", "args", "retry", "startToCloseTimeout", "attempt", "backoffMs"];
+            readonly description: "R2: a local activity the task needs (11 §2.12). Run attempt `attempt` after waiting backoffMs, then run the same task again with the outcome in localActivityResults.";
+            readonly properties: {
+                readonly localActivityId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly kind: {
+                    readonly const: "node";
+                };
+                readonly nodeType: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly nodeVersion: {
+                    readonly type: "string";
+                };
+                readonly operation: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly args: {};
+                readonly connection: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly retry: {
+                    readonly $ref: "#/$defs/retryPolicy";
+                };
+                readonly startToCloseTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly maximum: 30000;
+                };
+                readonly attempt: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly backoffMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly summary: {
+                    readonly type: "string";
+                    readonly maxLength: 200;
+                };
+            };
+            readonly additionalProperties: false;
+        };
         readonly request: {
             readonly type: "object";
             readonly required: readonly ["protocol", "kind", "workflowFn", "info", "history", "nowMs"];
@@ -715,10 +1054,31 @@ declare const WORKFLOW_TASK_SCHEMA: {
                         readonly $ref: "#/$defs/command";
                     };
                 };
-                readonly localActivityRequests: {
+                readonly localActivityRequests: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/localActivityRequest";
+                    };
+                };
+                readonly unfinishedHandlers: {
                     readonly type: "array";
+                    readonly description: "R2: handlers still running when the terminal command was issued (11 §2.18); never set on replay.";
                     readonly items: {
                         readonly type: "object";
+                        readonly required: readonly ["kind", "name", "count"];
+                        readonly properties: {
+                            readonly kind: {
+                                readonly enum: readonly ["signal", "update"];
+                            };
+                            readonly name: {
+                                readonly type: "string";
+                            };
+                            readonly count: {
+                                readonly type: "integer";
+                                readonly minimum: 1;
+                            };
+                        };
+                        readonly additionalProperties: false;
                     };
                 };
                 readonly queryResults: {
@@ -894,6 +1254,7 @@ declare const WORKFLOW_TASK_SCHEMA: {
             }, {
                 readonly type: "object";
                 readonly required: readonly ["workflowKey", "workflowId"];
+                readonly description: "The open run of a workflow id, following its continue-as-new chain; firstRunId pins the chain (R2).";
                 readonly properties: {
                     readonly workflowKey: {
                         readonly type: "string";
@@ -905,10 +1266,70 @@ declare const WORKFLOW_TASK_SCHEMA: {
                         readonly minLength: 1;
                         readonly maxLength: 256;
                     };
+                    readonly firstRunId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 256;
+                    };
                 };
                 readonly additionalProperties: false;
             }];
         };
+        readonly runRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["initialDelayMs"];
+            readonly description: "Run-level retry (11 §2.17), in milliseconds. maxAttempts counts every attempt; absent means unlimited, bounded by the execution timeout.";
+            readonly properties: {
+                readonly maxAttempts: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly initialDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+                readonly maxDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly enum: readonly ErrorType[];
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly timeouts: {
+            readonly type: "object";
+            readonly description: "The three workflow timeouts (11 §2.20), in milliseconds.";
+            readonly properties: {
+                readonly executionTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly runTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+            };
+            readonly additionalProperties: false;
+        };
         readonly childOptions: {
             readonly type: "object";
             readonly required: readonly ["parentClosePolicy"];
@@ -960,7 +1381,80 @@ declare const WORKFLOW_TASK_SCHEMA: {
                     readonly type: "integer";
                     readonly minimum: 0;
                 };
+                readonly retry: {
+                    readonly $ref: "#/$defs/runRetryPolicy";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
+                readonly idReusePolicy: {
+                    readonly enum: readonly ["ALLOW_DUPLICATE", "ALLOW_DUPLICATE_FAILED_ONLY", "REJECT_DUPLICATE"];
+                };
+                readonly idConflictPolicy: {
+                    readonly enum: readonly ["FAIL", "USE_EXISTING", "TERMINATE_EXISTING"];
+                };
+            };
+        };
+        readonly legacyCanRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["retryDelay"];
+            readonly description: "The R1 activity-shaped CONTINUE_AS_NEW retry: whatever explicitRetryPolicy wrote from a Partial<RetryPolicy>, so numbers carry no integer or minimum constraint. It never had a meaning, and the service ignores it.";
+            readonly properties: {
+                readonly maxRetries: {
+                    readonly type: "number";
+                };
+                readonly retryDelay: {
+                    readonly type: "number";
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                };
+                readonly maxDelay: {
+                    readonly type: "number";
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly canOptions: {
+            readonly type: "object";
+            readonly description: "Options of a CONTINUE_AS_NEW command (C-SCHEMA, frozen in R2). retry is the R2 run-retry policy of the new run, or the R1 activity shape (retryDelay, maxRetries, maxDelay) that R1 bundles wrote and R2 bundles still write for that shape: it never had a meaning, and the service ignores it instead of reading it as a run-retry policy.";
+            readonly properties: {
+                readonly taskQueue: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly retry: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/$defs/runRetryPolicy";
+                    }, {
+                        readonly $ref: "#/$defs/legacyCanRetryPolicy";
+                    }];
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly context: {
+                    readonly type: "object";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
             };
+            readonly additionalProperties: false;
         };
         readonly headers: {
             readonly type: "object";
@@ -1093,10 +1587,17 @@ declare const HISTORY_FILE_SCHEMA: {
                 readonly businessId: {
                     readonly type: "string";
                 };
+                readonly workflowId: {
+                    readonly type: "string";
+                };
                 readonly attempt: {
                     readonly type: "integer";
                     readonly minimum: 1;
                 };
+                readonly runAttempt: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
                 readonly taskQueue: {
                     readonly type: "string";
                 };
@@ -1160,6 +1661,15 @@ declare const HISTORY_FILE_SCHEMA: {
                 readonly context: {
                     readonly type: "object";
                 };
+                readonly memo: {
+                    readonly type: "object";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
+                readonly retry: {
+                    readonly $ref: "#/$defs/runRetryPolicy";
+                };
             };
         };
         readonly json: {
@@ -1275,6 +1785,7 @@ declare const HISTORY_FILE_SCHEMA: {
             }, {
                 readonly type: "object";
                 readonly required: readonly ["workflowKey", "workflowId"];
+                readonly description: "The open run of a workflow id, following its continue-as-new chain; firstRunId pins the chain (R2).";
                 readonly properties: {
                     readonly workflowKey: {
                         readonly type: "string";
@@ -1286,10 +1797,70 @@ declare const HISTORY_FILE_SCHEMA: {
                         readonly minLength: 1;
                         readonly maxLength: 256;
                     };
+                    readonly firstRunId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 256;
+                    };
                 };
                 readonly additionalProperties: false;
             }];
         };
+        readonly runRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["initialDelayMs"];
+            readonly description: "Run-level retry (11 §2.17), in milliseconds. maxAttempts counts every attempt; absent means unlimited, bounded by the execution timeout.";
+            readonly properties: {
+                readonly maxAttempts: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly initialDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                    readonly minimum: 1;
+                };
+                readonly maxDelayMs: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly enum: readonly ErrorType[];
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly timeouts: {
+            readonly type: "object";
+            readonly description: "The three workflow timeouts (11 §2.20), in milliseconds.";
+            readonly properties: {
+                readonly executionTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly runTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+            };
+            readonly additionalProperties: false;
+        };
         readonly childOptions: {
             readonly type: "object";
             readonly required: readonly ["parentClosePolicy"];
@@ -1341,7 +1912,80 @@ declare const HISTORY_FILE_SCHEMA: {
                     readonly type: "integer";
                     readonly minimum: 0;
                 };
+                readonly retry: {
+                    readonly $ref: "#/$defs/runRetryPolicy";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
+                readonly idReusePolicy: {
+                    readonly enum: readonly ["ALLOW_DUPLICATE", "ALLOW_DUPLICATE_FAILED_ONLY", "REJECT_DUPLICATE"];
+                };
+                readonly idConflictPolicy: {
+                    readonly enum: readonly ["FAIL", "USE_EXISTING", "TERMINATE_EXISTING"];
+                };
+            };
+        };
+        readonly legacyCanRetryPolicy: {
+            readonly type: "object";
+            readonly required: readonly ["retryDelay"];
+            readonly description: "The R1 activity-shaped CONTINUE_AS_NEW retry: whatever explicitRetryPolicy wrote from a Partial<RetryPolicy>, so numbers carry no integer or minimum constraint. It never had a meaning, and the service ignores it.";
+            readonly properties: {
+                readonly maxRetries: {
+                    readonly type: "number";
+                };
+                readonly retryDelay: {
+                    readonly type: "number";
+                };
+                readonly backoffMultiplier: {
+                    readonly type: "number";
+                };
+                readonly maxDelay: {
+                    readonly type: "number";
+                };
+                readonly retryOnErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly nonRetryableErrorTypes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly canOptions: {
+            readonly type: "object";
+            readonly description: "Options of a CONTINUE_AS_NEW command (C-SCHEMA, frozen in R2). retry is the R2 run-retry policy of the new run, or the R1 activity shape (retryDelay, maxRetries, maxDelay) that R1 bundles wrote and R2 bundles still write for that shape: it never had a meaning, and the service ignores it instead of reading it as a run-retry policy.";
+            readonly properties: {
+                readonly taskQueue: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                };
+                readonly retry: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/$defs/runRetryPolicy";
+                    }, {
+                        readonly $ref: "#/$defs/legacyCanRetryPolicy";
+                    }];
+                };
+                readonly workflowTaskTimeout: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly context: {
+                    readonly type: "object";
+                };
+                readonly versioningBehavior: {
+                    readonly enum: readonly ["PINNED", "AUTO_UPGRADE"];
+                };
             };
+            readonly additionalProperties: false;
         };
         readonly headers: {
             readonly type: "object";
@@ -1354,7 +1998,19 @@ declare const HISTORY_FILE_SCHEMA: {
 /** File name and schema of every generated history schema. */
 declare const HISTORY_SCHEMA_FILES: ReadonlyArray<readonly [string, unknown]>;
 
-/** Command helpers shared by validation and the state machine; no schema code. */
+/**
+ * The command feature gate (C-GATE, frozen in SDK R2) and command helpers
+ * shared by validation and the state machine; no schema code.
+ *
+ * Every command needs one or more features. The service builds the set of
+ * features a workspace may use once per command batch, before it locks the
+ * run (in Phase B: {@link PHASE_B_CORE_FEATURES}, plus
+ * {@link PHASE_B_PARITY_FEATURES} when `fluidgrids.durable-parity` is on),
+ * and refuses a batch with a command whose features are not all enabled
+ * (`UNSUPPORTED_COMMAND`; the run stays RUNNING and heals when the flag is
+ * turned back on). Relief commands ({@link isReliefCommand}) answer work the
+ * service already granted and are never refused for a missing flag.
+ */
 
 /** One problem found in a command batch or a history. */
 interface HistoryIssue {
@@ -1365,18 +2021,101 @@ interface HistoryIssue {
     path?: string;
 }
 /**
- * True when the command is enabled: the Phase B core set always, the parity
- * set when `enabled` is `parity`, Phase C commands never.
+ * A feature a command may need (C-GATE).
+ *
+ * - `core`: the Phase B core command set.
+ * - `parity.can`: `CONTINUE_AS_NEW` (enabled in Phase B core).
+ * - `parity.context`: `UPSERT_CONTEXT` (enabled in Phase B core).
+ * - `parity.localActivity`: `RECORD_LOCAL_ACTIVITY`.
+ * - `parity.externalCancel`: `REQUEST_CANCEL_EXTERNAL_RUN` aimed at a run
+ *   that is not one of the run's own children.
+ * - `parity.childOptions`: the `START_CHILD_RUN` options new in R2
+ *   (anything outside {@link CORE_CHILD_OPTIONS}: `retry`,
+ *   `versioningBehavior`, `idReusePolicy`, `idConflictPolicy`).
+ * - `parity.canOptions`: the `CONTINUE_AS_NEW` options new in R2: a run-retry
+ *   `retry` and anything outside {@link CORE_CAN_OPTIONS}.
+ * - `parity.workflowIdTarget`: a `SIGNAL_RUN` or `REQUEST_CANCEL_EXTERNAL_RUN`
+ *   target given as `{ workflowKey, workflowId }`.
+ * - `c.*`: reserved for Phase C, never enabled in Phase B.
+ */
+type CommandFeature = 'core' | 'parity.can' | 'parity.context' | 'parity.localActivity' | 'parity.externalCancel' | 'parity.childOptions' | 'parity.canOptions' | 'parity.workflowIdTarget' | 'c.updates' | 'c.searchAttributes' | 'c.userActivity';
+/** Every feature, in a stable order. */
+declare const COMMAND_FEATURES: readonly CommandFeature[];
+/** The features of the Phase B core release (what the service enables without the parity flag). */
+declare const PHASE_B_CORE_FEATURES: ReadonlySet<CommandFeature>;
+/** Every Phase B feature: the core set plus what `fluidgrids.durable-parity` enables. */
+declare const PHASE_B_PARITY_FEATURES: ReadonlySet<CommandFeature>;
+/**
+ * Child options a Phase B core child may carry: every option the R1 runtime
+ * already wrote into `START_CHILD_RUN` and the Phase B service accepted (it
+ * stored or ignored them). Only the options new in R2 (`retry`,
+ * `versioningBehavior`, `idReusePolicy`, `idConflictPolicy`) need
+ * `parity.childOptions`, so a Phase B workflow behaves the same with the
+ * parity flag off.
+ */
+declare const CORE_CHILD_OPTIONS: ReadonlySet<string>;
+/**
+ * Continue-as-new options a Phase B core command may carry: every option the
+ * R1 runtime wrote. `retry` is core only in its R1 (activity) shape, which the
+ * Phase B service ignores ({@link continueAsNewRetryShape}); the R2 run-retry
+ * shape needs `parity.canOptions`.
+ */
+declare const CORE_CAN_OPTIONS: ReadonlySet<string>;
+/**
+ * The shape of `CONTINUE_AS_NEW` `options.retry` (C-SCHEMA `canOptions`):
+ *
+ * - `run`: the R2 run-retry policy (`initialDelayMs`, `maxAttempts`, ...),
+ *   which the service applies to the new run (11 §2.17);
+ * - `legacy`: the R1 activity shape (`retryDelay`, `maxRetries`, `maxDelay`)
+ *   that R1 bundles and histories carry. It never had a meaning: the Phase B
+ *   service ignored it, and the service must keep ignoring it rather than
+ *   read it as a run-retry policy;
+ * - `none`: no retry option.
+ *
+ * A value with keys of both shapes, or of neither, is `invalid`; the command
+ * schema refuses it.
+ */
+declare function continueAsNewRetryShape(options: Readonly<Record<string, unknown>>): 'run' | 'legacy' | 'none' | 'invalid';
+/** The features `command` needs, without duplicates, in {@link COMMAND_FEATURES} order. */
+declare function commandFeatures(command: WorkflowCommand): CommandFeature[];
+/**
+ * Which commands are enabled: a feature set (C-GATE), or the deprecated
+ * release levels `core` and `parity`, which keep their R1 meaning (the type
+ * lists of `isCommandEnabled`, with a child-targeted cancel always enabled).
+ */
+type CommandGate = 'core' | 'parity' | ReadonlySet<CommandFeature>;
+/**
+ * True when the command type is enabled: the Phase B core set always, the
+ * parity set when `enabled` is `parity`, Phase C commands never.
+ *
+ * @deprecated Since R2; use {@link isWorkflowCommandEnabled} with a feature
+ * set. Kept for one release.
  */
 declare function isCommandEnabled(type: CommandType, enabled?: 'core' | 'parity'): boolean;
 /**
- * True when this command is enabled. Like {@link isCommandEnabled}, except
- * that `REQUEST_CANCEL_EXTERNAL_RUN` aimed at one of the run's own children
- * (`target.childId`) is core: it is how a cancelled scope cancels a child
- * (the default child cancellation type, spec 11 §2.5). Other targets stay
- * parity.
+ * True when every feature `command` needs is enabled. With a release level
+ * (`core`, `parity`) it answers as R1 did: the command type decides, and
+ * `REQUEST_CANCEL_EXTERNAL_RUN` aimed at one of the run's own children is
+ * core.
+ */
+declare function isWorkflowCommandEnabled(command: WorkflowCommand, enabled?: CommandGate): boolean;
+/** Why a command is refused by the gate, naming the missing features. */
+declare function unsupportedMessage(command: WorkflowCommand, enabled?: CommandGate): string;
+/** What the lease of the current workflow task already granted (C-LEASE). */
+interface CommandRelief {
+    /** Local activities the lease asked the worker to run (`localActivityRequested`). */
+    grantedLocalActivityIds: readonly string[];
+    /** Updates the lease delivered to the task (Phase C). */
+    deliveredUpdateIds: readonly string[];
+}
+/**
+ * True for a command that answers work the lease already granted: a
+ * `RECORD_LOCAL_ACTIVITY` of a granted local activity, or an update reply to
+ * a delivered update. Such commands are accepted even when the flag that
+ * enables new requests of their kind is off (BP7), so turning a flag off never
+ * strands work that was already started.
  */
-declare function isWorkflowCommandEnabled(command: WorkflowCommand, enabled?: 'core' | 'parity'): boolean;
+declare function isReliefCommand(command: WorkflowCommand, lease: CommandRelief): boolean;
 
 /**
  * The pure state machine of a durable-function run (DB3): what a command batch
@@ -1417,6 +2156,15 @@ interface ChildState {
     parentClosePolicy: ParentClosePolicy;
     initiatedSeq: number;
 }
+/** A local activity recorded in history (`LOCAL_ACTIVITY_COMPLETED` or `_FAILED`). */
+interface LocalActivityState {
+    status: 'COMPLETED' | 'FAILED';
+    attempts: number;
+    recordedSeq: number;
+    nodeType?: string;
+    operation?: string;
+    summary?: string;
+}
 interface ExternalState {
     kind: 'signal' | 'cancel';
     status: 'PENDING' | 'RESOLVED';
@@ -1447,6 +2195,7 @@ interface RunState {
     timers: Record<string, TimerState>;
     children: Record<string, ChildState>;
     externals: Record<string, ExternalState>;
+    localActivities: Record<string, LocalActivityState>;
     sideEffects: Record<string, Json>;
     markers: Record<string, Json>;
     signalsReceived: number;
@@ -1485,7 +2234,9 @@ interface EventsForCommandsContext {
     /** Task start time (the request's `nowMs`); timers fire at `nowMs + durationMs`. */
     nowMs: number;
     /** Which commands are enabled (see `validateCommands`). Default `core`. */
-    enabled?: 'core' | 'parity';
+    enabled?: CommandGate;
+    /** What the lease already granted; relief commands pass the gate (see `isReliefCommand`). */
+    relief?: CommandRelief;
 }
 type EventsForCommandsResult = {
     ok: true;
@@ -1554,4 +2305,4 @@ declare function createHistoryFile(workflowFn: string, events: RunEventRecord[],
 /** Serialise a history file the way the CLI and the fixtures write it. */
 declare function serializeHistoryFile(file: HistoryFile): string;
 
-export { type ActivityState as A, parseHistoryFile as B, type ChildState as C, pendingCounts as D, type EventsForCommandsContext as E, projectRunState as F, serializeHistoryFile as G, type HistoryIssue as H, taskCompletedEvents as I, utf8Bytes as J, RUN_EVENT_SCHEMA as R, type TimerState as T, WORKFLOW_COMMAND_SCHEMA as W, type ActivityStatus as a, type ChildStatus as b, type EventsForCommandsResult as c, type ExternalState as d, HISTORY_FILE_FORMAT as e, HISTORY_FILE_SCHEMA as f, HISTORY_FILE_SCHEMA_ID as g, HISTORY_SCHEMA_FILES as h, type HistoryFile as i, HistoryFileError as j, HistoryStateError as k, RUN_EVENT_SCHEMA_ID as l, type RunState as m, type RunStatus as n, WORKFLOW_COMMAND_SCHEMA_ID as o, WORKFLOW_TASK_SCHEMA as p, WORKFLOW_TASK_SCHEMA_ID as q, applyEvent as r, createHistoryFile as s, eventsForCommands as t, hasUnprocessedInput as u, initialRunState as v, isActivityOpen as w, isChildOpen as x, isCommandEnabled as y, isWorkflowCommandEnabled as z };
+export { type ActivityState as A, continueAsNewRetryShape as B, type CommandGate as C, createHistoryFile as D, type EventsForCommandsContext as E, eventsForCommands as F, hasUnprocessedInput as G, type HistoryIssue as H, initialRunState as I, isActivityOpen as J, isChildOpen as K, type LocalActivityState as L, isCommandEnabled as M, isReliefCommand as N, isWorkflowCommandEnabled as O, PHASE_B_CORE_FEATURES as P, parseHistoryFile as Q, RUN_EVENT_SCHEMA as R, pendingCounts as S, type TimerState as T, projectRunState as U, serializeHistoryFile as V, WORKFLOW_COMMAND_SCHEMA as W, taskCompletedEvents as X, unsupportedMessage as Y, utf8Bytes as Z, type CommandRelief as a, type ActivityStatus as b, COMMAND_FEATURES as c, CORE_CAN_OPTIONS as d, CORE_CHILD_OPTIONS as e, type ChildState as f, type ChildStatus as g, type CommandFeature as h, type EventsForCommandsResult as i, type ExternalState as j, HISTORY_FILE_FORMAT as k, HISTORY_FILE_SCHEMA as l, HISTORY_FILE_SCHEMA_ID as m, HISTORY_SCHEMA_FILES as n, type HistoryFile as o, HistoryFileError as p, HistoryStateError as q, PHASE_B_PARITY_FEATURES as r, RUN_EVENT_SCHEMA_ID as s, type RunState as t, type RunStatus as u, WORKFLOW_COMMAND_SCHEMA_ID as v, WORKFLOW_TASK_SCHEMA as w, WORKFLOW_TASK_SCHEMA_ID as x, applyEvent as y, commandFeatures as z };