@lostgradient/weft 0.20.0 → 0.22.0

package/dist/cli/generated/operation-client.generated.d.ts

@@ -19,14 +19,14 @@ export declare const CLIENT_REST_OPERATION_BINDINGS: {
         };
     };
 };
-type SharedAttributesBulkConcurrenc_ff397168 = {
+type SharedAttributesBulkConcurrenc_0f0d07d6 = {
     readonly attributes?: ReadonlyArray<SharedGtGteKey_e658e64c>;
     readonly bulkConcurrency?: number;
     readonly confirmationToken?: string;
     readonly createdAt?: SharedGtGteLt_d9a61361;
     readonly dryRun?: boolean;
     readonly executionDeadline?: SharedGtGteLt_d9a61361;
-    readonly failureCategory?: unknown;
+    readonly failureCategory?: 'application' | 'timeout' | 'cancellation' | 'resource' | 'system' | ReadonlyArray<'application' | 'timeout' | 'cancellation' | 'resource' | 'system'>;
     readonly idPrefix?: string;
     readonly limit?: number;
     readonly offset?: number;
@@ -34,23 +34,23 @@ type SharedAttributesBulkConcurrenc_ff397168 = {
     readonly parentWorkflowId?: string;
     readonly requestId?: string;
     readonly scheduleId?: string;
-    readonly status?: unknown;
+    readonly status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timed-out' | 'suspended' | ReadonlyArray<'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timed-out' | 'suspended'>;
     readonly tags?: ReadonlyArray<string>;
     readonly type?: string;
     readonly updatedAt?: SharedGtGteLt_d9a61361;
 };
-type SharedAttributesCreatedAtExecu_0caddefc = {
+type SharedAttributesCreatedAtExecu_47f8e20e = {
     readonly attributes?: ReadonlyArray<SharedGtGteKey_e658e64c>;
     readonly createdAt?: SharedGtGteLt_d9a61361;
     readonly executionDeadline?: SharedGtGteLt_d9a61361;
-    readonly failureCategory?: unknown;
+    readonly failureCategory?: 'application' | 'timeout' | 'cancellation' | 'resource' | 'system' | ReadonlyArray<'application' | 'timeout' | 'cancellation' | 'resource' | 'system'>;
     readonly idPrefix?: string;
     readonly limit?: number;
     readonly offset?: number;
     readonly parentWorkflowExecutionToken?: string;
     readonly parentWorkflowId?: string;
     readonly scheduleId?: string;
-    readonly status?: unknown;
+    readonly status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timed-out' | 'suspended' | ReadonlyArray<'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timed-out' | 'suspended'>;
     readonly tags?: ReadonlyArray<string>;
     readonly type?: string;
     readonly updatedAt?: SharedGtGteLt_d9a61361;
@@ -76,7 +76,7 @@ export type ClientOperationTypes = {
             readonly token: string;
         };
         readonly output: {
-            readonly ok: boolean;
+            readonly ok: true;
         };
         readonly faults: 'InvalidParams' | 'NotFound';
     };
@@ -89,7 +89,7 @@ export type ClientOperationTypes = {
             readonly token: string;
         };
         readonly output: {
-            readonly ok: boolean;
+            readonly ok: true;
         };
         readonly faults: 'InvalidParams' | 'NotFound';
     };
@@ -98,10 +98,10 @@ export type ClientOperationTypes = {
         readonly output: {
             readonly items: ReadonlyArray<{
                 readonly currentValue: number;
-                readonly firedAt: unknown;
+                readonly firedAt: number | null;
                 readonly metric: 'workflow.failure_rate' | 'activity.p99_duration' | 'storage.size';
                 readonly threshold: number;
-                readonly window: unknown;
+                readonly window: string | null;
             }>;
         };
         readonly faults: never;
@@ -128,7 +128,7 @@ export type ClientOperationTypes = {
             readonly workflowId?: unknown;
         };
         readonly output: {
-            readonly ok: boolean;
+            readonly ok: true;
         };
         readonly faults: 'NotFound';
     };
@@ -147,7 +147,34 @@ export type ClientOperationTypes = {
             readonly workflowId?: string;
         };
         readonly output: {
-            readonly items: ReadonlyArray<unknown>;
+            readonly items: ReadonlyArray<{
+                readonly allowPartial: boolean;
+                readonly artifact: unknown;
+                readonly createdAt: number;
+                readonly reviewId: string;
+                readonly reviewType: string;
+                readonly reviewers: ReadonlyArray<string>;
+                readonly status: 'pending';
+                readonly timeout?: number;
+                readonly webhookUrl?: string;
+                readonly workflowId: string;
+            } | {
+                readonly allowPartial: boolean;
+                readonly artifact: unknown;
+                readonly createdAt: number;
+                readonly decision: 'approved' | 'rejected' | 'needs-changes';
+                readonly feedback?: string;
+                readonly reviewId: string;
+                readonly reviewType: string;
+                readonly reviewer: string;
+                readonly reviewers: ReadonlyArray<string>;
+                readonly sectionDecisions?: Record<string, unknown>;
+                readonly status: 'completed';
+                readonly timeout?: number;
+                readonly timestamp: number;
+                readonly webhookUrl?: string;
+                readonly workflowId: string;
+            }>;
         };
         readonly faults: never;
     };
@@ -256,7 +283,7 @@ export type ClientOperationTypes = {
         readonly output: {
             readonly method: 'jwt' | 'api-key' | 'mtls' | 'stdio-local' | 'unauthenticated';
             readonly scopes: ReadonlyArray<'workflows:read' | 'workflows:write' | 'workflows:admin' | 'schedules:read' | 'schedules:write' | 'signals:write' | 'updates:write' | 'queries:read' | 'reviews:read' | 'reviews:write' | 'attributes:read' | 'attributes:write' | 'tags:write' | 'streams:read' | 'events:read' | 'storage:read' | 'storage:write' | 'storage:admin' | 'workers:write' | 'system:read' | 'system:admin'>;
-            readonly subject: unknown;
+            readonly subject: string | null;
         };
         readonly faults: never;
     };
@@ -264,7 +291,7 @@ export type ClientOperationTypes = {
         readonly input: {};
         readonly output: {
             readonly activities: unknown;
-            readonly registryVersion: number;
+            readonly registryVersion: 1;
             readonly workflows: unknown;
         };
         readonly faults: never;
@@ -276,8 +303,8 @@ export type ClientOperationTypes = {
                 readonly backlog: number;
                 readonly connectedWorkers: number;
                 readonly inFlight: number;
-                readonly oldestEnqueuedAt: unknown;
-                readonly oldestQueuedAgeMs: unknown;
+                readonly oldestEnqueuedAt: number | null;
+                readonly oldestQueuedAgeMs: number | null;
                 readonly queue: string;
                 readonly schedulingPolicy: 'priority' | 'fifo' | 'lifo';
                 readonly waitingPollers: number;
@@ -287,18 +314,20 @@ export type ClientOperationTypes = {
     };
     'weft.tasks.diagnostics': {
         readonly input: {
+            readonly includeExpectedDelayed: boolean;
             readonly limit: number;
             readonly operationId?: string;
             readonly queue?: string;
             readonly retryStormMinimumAttempts: number;
             readonly staleHeartbeatAfterMs: number;
             readonly staleQueuedAfterMs: number;
+            readonly unadoptedAfterMs: number;
             readonly workflowId?: string;
         };
         readonly output: {
             readonly items: ReadonlyArray<{
                 readonly activityName?: string;
-                readonly deadLetterReason?: string;
+                readonly deadLetterReason?: 'result-resolution-storage-exhausted';
                 readonly deadLetteredAt?: number;
                 readonly evidence: ReadonlyArray<string>;
                 readonly executionLatencyMs?: number;
@@ -316,14 +345,35 @@ export type ClientOperationTypes = {
                 readonly storageError?: string;
                 readonly workerId?: string;
                 readonly workflowId?: string;
+            } | {
+                readonly availableAt: number;
+                readonly evidence: ReadonlyArray<string>;
+                readonly kind: 'delayed';
+                readonly operationId: string;
+                readonly queue: string;
+                readonly requeueCount: number;
+                readonly retryCount: number;
+                readonly state: 'queued';
+                readonly workflowId?: string;
+            } | {
+                readonly adopted: false;
+                readonly evidence: ReadonlyArray<string>;
+                readonly kind: 'unadopted-terminal';
+                readonly operationId: string;
+                readonly queue: string;
+                readonly state: 'resolved';
+                readonly terminalAt: number;
+                readonly workflowId?: string;
             }>;
             readonly limit: number;
             readonly summary: {
                 readonly allWorkersAtCapacity: number;
                 readonly deadLettered: number;
+                readonly delayed: number;
                 readonly retryStorms: number;
                 readonly staleInflight: number;
                 readonly stuckQueued: number;
+                readonly unadoptedTerminal: number;
             };
         };
         readonly faults: never;
@@ -333,7 +383,7 @@ export type ClientOperationTypes = {
             readonly operationId: string;
         };
         readonly output: {
-            readonly ok: boolean;
+            readonly ok: true;
         };
         readonly faults: 'NotFound';
     };
@@ -371,7 +421,29 @@ export type ClientOperationTypes = {
             readonly workerId: string;
         };
         readonly output: {
-            readonly worker: unknown;
+            readonly worker: {
+                readonly deploymentVersion: {
+                    readonly artifactDigest: string;
+                    readonly buildId: string;
+                    readonly deploymentName: string;
+                    readonly manifestDigest: string;
+                    readonly manifestVersion: number;
+                    readonly protocolVersion: number;
+                    readonly runtimeName: string;
+                    readonly runtimeVersion: string;
+                    readonly sdkVersion: string;
+                    readonly workflows: Record<string, unknown>;
+                };
+                readonly instance: {
+                    readonly connectedAt: number;
+                    readonly health: 'active' | 'draining' | 'drained';
+                    readonly heartbeatAgeMs: number;
+                    readonly lastHeartbeatAt: number;
+                    readonly queue: string;
+                    readonly startedAt: number;
+                    readonly workerId: string;
+                };
+            } | null;
         };
         readonly faults: never;
     };
@@ -388,14 +460,14 @@ export type ClientOperationTypes = {
         readonly output: {
             readonly deployments: ReadonlyArray<{
                 readonly activeWorkers: number;
-                readonly buildId: unknown;
-                readonly deploymentName: unknown;
+                readonly buildId: string | null;
+                readonly deploymentName: string | null;
                 readonly drainedWorkers: number;
                 readonly drainingWorkers: number;
                 readonly health: 'active' | 'draining' | 'drained';
                 readonly inFlight: number;
-                readonly oldestStartedAt: unknown;
-                readonly runtimeVersion: unknown;
+                readonly oldestStartedAt: number | null;
+                readonly runtimeVersion: string | null;
                 readonly workers: number;
             }>;
             readonly items: ReadonlyArray<{
@@ -467,14 +539,16 @@ export type ClientOperationTypes = {
             readonly attributes?: ReadonlyArray<SharedGtGteKey_e658e64c>;
             readonly createdAt?: SharedGtGteLt_d9a61361;
             readonly executionDeadline?: SharedGtGteLt_d9a61361;
-            readonly failureCategory?: unknown;
-            readonly groupBy: unknown;
+            readonly failureCategory?: 'application' | 'timeout' | 'cancellation' | 'resource' | 'system' | ReadonlyArray<'application' | 'timeout' | 'cancellation' | 'resource' | 'system'>;
+            readonly groupBy: 'status' | 'type' | 'failureCategory' | {
+                readonly attribute: string;
+            };
             readonly idPrefix?: string;
             readonly limit?: number;
             readonly parentWorkflowExecutionToken?: string;
             readonly parentWorkflowId?: string;
             readonly scheduleId?: string;
-            readonly status?: unknown;
+            readonly status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timed-out' | 'suspended' | ReadonlyArray<'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timed-out' | 'suspended'>;
             readonly tags?: ReadonlyArray<string>;
             readonly type?: string;
             readonly updatedAt?: SharedGtGteLt_d9a61361;
@@ -482,7 +556,7 @@ export type ClientOperationTypes = {
         readonly output: {
             readonly groups: ReadonlyArray<{
                 readonly count: number;
-                readonly key: unknown;
+                readonly key: string | null;
             }>;
             readonly total: number;
             readonly truncated: boolean;
@@ -502,22 +576,22 @@ export type ClientOperationTypes = {
             readonly workflowId: string;
         };
         readonly output: {
-            readonly ok: boolean;
+            readonly ok: true;
         };
         readonly faults: never;
     };
     'weft.workflows.bulk.cancel': {
-        readonly input: SharedAttributesBulkConcurrenc_ff397168;
+        readonly input: SharedAttributesBulkConcurrenc_0f0d07d6;
         readonly output: unknown;
         readonly faults: never;
     };
     'weft.workflows.bulk.delete': {
-        readonly input: SharedAttributesBulkConcurrenc_ff397168;
+        readonly input: SharedAttributesBulkConcurrenc_0f0d07d6;
         readonly output: unknown;
         readonly faults: 'Unprocessable';
     };
     'weft.workflows.bulk.retryfailed': {
-        readonly input: SharedAttributesBulkConcurrenc_ff397168;
+        readonly input: SharedAttributesBulkConcurrenc_0f0d07d6;
         readonly output: unknown;
         readonly faults: never;
     };
@@ -529,7 +603,7 @@ export type ClientOperationTypes = {
             readonly createdAt?: SharedGtGteLt_d9a61361;
             readonly dryRun?: boolean;
             readonly executionDeadline?: SharedGtGteLt_d9a61361;
-            readonly failureCategory?: unknown;
+            readonly failureCategory?: 'application' | 'timeout' | 'cancellation' | 'resource' | 'system' | ReadonlyArray<'application' | 'timeout' | 'cancellation' | 'resource' | 'system'>;
             readonly idPrefix?: string;
             readonly limit?: number;
             readonly name: string;
@@ -539,7 +613,7 @@ export type ClientOperationTypes = {
             readonly payload?: unknown;
             readonly requestId?: string;
             readonly scheduleId?: string;
-            readonly status?: unknown;
+            readonly status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timed-out' | 'suspended' | ReadonlyArray<'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timed-out' | 'suspended'>;
             readonly tags?: ReadonlyArray<string>;
             readonly type?: string;
             readonly updatedAt?: SharedGtGteLt_d9a61361;
@@ -552,7 +626,7 @@ export type ClientOperationTypes = {
             readonly bulkConcurrency?: number;
             readonly confirmationToken?: string;
             readonly dryRun?: boolean;
-            readonly filter?: SharedAttributesCreatedAtExecu_0caddefc;
+            readonly filter?: SharedAttributesCreatedAtExecu_47f8e20e;
             readonly operation: 'add' | 'remove';
             readonly requestId?: string;
             readonly tags: ReadonlyArray<string>;
@@ -618,15 +692,15 @@ export type ClientOperationTypes = {
             readonly attributes?: ReadonlyArray<SharedGtGteKey_e658e64c>;
             readonly createdAt?: SharedGtGteLt_d9a61361;
             readonly executionDeadline?: SharedGtGteLt_d9a61361;
-            readonly failureCategory?: unknown;
+            readonly failureCategory?: string | ReadonlyArray<string>;
             readonly idPrefix?: string;
-            readonly include?: unknown;
+            readonly include?: string | ReadonlyArray<string>;
             readonly limit?: number;
             readonly offset?: number;
             readonly parentWorkflowExecutionToken?: string;
             readonly parentWorkflowId?: string;
             readonly scheduleId?: string;
-            readonly status?: unknown;
+            readonly status?: string | ReadonlyArray<string>;
             readonly tags?: ReadonlyArray<string>;
             readonly type?: string;
             readonly updatedAt?: SharedGtGteLt_d9a61361;
@@ -635,7 +709,7 @@ export type ClientOperationTypes = {
         readonly faults: 'Unprocessable';
     };
     'weft.workflows.purge': {
-        readonly input: SharedAttributesCreatedAtExecu_0caddefc;
+        readonly input: SharedAttributesCreatedAtExecu_47f8e20e;
         readonly output: unknown;
         readonly faults: never;
     };
@@ -650,7 +724,7 @@ export type ClientOperationTypes = {
     };
     'weft.workflows.replay': {
         readonly input: {
-            readonly step: unknown;
+            readonly step: string | number;
             readonly workflowId: string;
         };
         readonly output: unknown;
@@ -676,7 +750,10 @@ export type ClientOperationTypes = {
         readonly input: {
             readonly workflowId: string;
         };
-        readonly output: unknown;
+        readonly output: {
+            readonly occurrence?: number;
+            readonly scheduleId: string;
+        } | null;
         readonly faults: never;
     };
     'weft.workflows.signal': {
@@ -687,7 +764,7 @@ export type ClientOperationTypes = {
             readonly workflowId: string;
         };
         readonly output: {
-            readonly ok: boolean;
+            readonly ok: true;
         };
         readonly faults: 'NotFound';
     };
@@ -754,7 +831,7 @@ export type ClientOperationTypes = {
             readonly workflowId: string;
         };
         readonly output: {
-            readonly ok: boolean;
+            readonly ok: true;
         };
         readonly faults: 'NotFound' | 'Unprocessable';
     };
@@ -764,7 +841,7 @@ export type ClientOperationTypes = {
             readonly workflowId: string;
         };
         readonly output: {
-            readonly ok: boolean;
+            readonly ok: true;
         };
         readonly faults: 'NotFound' | 'Unprocessable';
     };

package/dist/client/http-client-storage.js

@@ -38,7 +38,7 @@ export function createHttpClientStorage(baseUrl, headers) {
       await requestResponse(baseUrl, `/storage/${encodeURIComponent(key)}`, headers, {
         method: "PUT",
         headers: { "content-type": "application/octet-stream" },
-        body: new Blob([value])
+        body: new Blob([new Uint8Array(value)])
       });
     },
     async delete(key) {

package/dist/core/engine/activity-reconciliation.d.ts

@@ -95,14 +95,14 @@ export declare function buildActivityReconciliationReference(workflowId: string,
 export declare function resolveActivityIdempotencyKey(activity: ActivityReconciliationMetadata | undefined, operation: ActivityOperation): string | undefined;
 export declare function readActivityReconciliationRecord(storage: Storage, key: string): Promise<ActivityReconciliationRecord | null>;
 export declare function validateActivityResultForReconciliation(result: unknown, maxPayloadBytes: number | null): Uint8Array;
-export declare function claimActivityReconciliationStart(storage: Storage, reference: ActivityReconciliationReference, record: ActivityReconciliationRecord): Promise<boolean>;
+export declare function claimActivityReconciliationStart(internals: EngineInternals, workflowId: string, reference: ActivityReconciliationReference, record: ActivityReconciliationRecord): Promise<boolean>;
 export declare function createCompletedActivityReconciliationRecord(startedRecord: ActivityReconciliationRecord, result: unknown, now: number): ActivityReconciliationRecord;
 export declare function resolveStartedActivityReconciliationRecord(internals: EngineInternals, workflowId: string, operation: ActivityOperation, reference: ActivityReconciliationReference, activity: ActivityReconciliationMetadata | undefined, idempotencyKey: string, attempt: number): Promise<ActivityReconciliationRecord | {
     completedResult: unknown;
 }>;
 export declare function writeActivityReconciliationTransition(storage: Storage, reference: ActivityReconciliationReference, expectedRecord: ActivityReconciliationRecord, nextRecord: ActivityReconciliationRecord): Promise<void>;
 export declare function stageActivityReconciliationTransitionWithAtomicWorkflowCommit(internals: EngineInternals, workflowId: string, reference: ActivityReconciliationReference, expectedRecord: ActivityReconciliationRecord, nextRecord: ActivityReconciliationRecord): void;
-export declare function commitActivityReconciliationTransitionWithFencedWrite(internals: EngineInternals, reference: ActivityReconciliationReference, expectedRecord: ActivityReconciliationRecord, nextRecord: ActivityReconciliationRecord): Promise<void>;
+export declare function commitActivityReconciliationTransitionWithFencedWrite(internals: EngineInternals, workflowId: string, reference: ActivityReconciliationReference, expectedRecord: ActivityReconciliationRecord, nextRecord: ActivityReconciliationRecord): Promise<void>;
 export declare function normalizePreDispatchVerificationResult(result: ActivityVerificationResult): 'not-completed' | 'completed-result-unavailable' | 'indeterminate' | {
     result: unknown;
 };

package/dist/core/engine/activity-reconciliation.js

@@ -7,7 +7,10 @@ import { decode, encode } from "../codec.js";
 import { assertPayloadWithinLimit } from "../payload-size.js";
 import { WeftError } from "../weft-error.js";
 import { stageAtomicWorkflowCommitSideEffects } from "./checkpoint-side-effects.js";
-import { commitFencedEngineWrite } from "./fenced-write.js";
+import {
+  commitFencedEngineWrite,
+  commitFencedEngineWriteAllowingPreconditionFailure
+} from "./fenced-write.js";
 
 export class ActivityReconciliationCapabilityError extends WeftError {
   constructor() {
@@ -50,11 +53,12 @@ export function validateActivityResultForReconciliation(result, maxPayloadBytes)
   assertPayloadWithinLimit(result, maxPayloadBytes, "activity result");
   return encode(result);
 }
-export async function claimActivityReconciliationStart(storage, reference, record) {
+export async function claimActivityReconciliationStart(internals, workflowId, reference, record) {
+  const storage = internals.storage;
   if (!storage.capabilities().conditionalBatch)
     throw new ActivityReconciliationCapabilityError;
   requireStorageCapability(storage, "conditionalBatch", "activity result reconciliation");
-  return storageConditionalBatch(storage, [{ key: reference.key, expectedValue: null }], [{ type: "put", key: reference.key, value: encode(record) }]);
+  return commitFencedEngineWriteAllowingPreconditionFailure(internals, workflowId, [{ type: "put", key: reference.key, value: encode(record) }], [{ key: reference.key, expectedValue: null }]);
 }
 export function createCompletedActivityReconciliationRecord(startedRecord, result, now) {
   return {
@@ -84,7 +88,7 @@ export async function resolveStartedActivityReconciliationRecord(internals, work
       ownerId: crypto.randomUUID(),
       updatedAt: internals.options.getNow()
     };
-    await commitActivityReconciliationTransitionWithFencedWrite(internals, reference, record, nextRecord);
+    await commitActivityReconciliationTransitionWithFencedWrite(internals, workflowId, reference, record, nextRecord);
     return nextRecord;
   }
   if (normalized === "completed-result-unavailable")
@@ -93,7 +97,7 @@ export async function resolveStartedActivityReconciliationRecord(internals, work
     throw new ActivityReconciliationIndeterminateError(`Activity "${operation.activityName}" reconciliation is indeterminate.`);
   validateActivityResultForReconciliation(normalized.result, internals.options.payloadSizePolicy.maxBytes);
   const completedRecord = createCompletedActivityReconciliationRecord(record, normalized.result, internals.options.getNow());
-  await commitActivityReconciliationTransitionWithFencedWrite(internals, reference, record, completedRecord);
+  await commitActivityReconciliationTransitionWithFencedWrite(internals, workflowId, reference, record, completedRecord);
   return { completedResult: normalized.result };
 }
 export async function writeActivityReconciliationTransition(storage, reference, expectedRecord, nextRecord) {
@@ -104,9 +108,9 @@ export async function writeActivityReconciliationTransition(storage, reference,
 export function stageActivityReconciliationTransitionWithAtomicWorkflowCommit(internals, workflowId, reference, expectedRecord, nextRecord) {
   stageAtomicWorkflowCommitSideEffects(internals, workflowId, buildActivityReconciliationTransitionSideEffects(reference, expectedRecord, nextRecord));
 }
-export async function commitActivityReconciliationTransitionWithFencedWrite(internals, reference, expectedRecord, nextRecord) {
+export async function commitActivityReconciliationTransitionWithFencedWrite(internals, workflowId, reference, expectedRecord, nextRecord) {
   const sideEffects = buildActivityReconciliationTransitionSideEffects(reference, expectedRecord, nextRecord);
-  await commitFencedEngineWrite(internals, sideEffects.operations, sideEffects.conditions, () => new ActivityReconciliationConflictError("Activity reconciliation completion lost compare-and-set ownership."));
+  await commitFencedEngineWrite(internals, workflowId, sideEffects.operations, sideEffects.conditions, () => new ActivityReconciliationConflictError("Activity reconciliation completion lost compare-and-set ownership."));
 }
 function buildActivityReconciliationTransitionSideEffects(reference, expectedRecord, nextRecord) {
   return {
@@ -171,7 +175,7 @@ function createStartedRecord(workflowId, operation, reference, attempt, now) {
 }
 async function claimStartedRecord(internals, workflowId, operation, reference, attempt) {
   const startedRecord = createStartedRecord(workflowId, operation, reference, attempt, internals.options.getNow());
-  if (await claimActivityReconciliationStart(internals.storage, reference, startedRecord))
+  if (await claimActivityReconciliationStart(internals, workflowId, reference, startedRecord))
     return { didClaim: !0, record: startedRecord };
   const record = await readActivityReconciliationRecord(internals.storage, reference.key);
   if (record === null)

package/dist/core/engine/async-activity-completion.js

@@ -10,6 +10,7 @@ import {
 } from "./async-activity-records.js";
 import { stageAtomicWorkflowCommitSideEffects } from "./checkpoint-side-effects.js";
 import { commitFencedEngineWrite } from "./fenced-write.js";
+import { confirmWakeOwnership } from "./wake-ownership-guard.js";
 
 export class AsyncActivityDeferral extends Error {
   token;
@@ -30,7 +31,7 @@ export class AsyncActivityTokenNotFoundError extends WeftError {
 export async function parkDeferredAsyncActivity(internals, deferral, details, callbacks) {
   const queuedResolution = takePendingAsyncActivityResolution(internals, details.workflowId, deferral.token);
   if (queuedResolution !== void 0) {
-    deliverPendingAsyncActivityResolution(internals, details.workflowId, queuedResolution, callbacks);
+    await deliverPendingAsyncActivityResolution(internals, details.workflowId, queuedResolution, callbacks);
     return new Promise(() => {});
   }
   await registerPendingAsyncActivity(internals, {
@@ -44,16 +45,23 @@ async function consumePendingAsyncActivity(internals, token, outcome) {
   const pending = internals.pendingAsyncActivities.get(token);
   if (!pending)
     throw new AsyncActivityTokenNotFoundError(token);
+  const registry = internals.workflowClaimRegistry;
+  if (registry !== null && registry.currentEpoch(pending.workflowId) === null)
+    throw new AsyncActivityTokenNotFoundError(token);
   internals.pendingAsyncActivities.delete(token);
   try {
-    await commitFencedEngineWrite(internals, buildAsyncActivityAcknowledgementOperations(pending, outcome), [], () => Error(`Async activity acknowledgement for token "${token}" lost its precondition.`));
+    await commitFencedEngineWrite(internals, pending.workflowId, buildAsyncActivityAcknowledgementOperations(pending, outcome), [], () => Error(`Async activity acknowledgement for token "${token}" lost its precondition.`));
   } catch (error) {
     internals.pendingAsyncActivities.set(token, pending);
     throw error;
   }
   return pending;
 }
-function deliverPendingAsyncActivityResolution(internals, workflowId, resolution, callbacks) {
+async function deliverPendingAsyncActivityResolution(internals, workflowId, resolution, callbacks) {
+  if (internals.workflowClaimRegistry !== null) {
+    if (await confirmWakeOwnership(internals, workflowId, "async-activity") === "discard")
+      return;
+  }
   stageAtomicWorkflowCommitSideEffects(internals, workflowId, {
     conditions: [],
     operations: [
@@ -75,7 +83,7 @@ async function resolvePendingAsyncActivity(internals, token, outcome, callbacks,
     queuePendingAsyncActivityResolution(internals, pending.workflowId, resolution);
     return;
   }
-  deliverPendingAsyncActivityResolution(internals, pending.workflowId, resolution, callbacks);
+  await deliverPendingAsyncActivityResolution(internals, pending.workflowId, resolution, callbacks);
 }
 export async function completeAsyncActivity(internals, token, result, callbacks) {
   assertPayloadWithinLimit(result, internals.options.payloadSizePolicy.maxBytes, "activity result");

package/dist/core/engine/async-activity-records.d.ts

@@ -104,8 +104,18 @@ export declare function registerPendingAsyncActivity(internals: EngineInternals,
  * before the recovered workflow has replayed far enough to re-register it —
  * and so an acknowledged-but-not-yet-checkpointed resolution is redelivered
  * when replay re-parks on the same deterministic token.
+ *
+ * Pass `workflowId` to reload just one workflow's records. ADR 0002's
+ * reclaim-driven resume needs this: a resolution acknowledged by an expired
+ * owner is discarded by that engine's `confirmWakeOwnership` check, leaving
+ * only the durable record. The engine that takes the workflow over finished
+ * its startup scan long ago, so without a per-workflow reload it never
+ * discovers a resolution written after that scan — the workflow re-parks and
+ * waits forever even though the completion caller was told it succeeded. The
+ * scan is bounded to {@link asyncActivityWorkflowPrefix}, so a takeover pays
+ * for one workflow rather than a store-wide sweep.
  */
-export declare function recoverPendingAsyncActivities(internals: EngineInternals): Promise<void>;
+export declare function recoverPendingAsyncActivities(internals: EngineInternals, workflowId?: string): Promise<void>;
 /**
  * True when a resolution cannot be delivered yet because inline replay has not
  * adopted the workflow generator (the post-recovery window).

package/dist/core/engine/async-activity-records.js

@@ -148,12 +148,13 @@ export function buildAsyncActivityAcknowledgementOperations(pending, outcome) {
 export async function registerPendingAsyncActivity(internals, pending) {
   const alreadyRegistered = internals.pendingAsyncActivities.has(pending.token);
   internals.pendingAsyncActivities.set(pending.token, pending);
-  await commitFencedEngineWrite(internals, [buildPersistPendingAsyncActivityOperation(pending)], [], () => Error(`Async activity registration for token "${pending.token}" lost its precondition.`));
+  await commitFencedEngineWrite(internals, pending.workflowId, [buildPersistPendingAsyncActivityOperation(pending)], [], () => Error(`Async activity registration for token "${pending.token}" lost its precondition.`));
   if (!alreadyRegistered)
     internals.engine.dispatchEvent(new ActivityAsyncPendingEvent(pending.token, pending.operationId, pending.workflowId, pending.activityName, pending.attempt));
 }
-export async function recoverPendingAsyncActivities(internals) {
-  for await (const [, bytes] of internals.storage.scan(ASYNC_ACTIVITY_KEY_PREFIX)) {
+export async function recoverPendingAsyncActivities(internals, workflowId) {
+  const scanPrefix = workflowId === void 0 ? ASYNC_ACTIVITY_KEY_PREFIX : asyncActivityWorkflowPrefix(workflowId);
+  for await (const [, bytes] of internals.storage.scan(scanPrefix)) {
     const decoded = decode(bytes);
     if (isPersistedAsyncActivity(decoded)) {
       internals.pendingAsyncActivities.set(decoded.token, {

package/dist/core/engine/attributes-tags.d.ts

@@ -1,6 +1,16 @@
 import type { BatchOperation } from '../../storage/interface.ts';
 import type { BulkTagResult, ListFilter, SearchAttributeValue, WorkflowState, WorkflowStatus } from '../types.ts';
 import type { EngineInternals } from './internals.ts';
+/**
+ * `updateWorkflowState`'s two callers commit very different transitions per
+ * ADR 0002: `failWorkflow` is a SELF-transition (this engine finishing its
+ * own workflow) while `terminateWorkflow` (cancel/timeout) is an EXTERNAL
+ * terminal transition (any engine may commit it, and it rotates the claim
+ * epoch under `ownership: 'workflow-lease'`). `category` is a REQUIRED
+ * positional parameter rather than an optional options field so a caller
+ * cannot silently default into the wrong fencing shape.
+ */
+export type WorkflowStateTransitionCategory = 'self' | 'external-terminal';
 type WorkflowStateUpdateOptions = {
     allowedStatuses?: readonly WorkflowStatus[];
     buildAdditionalOperations?: (previousState: WorkflowState, updatedAt: number) => BatchOperation[];
@@ -21,7 +31,7 @@ export declare function writeRetainedTerminalSearchAttributes(internals: EngineI
 /** Build secondary-index updates for terminal workflow state transitions. */
 export declare function buildTerminalWorkflowIndexOperations(previousState: WorkflowState, nextState: WorkflowState): BatchOperation[];
 /** Apply a serialized workflow-state update and return the previous state metadata. */
-export declare function updateWorkflowState(internals: EngineInternals, workflowId: string, updates: Partial<WorkflowState>, options?: WorkflowStateUpdateOptions): Promise<WorkflowStateUpdateResult | null>;
+export declare function updateWorkflowState(internals: EngineInternals, workflowId: string, updates: Partial<WorkflowState>, category: WorkflowStateTransitionCategory, options?: WorkflowStateUpdateOptions): Promise<WorkflowStateUpdateResult | null>;
 /** Add or remove tags for a single workflow under the serialized state-write lock. */
 export declare function mutateWorkflowTags(internals: EngineInternals, workflowId: string, tags: string[], mode: 'add' | 'remove'): Promise<boolean>;
 /** Add or remove tags for every workflow selected by a scoped bulk filter. */