@fabricorg/platform-host 0.2.0 → 0.3.1

package/dist/index.js

@@ -22,9 +22,8 @@ function createGovernedActionHost(options) {
     }
     const actionInvocationId = createFabricId("act");
     const correlationId = input.correlationId ?? createFabricId("corr");
-    const workflowId = `action-invocation-${actionInvocationId}`;
     const durableParameters = options.redactActionParameters ? options.redactActionParameters(input.actionId, input.parameters) : input.parameters;
-    await options.store.createActionInvocation({
+    const durableInvocation = await options.store.createActionInvocation({
       id: actionInvocationId,
       tenantId: input.tenantId,
       spaceId: input.spaceId,
@@ -36,26 +35,37 @@ function createGovernedActionHost(options) {
       parameters: durableParameters,
       result: {},
       correlationId,
-      ...input.causationId ? { causationId: input.causationId } : {}
+      ...input.causationId ? { causationId: input.causationId } : {},
+      ...input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}
     });
+    const durableWorkflowId = `action-invocation-${durableInvocation.id}`;
+    if (durableInvocation.id !== actionInvocationId && isTerminal(durableInvocation.status)) {
+      return {
+        actionInvocationId: durableInvocation.id,
+        status: durableInvocation.status,
+        workflowId: durableWorkflowId,
+        result: durableInvocation.result,
+        ...durableInvocation.error ? { error: durableInvocation.error } : {}
+      };
+    }
     if (options.dispatcher) {
       try {
         const dispatched = await options.dispatcher.dispatch({
-          actionInvocationId,
+          actionInvocationId: durableInvocation.id,
           tenantId: input.tenantId,
           spaceId: input.spaceId,
-          workflowId
+          workflowId: durableWorkflowId
         });
         return {
-          actionInvocationId,
-          status: "pending",
+          actionInvocationId: durableInvocation.id,
+          status: durableInvocation.status,
           workflowId: dispatched.workflowId,
           ...dispatched.runId ? { runId: dispatched.runId } : {}
         };
       } catch (error) {
         const message = errorMessage(error);
         await options.store.updateActionInvocation(
-          actionInvocationId,
+          durableInvocation.id,
           input.tenantId,
           input.spaceId,
           { status: "failed", error: message }
@@ -64,11 +74,11 @@ function createGovernedActionHost(options) {
       }
     }
     const executed = await executeInvocation(
-      actionInvocationId,
+      durableInvocation.id,
       input.tenantId,
       input.spaceId
     );
-    return { ...executed, workflowId };
+    return { ...executed, workflowId: durableWorkflowId };
   }
   async function executeInvocation(actionInvocationId, tenantId, spaceId) {
     const invocation = await options.store.getActionInvocation(
@@ -89,223 +99,243 @@ function createGovernedActionHost(options) {
     if (!action) {
       return fail(invocation, "failed", `Unknown action: ${invocation.actionId}`);
     }
+    if (invocation.attemptCount > 1 && !action.idempotent) {
+      return fail(
+        invocation,
+        "failed",
+        `Interrupted action ${invocation.actionId} is not declared idempotent; manual reconciliation is required.`
+      );
+    }
     await options.store.updateActionInvocation(actionInvocationId, tenantId, spaceId, {
       status: "running"
     });
-    const parsed = action.schema.safeParse(invocation.parameters);
-    if (!parsed.success) {
-      const message = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
-      return fail(invocation, "validation_failed", message);
-    }
-    const authorizationInput = toAuthorizationInput(action, invocation);
-    const definitions = options.resolvePolicies ? await options.resolvePolicies({
-      ...authorizationInput,
-      declaredPolicyIds: action.policies ?? []
-    }) : declaredPolicies(action.policies ?? []);
-    const outcomes = await evaluatePolicyDefinitions(definitions, {
-      tenantId,
-      spaceId,
-      actionInvocationId,
-      actionId: action.actionId,
-      actorId: invocation.actorId,
-      actorType: invocation.actorType,
-      parameters: parsed.data,
-      db: options.store.db,
-      services: options.services,
-      mode: "execute"
-    });
-    for (const outcome of outcomes) {
-      await options.store.appendPolicyEvaluation({
-        id: createFabricId("pol"),
-        actionInvocationId,
+    try {
+      const parsed = action.schema.safeParse(invocation.parameters);
+      if (!parsed.success) {
+        const message = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+        return fail(invocation, "validation_failed", message);
+      }
+      const authorizationInput = toAuthorizationInput(action, invocation);
+      const definitions = options.resolvePolicies ? await options.resolvePolicies({
+        ...authorizationInput,
+        declaredPolicyIds: action.policies ?? []
+      }) : declaredPolicies(action.policies ?? []);
+      const outcomes = await evaluatePolicyDefinitions(definitions, {
         tenantId,
         spaceId,
-        outcome,
-        createdAt: now()
-      });
-    }
-    const aggregate = aggregatePolicyOutcomes(outcomes);
-    if (aggregate?.result === "block") {
-      const reason = aggregate.reason ?? `Blocked by policy ${aggregate.policyId}`;
-      await appendEvent(invocation, {
-        eventType: "ComplianceBlocked",
-        subjectType: "ActionInvocation",
-        subjectId: actionInvocationId,
-        payload: { actionId: action.actionId, policyId: aggregate.policyId, reason }
+        actionInvocationId,
+        actionId: action.actionId,
+        actorId: invocation.actorId,
+        actorType: invocation.actorType,
+        parameters: parsed.data,
+        db: options.store.db,
+        services: options.services,
+        mode: "execute"
       });
-      return fail(invocation, "blocked_by_policy", reason);
-    }
-    const binding = action.stateMachine;
-    if (binding) {
-      const entityId = binding.getEntityId(parsed.data);
-      const currentState = entityId ? await options.store.getEntityState(
-        tenantId,
-        spaceId,
-        binding.entityType,
-        entityId
-      ) ?? initialState(binding.entityType) : initialState(binding.entityType);
-      const targetState = typeof binding.targetState === "function" ? binding.targetState(parsed.data) : binding.targetState;
-      const transition = validateTransition(
-        binding.entityType,
-        currentState,
-        targetState,
-        action.actionId
-      );
-      if (!transition.valid) {
-        return fail(invocation, "failed", transition.error ?? "Invalid state transition");
+      for (const outcome of outcomes) {
+        await options.store.appendPolicyEvaluation({
+          id: lifecycleId("pol", actionInvocationId, outcome.policyId),
+          actionInvocationId,
+          tenantId,
+          spaceId,
+          outcome,
+          createdAt: now()
+        });
       }
-    }
-    let data;
-    let domainEvents = [];
-    try {
-      const handlerResult = await options.store.transaction(
-        (db) => action.handler ? action.handler(
-          {
-            actionInvocationId,
-            tenantId,
-            spaceId,
-            actorId: invocation.actorId,
-            actorType: invocation.actorType,
-            correlationId: invocation.correlationId,
-            ...invocation.causationId ? { causationId: invocation.causationId } : {},
-            db,
-            services: options.services
-          },
-          parsed.data
-        ) : Promise.resolve({ success: true, data: {} })
-      );
-      if (!handlerResult.success) {
-        return fail(invocation, "failed", handlerResult.error ?? "Action handler failed");
+      const aggregate = aggregatePolicyOutcomes(outcomes);
+      if (aggregate?.result === "block") {
+        const reason = aggregate.reason ?? `Blocked by policy ${aggregate.policyId}`;
+        await appendEvent(invocation, {
+          eventType: "ComplianceBlocked",
+          subjectType: "ActionInvocation",
+          subjectId: actionInvocationId,
+          payload: { actionId: action.actionId, policyId: aggregate.policyId, reason }
+        }, `compliance:${aggregate.policyId}`);
+        return fail(invocation, "blocked_by_policy", reason);
       }
-      data = handlerResult.data ?? {};
-      domainEvents = extractEvents(data);
-      if (action.eventPhase !== "after_adapters") {
-        for (const event of domainEvents) await appendEvent(invocation, event);
+      const binding = action.stateMachine;
+      if (binding) {
+        const entityId = binding.getEntityId(parsed.data);
+        const currentState = entityId ? await options.store.getEntityState(
+          tenantId,
+          spaceId,
+          binding.entityType,
+          entityId
+        ) ?? initialState(binding.entityType) : initialState(binding.entityType);
+        const targetState = typeof binding.targetState === "function" ? binding.targetState(parsed.data) : binding.targetState;
+        const transition = validateTransition(
+          binding.entityType,
+          currentState,
+          targetState,
+          action.actionId
+        );
+        const replayingAppliedTransition = action.idempotent && currentState === targetState;
+        if (!transition.valid && !replayingAppliedTransition) {
+          return fail(invocation, "failed", transition.error ?? "Invalid state transition");
+        }
       }
-    } catch (error) {
-      return fail(invocation, "failed", errorMessage(error));
-    }
-    for (const step of action.adapterSteps ?? []) {
-      const input = step.getInput(parsed.data, data);
-      if (!input) continue;
-      const adapter = adapters.require(step.adapterType, step.operation);
-      const adapterInvocationId = createFabricId("adp");
-      const adapterEventSubject = options.adapterEventSubject?.(
-        action.actionId,
-        parsed.data,
-        data
-      ) ?? { subjectType: "AdapterInvocation", subjectId: adapterInvocationId };
-      const recordedInput = options.redactAdapterInput ? options.redactAdapterInput(
-        action.actionId,
-        step.adapterType,
-        step.operation,
-        input
-      ) : input;
-      const startedAt = now();
-      const record = {
-        id: adapterInvocationId,
-        actionInvocationId,
-        tenantId,
-        spaceId,
-        adapterType: step.adapterType,
-        operation: step.operation,
-        vendor: adapter.vendor,
-        status: "running",
-        input: recordedInput,
-        attempt: 1,
-        createdAt: startedAt,
-        updatedAt: startedAt
-      };
-      await options.store.createAdapterInvocation(record);
-      await appendEvent(invocation, {
-        eventType: "AdapterInvocationStarted",
-        subjectType: adapterEventSubject.subjectType,
-        subjectId: adapterEventSubject.subjectId,
-        payload: { adapterType: step.adapterType, operation: step.operation }
-      });
+      let data;
+      let domainEvents = [];
       try {
-        const result2 = await executeWithAdapterRetry({
-          policy: step.retryPolicy ?? adapter.retryPolicy,
-          defaultIdempotent: adapter.idempotent,
-          execute: async (attempt, maxAttempts) => {
-            await options.store.updateAdapterInvocation(adapterInvocationId, {
-              attempt,
-              updatedAt: now()
-            });
-            return adapter.execute(input, {
+        const handlerResult = await options.store.transaction(
+          (db) => action.handler ? action.handler(
+            {
+              actionInvocationId,
               tenantId,
               spaceId,
-              actionInvocationId,
-              adapterInvocationId,
+              actorId: invocation.actorId,
+              actorType: invocation.actorType,
               correlationId: invocation.correlationId,
               ...invocation.causationId ? { causationId: invocation.causationId } : {},
-              attempt,
-              maxAttempts
+              db,
+              services: options.services
+            },
+            parsed.data
+          ) : Promise.resolve({ success: true, data: {} })
+        );
+        if (!handlerResult.success) {
+          return fail(invocation, "failed", handlerResult.error ?? "Action handler failed");
+        }
+        data = handlerResult.data ?? {};
+        domainEvents = extractEvents(data);
+        if (action.eventPhase !== "after_adapters") {
+          for (const [index, event] of domainEvents.entries()) {
+            await appendEvent(invocation, event, `domain:${index}`);
+          }
+        }
+      } catch (error) {
+        return fail(invocation, "failed", errorMessage(error));
+      }
+      for (const [stepIndex, step] of (action.adapterSteps ?? []).entries()) {
+        const input = step.getInput(parsed.data, data);
+        if (!input) continue;
+        const adapter = adapters.require(step.adapterType, step.operation);
+        const adapterInvocationId = lifecycleId("adp", actionInvocationId, String(stepIndex));
+        const previousAdapterInvocation = await options.store.getAdapterInvocation(
+          adapterInvocationId
+        );
+        if (previousAdapterInvocation?.status === "succeeded") continue;
+        const adapterEventSubject = options.adapterEventSubject?.(
+          action.actionId,
+          parsed.data,
+          data
+        ) ?? { subjectType: "AdapterInvocation", subjectId: adapterInvocationId };
+        const recordedInput = options.redactAdapterInput ? options.redactAdapterInput(
+          action.actionId,
+          step.adapterType,
+          step.operation,
+          input
+        ) : input;
+        const startedAt = now();
+        const record = {
+          id: adapterInvocationId,
+          actionInvocationId,
+          tenantId,
+          spaceId,
+          adapterType: step.adapterType,
+          operation: step.operation,
+          vendor: adapter.vendor,
+          status: "running",
+          input: recordedInput,
+          attempt: 1,
+          createdAt: startedAt,
+          updatedAt: startedAt
+        };
+        await options.store.createAdapterInvocation(record);
+        await appendEvent(invocation, {
+          eventType: "AdapterInvocationStarted",
+          subjectType: adapterEventSubject.subjectType,
+          subjectId: adapterEventSubject.subjectId,
+          payload: { adapterType: step.adapterType, operation: step.operation }
+        }, `adapter:${stepIndex}:started`);
+        try {
+          const result2 = await executeWithAdapterRetry({
+            policy: step.retryPolicy ?? adapter.retryPolicy,
+            defaultIdempotent: adapter.idempotent,
+            execute: async (attempt, maxAttempts) => {
+              await options.store.updateAdapterInvocation(adapterInvocationId, {
+                attempt,
+                updatedAt: now()
+              });
+              return adapter.execute(input, {
+                tenantId,
+                spaceId,
+                actionInvocationId,
+                adapterInvocationId,
+                correlationId: invocation.correlationId,
+                ...invocation.causationId ? { causationId: invocation.causationId } : {},
+                attempt,
+                maxAttempts
+              });
+            },
+            isSuccessful: (result3) => result3.success,
+            getError: (result3) => result3.error
+          });
+          if (!result2.success) {
+            await options.store.updateAdapterInvocation(adapterInvocationId, {
+              status: "failed",
+              error: result2.error ?? "Adapter failed",
+              updatedAt: now()
             });
-          },
-          isSuccessful: (result3) => result3.success,
-          getError: (result3) => result3.error
-        });
-        if (!result2.success) {
+            await appendEvent(invocation, {
+              eventType: "AdapterInvocationFailed",
+              subjectType: adapterEventSubject.subjectType,
+              subjectId: adapterEventSubject.subjectId,
+              payload: { adapterType: step.adapterType, operation: step.operation }
+            }, `adapter:${stepIndex}:failed`);
+            return fail(invocation, "failed", result2.error ?? "Adapter failed");
+          }
+          const resultRecord = result2;
+          const output = isRecord(resultRecord.output) ? resultRecord.output : Object.fromEntries(
+            Object.entries(resultRecord).filter(
+              ([key]) => key !== "success" && key !== "error"
+            )
+          );
           await options.store.updateAdapterInvocation(adapterInvocationId, {
-            status: "failed",
-            error: result2.error ?? "Adapter failed",
+            status: "succeeded",
+            output,
             updatedAt: now()
           });
           await appendEvent(invocation, {
-            eventType: "AdapterInvocationFailed",
+            eventType: "AdapterInvocationSucceeded",
             subjectType: adapterEventSubject.subjectType,
             subjectId: adapterEventSubject.subjectId,
-            payload: { adapterType: step.adapterType, operation: step.operation }
+            payload: {
+              adapterType: step.adapterType,
+              operation: step.operation,
+              input: recordedInput,
+              output
+            }
+          }, `adapter:${stepIndex}:succeeded`);
+        } catch (error) {
+          const message = errorMessage(error);
+          await options.store.updateAdapterInvocation(adapterInvocationId, {
+            status: "failed",
+            error: message,
+            updatedAt: now()
           });
-          return fail(invocation, "failed", result2.error ?? "Adapter failed");
+          return fail(invocation, "failed", message);
         }
-        const resultRecord = result2;
-        const output = isRecord(resultRecord.output) ? resultRecord.output : Object.fromEntries(
-          Object.entries(resultRecord).filter(
-            ([key]) => key !== "success" && key !== "error"
-          )
-        );
-        await options.store.updateAdapterInvocation(adapterInvocationId, {
-          status: "succeeded",
-          output,
-          updatedAt: now()
-        });
-        await appendEvent(invocation, {
-          eventType: "AdapterInvocationSucceeded",
-          subjectType: adapterEventSubject.subjectType,
-          subjectId: adapterEventSubject.subjectId,
-          payload: {
-            adapterType: step.adapterType,
-            operation: step.operation,
-            input: recordedInput,
-            output
-          }
-        });
-      } catch (error) {
-        const message = errorMessage(error);
-        await options.store.updateAdapterInvocation(adapterInvocationId, {
-          status: "failed",
-          error: message,
-          updatedAt: now()
-        });
-        return fail(invocation, "failed", message);
       }
+      if (action.eventPhase === "after_adapters") {
+        for (const [index, event] of domainEvents.entries()) {
+          await appendEvent(invocation, event, `domain:${index}`);
+        }
+      }
+      const result = withoutPrivateHostFields(data);
+      await options.store.updateActionInvocation(actionInvocationId, tenantId, spaceId, {
+        status: "completed",
+        result
+      });
+      return { actionInvocationId, status: "completed", result };
+    } catch (error) {
+      return fail(invocation, "failed", errorMessage(error));
     }
-    if (action.eventPhase === "after_adapters") {
-      for (const event of domainEvents) await appendEvent(invocation, event);
-    }
-    const result = withoutPrivateHostFields(data);
-    await options.store.updateActionInvocation(actionInvocationId, tenantId, spaceId, {
-      status: "completed",
-      result
-    });
-    return { actionInvocationId, status: "completed", result };
   }
-  async function appendEvent(invocation, event) {
+  async function appendEvent(invocation, event, deduplicationKey) {
     const timestamp = now();
     const envelope = {
-      id: createFabricId("evt"),
+      id: lifecycleId("evt", invocation.id, deduplicationKey),
       tenantId: invocation.tenantId,
       spaceId: invocation.spaceId,
       eventType: event.eventType,
@@ -375,6 +405,10 @@ function errorMessage(error) {
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
+function lifecycleId(prefix, invocationId, key) {
+  const safeKey = key.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 96);
+  return `${prefix}_${invocationId}_${safeKey}`;
+}
 
 // src/memory-store.ts
 var MemoryPlatformHostStore = class {
@@ -390,8 +424,14 @@ var MemoryPlatformHostStore = class {
     return run(this.db);
   }
   async createActionInvocation(input) {
+    if (input.idempotencyKey) {
+      const existing = this.invocations.find(
+        (record2) => record2.tenantId === input.tenantId && record2.spaceId === input.spaceId && record2.actionId === input.actionId && record2.idempotencyKey === input.idempotencyKey
+      );
+      if (existing) return existing;
+    }
     const now = /* @__PURE__ */ new Date();
-    const record = { ...input, createdAt: now, updatedAt: now };
+    const record = { ...input, attemptCount: 0, createdAt: now, updatedAt: now };
     this.invocations.push(record);
     return record;
   }
@@ -406,17 +446,23 @@ var MemoryPlatformHostStore = class {
     Object.assign(record, patch, { updatedAt: /* @__PURE__ */ new Date() });
   }
   async appendPolicyEvaluation(record) {
+    if (this.policyEvaluations.some((candidate) => candidate.id === record.id)) return;
     this.policyEvaluations.push(record);
   }
   async createAdapterInvocation(record) {
+    if (this.adapterInvocations.some((candidate) => candidate.id === record.id)) return;
     this.adapterInvocations.push(record);
   }
+  async getAdapterInvocation(id) {
+    return this.adapterInvocations.find((candidate) => candidate.id === id);
+  }
   async updateAdapterInvocation(id, patch) {
     const record = this.adapterInvocations.find((candidate) => candidate.id === id);
     if (!record) throw new Error(`AdapterInvocation not found: ${id}`);
     Object.assign(record, patch);
   }
   async appendEvent(event) {
+    if (this.events.some((candidate) => candidate.id === event.id)) return;
     this.events.push(event);
   }
   async nextEventSequence(tenantId, spaceId) {
@@ -433,6 +479,28 @@ var MemoryPlatformHostStore = class {
     }
     return state;
   }
+  async listActionInvocations(input = {}) {
+    return this.invocations.filter(
+      (record) => (!input.tenantId || record.tenantId === input.tenantId) && (!input.spaceId || record.spaceId === input.spaceId) && (!input.statuses?.length || input.statuses.includes(record.status)) && (!input.updatedBefore || record.updatedAt < input.updatedBefore)
+    ).sort((left, right) => left.createdAt.getTime() - right.createdAt.getTime()).slice(0, input.limit ?? 100);
+  }
+  async claimActionInvocations(input) {
+    const current = input.now ?? /* @__PURE__ */ new Date();
+    const eligible = this.invocations.filter(
+      (record) => (!input.tenantId || record.tenantId === input.tenantId) && (!input.spaceId || record.spaceId === input.spaceId) && (record.status === "pending" || record.status === "running" && (!record.leaseExpiresAt || record.leaseExpiresAt <= current))
+    ).sort((left, right) => left.createdAt.getTime() - right.createdAt.getTime()).slice(0, input.limit ?? 10);
+    for (const record of eligible) {
+      record.status = "running";
+      record.leaseOwner = input.workerId;
+      record.leaseExpiresAt = new Date(current.getTime() + input.leaseDurationMs);
+      record.attemptCount += 1;
+      record.updatedAt = current;
+    }
+    return eligible;
+  }
+  async listEvents(tenantId, spaceId) {
+    return this.events.filter((event) => event.tenantId === tenantId && event.spaceId === spaceId).sort((left, right) => left.sequence - right.sequence);
+  }
 };
 
 // src/postgres-store.ts
@@ -451,9 +519,22 @@ var PostgresPlatformHostStore = class {
 				action_id text NOT NULL, action_version integer NOT NULL,
 				actor_id text NOT NULL, actor_type text NOT NULL, status text NOT NULL,
 				parameters jsonb NOT NULL, result jsonb NOT NULL DEFAULT '{}'::jsonb,
-				correlation_id text NOT NULL, causation_id text, error text,
+				correlation_id text NOT NULL, causation_id text, idempotency_key text, error text,
+				attempt_count integer NOT NULL DEFAULT 0, lease_owner text,
+				lease_expires_at timestamptz,
 				created_at timestamptz NOT NULL, updated_at timestamptz NOT NULL
 			);
+			ALTER TABLE fabric_platform.action_invocations
+				ADD COLUMN IF NOT EXISTS idempotency_key text,
+				ADD COLUMN IF NOT EXISTS attempt_count integer NOT NULL DEFAULT 0,
+				ADD COLUMN IF NOT EXISTS lease_owner text,
+				ADD COLUMN IF NOT EXISTS lease_expires_at timestamptz;
+			CREATE UNIQUE INDEX IF NOT EXISTS action_invocations_idempotency_idx
+				ON fabric_platform.action_invocations
+				(tenant_id, space_id, action_id, idempotency_key)
+				WHERE idempotency_key IS NOT NULL;
+			CREATE INDEX IF NOT EXISTS action_invocations_worker_idx
+				ON fabric_platform.action_invocations (status, lease_expires_at, created_at);
 			CREATE TABLE IF NOT EXISTS fabric_platform.policy_evaluations (
 				id text PRIMARY KEY, action_invocation_id text NOT NULL,
 				tenant_id text NOT NULL, space_id text NOT NULL, outcome jsonb NOT NULL,
@@ -490,11 +571,14 @@ var PostgresPlatformHostStore = class {
   }
   async createActionInvocation(input) {
     const now = /* @__PURE__ */ new Date();
-    await this.sql.query(
+    const result = await this.sql.query(
       `INSERT INTO fabric_platform.action_invocations
 			 (id,tenant_id,space_id,action_id,action_version,actor_id,actor_type,status,
-			  parameters,result,correlation_id,causation_id,error,created_at,updated_at)
-			 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9::jsonb,$10::jsonb,$11,$12,$13,$14,$14)`,
+			  parameters,result,correlation_id,causation_id,idempotency_key,error,created_at,updated_at)
+			 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9::jsonb,$10::jsonb,$11,$12,$13,$14,$15,$15)
+			 ON CONFLICT (tenant_id,space_id,action_id,idempotency_key)
+			 WHERE idempotency_key IS NOT NULL DO UPDATE SET id=fabric_platform.action_invocations.id
+			 RETURNING *`,
       [
         input.id,
         input.tenantId,
@@ -508,11 +592,12 @@ var PostgresPlatformHostStore = class {
         JSON.stringify(input.result),
         input.correlationId,
         input.causationId ?? null,
+        input.idempotencyKey ?? null,
         input.error ?? null,
         now
       ]
     );
-    return { ...input, createdAt: now, updatedAt: now };
+    return toActionRecord(result.rows[0]);
   }
   async getActionInvocation(id, tenantId, spaceId) {
     const result = await this.sql.query(
@@ -526,7 +611,12 @@ var PostgresPlatformHostStore = class {
     await this.sql.query(
       `UPDATE fabric_platform.action_invocations SET
 			 status=COALESCE($4,status), result=COALESCE($5::jsonb,result),
-			 error=CASE WHEN $6::boolean THEN $7 ELSE error END, updated_at=now()
+			 error=CASE WHEN $6::boolean THEN $7 ELSE error END,
+			 lease_owner=CASE WHEN $4 IN ('completed','failed','blocked_by_policy','validation_failed')
+			                  THEN NULL ELSE lease_owner END,
+			 lease_expires_at=CASE WHEN $4 IN ('completed','failed','blocked_by_policy','validation_failed')
+			                       THEN NULL ELSE lease_expires_at END,
+			 updated_at=now()
 			 WHERE id=$1 AND tenant_id=$2 AND space_id=$3`,
       [
         id,
@@ -543,7 +633,7 @@ var PostgresPlatformHostStore = class {
     await this.sql.query(
       `INSERT INTO fabric_platform.policy_evaluations
 			 (id,action_invocation_id,tenant_id,space_id,outcome,created_at)
-			 VALUES ($1,$2,$3,$4,$5::jsonb,$6)`,
+			 VALUES ($1,$2,$3,$4,$5::jsonb,$6) ON CONFLICT (id) DO NOTHING`,
       [
         record.id,
         record.actionInvocationId,
@@ -559,7 +649,8 @@ var PostgresPlatformHostStore = class {
       `INSERT INTO fabric_platform.adapter_invocations
 			 (id,action_invocation_id,tenant_id,space_id,adapter_type,operation,vendor,status,
 			  input,output,error,attempt,created_at,updated_at)
-			 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9::jsonb,$10::jsonb,$11,$12,$13,$14)`,
+			 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9::jsonb,$10::jsonb,$11,$12,$13,$14)
+			 ON CONFLICT (id) DO NOTHING`,
       [
         record.id,
         record.actionInvocationId,
@@ -578,6 +669,13 @@ var PostgresPlatformHostStore = class {
       ]
     );
   }
+  async getAdapterInvocation(id) {
+    const result = await this.sql.query(
+      `SELECT * FROM fabric_platform.adapter_invocations WHERE id=$1`,
+      [id]
+    );
+    return result.rows[0] ? toAdapterRecord(result.rows[0]) : void 0;
+  }
   async updateAdapterInvocation(id, patch) {
     await this.sql.query(
       `UPDATE fabric_platform.adapter_invocations SET
@@ -601,7 +699,8 @@ var PostgresPlatformHostStore = class {
 			 (id,tenant_id,space_id,event_type,event_schema_version,subject_type,subject_id,
 			  actor_id,actor_type,action_invocation_id,payload,sequence,occurred_at,recorded_at,
 			  correlation_id,causation_id)
-			 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11::jsonb,$12,$13,$14,$15,$16)`,
+				 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11::jsonb,$12,$13,$14,$15,$16)
+				 ON CONFLICT (id) DO NOTHING`,
       [
         event.id,
         event.tenantId,
@@ -641,6 +740,57 @@ var PostgresPlatformHostStore = class {
     );
     return result.rows[0]?.state;
   }
+  async listActionInvocations(input = {}) {
+    const conditions = [];
+    const values = [];
+    const add = (condition, value) => {
+      values.push(value);
+      conditions.push(condition.replace("?", `$${values.length}`));
+    };
+    if (input.tenantId) add("tenant_id=?", input.tenantId);
+    if (input.spaceId) add("space_id=?", input.spaceId);
+    if (input.statuses?.length) add("status = ANY(?::text[])", [...input.statuses]);
+    if (input.updatedBefore) add("updated_at<?", input.updatedBefore);
+    values.push(Math.max(1, Math.min(input.limit ?? 100, 1e3)));
+    const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = await this.sql.query(
+      `SELECT * FROM fabric_platform.action_invocations ${where}
+			 ORDER BY created_at LIMIT $${values.length}`,
+      values
+    );
+    return result.rows.map(toActionRecord);
+  }
+  async claimActionInvocations(input) {
+    const current = input.now ?? /* @__PURE__ */ new Date();
+    const limit = Math.max(1, Math.min(input.limit ?? 10, 100));
+    const leaseExpiresAt = new Date(current.getTime() + input.leaseDurationMs);
+    const result = await this.sql.query(
+      `WITH claimable AS (
+				SELECT id FROM fabric_platform.action_invocations
+				WHERE (status='pending' OR
+				       (status='running' AND (lease_expires_at IS NULL OR lease_expires_at <= $1)))
+				  AND ($2::text IS NULL OR tenant_id=$2)
+				  AND ($3::text IS NULL OR space_id=$3)
+				ORDER BY created_at
+				FOR UPDATE SKIP LOCKED
+				LIMIT $4
+			)
+			UPDATE fabric_platform.action_invocations AS invocation
+			SET status='running', lease_owner=$5, lease_expires_at=$6,
+			    attempt_count=attempt_count+1, updated_at=$1
+			FROM claimable WHERE invocation.id=claimable.id
+			RETURNING invocation.*`,
+      [
+        current,
+        input.tenantId ?? null,
+        input.spaceId ?? null,
+        limit,
+        input.workerId,
+        leaseExpiresAt
+      ]
+    );
+    return result.rows.map(toActionRecord);
+  }
   async listEvents(tenantId, spaceId) {
     const result = await this.sql.query(
       `SELECT * FROM fabric_platform.asset_events
@@ -650,6 +800,24 @@ var PostgresPlatformHostStore = class {
     return result.rows.map(toEventRecord);
   }
 };
+function toAdapterRecord(row) {
+  return {
+    id: String(row.id),
+    actionInvocationId: String(row.action_invocation_id),
+    tenantId: String(row.tenant_id),
+    spaceId: String(row.space_id),
+    adapterType: String(row.adapter_type),
+    operation: String(row.operation),
+    vendor: String(row.vendor),
+    status: String(row.status),
+    input: row.input,
+    ...row.output ? { output: row.output } : {},
+    ...row.error ? { error: String(row.error) } : {},
+    attempt: Number(row.attempt),
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
 function toActionRecord(row) {
   return {
     id: String(row.id),
@@ -664,6 +832,10 @@ function toActionRecord(row) {
     result: row.result,
     correlationId: String(row.correlation_id),
     ...row.causation_id ? { causationId: String(row.causation_id) } : {},
+    ...row.idempotency_key ? { idempotencyKey: String(row.idempotency_key) } : {},
+    attemptCount: Number(row.attempt_count ?? 0),
+    ...row.lease_owner ? { leaseOwner: String(row.lease_owner) } : {},
+    ...row.lease_expires_at ? { leaseExpiresAt: new Date(row.lease_expires_at) } : {},
     ...row.error ? { error: String(row.error) } : {},
     createdAt: new Date(row.created_at),
     updatedAt: new Date(row.updated_at)
@@ -690,6 +862,66 @@ function toEventRecord(row) {
   };
 }
 
-export { MemoryPlatformHostStore, PostgresPlatformHostStore, createGovernedActionHost };
+// src/worker.ts
+var DEFAULT_BATCH_SIZE = 10;
+var DEFAULT_LEASE_DURATION_MS = 5 * 6e4;
+var DEFAULT_POLL_INTERVAL_MS = 1e3;
+function createStoreBackedActionDispatcher() {
+  return {
+    dispatch: async (input) => ({ workflowId: input.workflowId })
+  };
+}
+async function runPlatformActionWorkerCycle(options) {
+  const claimed = await options.store.claimActionInvocations({
+    workerId: options.workerId,
+    limit: options.batchSize ?? DEFAULT_BATCH_SIZE,
+    leaseDurationMs: options.leaseDurationMs ?? DEFAULT_LEASE_DURATION_MS,
+    ...options.tenantId ? { tenantId: options.tenantId } : {},
+    ...options.spaceId ? { spaceId: options.spaceId } : {}
+  });
+  let completed = 0;
+  let failed = 0;
+  for (const invocation of claimed) {
+    try {
+      const result = await options.host.executeInvocation(
+        invocation.id,
+        invocation.tenantId,
+        invocation.spaceId
+      );
+      if (result.status === "completed") completed += 1;
+      else failed += 1;
+    } catch (error) {
+      failed += 1;
+      options.onError?.(error, invocation);
+    }
+  }
+  return { claimed: claimed.length, completed, failed };
+}
+async function runPlatformActionWorker(options) {
+  while (!options.signal?.aborted) {
+    try {
+      await runPlatformActionWorkerCycle(options);
+    } catch (error) {
+      options.onError?.(error);
+    }
+    await abortableDelay(options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS, options.signal);
+  }
+}
+async function abortableDelay(milliseconds, signal) {
+  if (signal?.aborted) return;
+  await new Promise((resolve) => {
+    const timeout = setTimeout(resolve, milliseconds);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timeout);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
+
+export { MemoryPlatformHostStore, PostgresPlatformHostStore, createGovernedActionHost, createStoreBackedActionDispatcher, runPlatformActionWorker, runPlatformActionWorkerCycle };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map