@fabricorg/platform-host 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -47,7 +47,9 @@ function createGovernedActionHost(options) {
         status: durableInvocation.status,
         workflowId: durableWorkflowId,
         result: durableInvocation.result,
-        ...durableInvocation.error ? { error: durableInvocation.error } : {}
+        ...durableInvocation.error ? { error: durableInvocation.error } : {},
+        ...durableInvocation.hitlRoute ? { hitlRoute: durableInvocation.hitlRoute } : {},
+        ...durableInvocation.hitlRiskTier ? { hitlRiskTier: durableInvocation.hitlRiskTier } : {}
       };
     }
     if (options.dispatcher) {
@@ -62,7 +64,9 @@ function createGovernedActionHost(options) {
           actionInvocationId: durableInvocation.id,
           status: durableInvocation.status,
           workflowId: dispatched.workflowId,
-          ...dispatched.runId ? { runId: dispatched.runId } : {}
+          ...dispatched.runId ? { runId: dispatched.runId } : {},
+          ...durableInvocation.hitlRoute ? { hitlRoute: durableInvocation.hitlRoute } : {},
+          ...durableInvocation.hitlRiskTier ? { hitlRiskTier: durableInvocation.hitlRiskTier } : {}
         };
       } catch (error) {
         const message = errorMessage(error);
@@ -82,34 +86,98 @@ function createGovernedActionHost(options) {
     );
     return { ...executed, workflowId: durableWorkflowId };
   }
-  async function executeInvocation(actionInvocationId, tenantId, spaceId) {
-    const invocation = await options.store.getActionInvocation(
+  async function executeInvocation(actionInvocationId, tenantId, spaceId, executionOptions = {}) {
+    const loadedInvocation = await options.store.getActionInvocation(
       actionInvocationId,
       tenantId,
       spaceId
     );
-    if (!invocation) throw new Error(`ActionInvocation not found: ${actionInvocationId}`);
-    if (isTerminal(invocation.status)) {
+    if (!loadedInvocation) {
+      throw new Error(`ActionInvocation not found: ${actionInvocationId}`);
+    }
+    let invocation = loadedInvocation;
+    if (isTerminal(invocation.status) || invocation.status === "waiting_for_approval") {
+      return actionResult(invocation);
+    }
+    if (invocation.status === "running" && invocation.leaseOwner && executionOptions.leaseOwner !== invocation.leaseOwner) {
       return {
-        actionInvocationId,
-        status: invocation.status,
-        result: invocation.result,
-        ...invocation.error ? { error: invocation.error } : {}
+        ...actionResult(invocation),
+        error: `Invocation is leased by ${invocation.leaseOwner}`
       };
     }
     const action = platform.resolveAction(invocation.actionId);
     if (!action) {
       return fail(invocation, "failed", `Unknown action: ${invocation.actionId}`);
     }
-    await options.store.updateActionInvocation(actionInvocationId, tenantId, spaceId, {
-      status: "running"
-    });
+    if (invocation.attemptCount > 1 && !action.idempotent) {
+      return fail(
+        invocation,
+        "failed",
+        `Interrupted action ${invocation.actionId} is not declared idempotent; manual reconciliation is required.`
+      );
+    }
+    if (invocation.status !== "running") {
+      await options.store.updateActionInvocation(actionInvocationId, tenantId, spaceId, {
+        status: "running"
+      });
+    }
     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);
       }
+      if (invocation.actorType === "agent" && options.hitlEvaluator) {
+        const hitlParameters = isRecord(parsed.data) ? parsed.data : invocation.parameters;
+        const approvalStore = asApprovalStore(options.store);
+        if (!approvalStore) {
+          return fail(
+            invocation,
+            "failed",
+            "The configured HITL evaluator requires a store with approval persistence support."
+          );
+        }
+        if (!invocation.hitlRoute) {
+          const decision = await options.hitlEvaluator({
+            actionId: action.actionId,
+            actorId: invocation.actorId,
+            actorType: invocation.actorType,
+            tenantId,
+            spaceId,
+            parameters: hitlParameters,
+            ...numberValue(hitlParameters.confidence) !== void 0 ? { confidence: numberValue(hitlParameters.confidence) } : {},
+            ...isRiskTier(hitlParameters.riskTier) ? { riskTier: hitlParameters.riskTier } : {},
+            ...stringValue(hitlParameters.agentSessionId) ? { agentSessionId: stringValue(hitlParameters.agentSessionId) } : {},
+            ...stringValue(hitlParameters.agentRunId) ? { agentRunId: stringValue(hitlParameters.agentRunId) } : {}
+          });
+          invocation = await approvalStore.recordHitlDecision(
+            actionInvocationId,
+            tenantId,
+            spaceId,
+            {
+              ...decision,
+              ...options.hitlPolicyVersion ? { policyVersion: options.hitlPolicyVersion } : {},
+              evaluatedAt: now()
+            }
+          );
+        }
+        if (invocation.hitlRoute === "rejected") {
+          return fail(
+            invocation,
+            "failed",
+            `HITL rejected: ${invocation.hitlReason ?? "no reason provided"}`
+          );
+        }
+        if ((invocation.hitlRoute === "needs-approval" || invocation.hitlRoute === "escalate") && !invocation.approvalDecision?.approved) {
+          await options.store.updateActionInvocation(actionInvocationId, tenantId, spaceId, {
+            status: "waiting_for_approval"
+          });
+          return {
+            ...actionResult(invocation),
+            status: "waiting_for_approval"
+          };
+        }
+      }
       const authorizationInput = toAuthorizationInput(action, invocation);
       const definitions = options.resolvePolicies ? await options.resolvePolicies({
         ...authorizationInput,
@@ -129,7 +197,7 @@ function createGovernedActionHost(options) {
       });
       for (const outcome of outcomes) {
         await options.store.appendPolicyEvaluation({
-          id: platform.createFabricId("pol"),
+          id: lifecycleId("pol", actionInvocationId, outcome.policyId),
           actionInvocationId,
           tenantId,
           spaceId,
@@ -145,7 +213,7 @@ function createGovernedActionHost(options) {
           subjectType: "ActionInvocation",
           subjectId: actionInvocationId,
           payload: { actionId: action.actionId, policyId: aggregate.policyId, reason }
-        });
+        }, `compliance:${aggregate.policyId}`);
         return fail(invocation, "blocked_by_policy", reason);
       }
       const binding = action.stateMachine;
@@ -164,7 +232,8 @@ function createGovernedActionHost(options) {
           targetState,
           action.actionId
         );
-        if (!transition.valid) {
+        const replayingAppliedTransition = action.idempotent && currentState === targetState;
+        if (!transition.valid && !replayingAppliedTransition) {
           return fail(invocation, "failed", transition.error ?? "Invalid state transition");
         }
       }
@@ -193,16 +262,22 @@ function createGovernedActionHost(options) {
         data = handlerResult.data ?? {};
         domainEvents = extractEvents(data);
         if (action.eventPhase !== "after_adapters") {
-          for (const event of domainEvents) await appendEvent(invocation, event);
+          for (const [index, event] of domainEvents.entries()) {
+            await appendEvent(invocation, event, `domain:${index}`);
+          }
         }
       } catch (error) {
         return fail(invocation, "failed", errorMessage(error));
       }
-      for (const step of action.adapterSteps ?? []) {
+      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 = platform.createFabricId("adp");
+        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,
@@ -235,7 +310,7 @@ function createGovernedActionHost(options) {
           subjectType: adapterEventSubject.subjectType,
           subjectId: adapterEventSubject.subjectId,
           payload: { adapterType: step.adapterType, operation: step.operation }
-        });
+        }, `adapter:${stepIndex}:started`);
         try {
           const result2 = await platform.executeWithAdapterRetry({
             policy: step.retryPolicy ?? adapter.retryPolicy,
@@ -270,7 +345,7 @@ function createGovernedActionHost(options) {
               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;
@@ -294,7 +369,7 @@ function createGovernedActionHost(options) {
               input: recordedInput,
               output
             }
-          });
+          }, `adapter:${stepIndex}:succeeded`);
         } catch (error) {
           const message = errorMessage(error);
           await options.store.updateAdapterInvocation(adapterInvocationId, {
@@ -306,22 +381,93 @@ function createGovernedActionHost(options) {
         }
       }
       if (action.eventPhase === "after_adapters") {
-        for (const event of domainEvents) await appendEvent(invocation, event);
+        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 };
+      return {
+        actionInvocationId,
+        status: "completed",
+        result,
+        ...invocation.hitlRoute ? { hitlRoute: invocation.hitlRoute } : {},
+        ...invocation.hitlRiskTier ? { hitlRiskTier: invocation.hitlRiskTier } : {}
+      };
     } catch (error) {
       return fail(invocation, "failed", errorMessage(error));
     }
   }
-  async function appendEvent(invocation, event) {
+  async function resumeApprovedInvocation(actionInvocationId, tenantId, spaceId, decision) {
+    if (!decision.approverId.trim()) throw new Error("approverId is required");
+    const invocation = await options.store.getActionInvocation(
+      actionInvocationId,
+      tenantId,
+      spaceId
+    );
+    if (!invocation) throw new Error(`ActionInvocation not found: ${actionInvocationId}`);
+    if (isTerminal(invocation.status)) return actionResult(invocation);
+    if (invocation.status !== "waiting_for_approval") {
+      return {
+        ...actionResult(invocation),
+        error: `Invocation is not waiting for approval (status: ${invocation.status})`
+      };
+    }
+    const action = platform.resolveAction(invocation.actionId);
+    if (!action) return fail(invocation, "failed", `Unknown action: ${invocation.actionId}`);
+    const approvalAuthorizationInput = toAuthorizationInput(action, {
+      tenantId,
+      spaceId,
+      actorId: decision.approverId,
+      actorType: decision.approverType
+    });
+    const entitled = await options.authorization.checkEntitlement(
+      approvalAuthorizationInput
+    );
+    const authorized = options.authorization.authorizeApproval ? await options.authorization.authorizeApproval({
+      ...approvalAuthorizationInput,
+      decision
+    }) : await options.authorization.authorize(approvalAuthorizationInput);
+    if (!entitled || !authorized) {
+      return {
+        ...actionResult(invocation),
+        error: `Actor ${decision.approverId} is not authorized to decide this approval`
+      };
+    }
+    const approvalStore = asApprovalStore(options.store);
+    if (!approvalStore) {
+      return {
+        ...actionResult(invocation),
+        error: "Approval resume requires a store with approval persistence support."
+      };
+    }
+    const transitionStartedAt = now();
+    const decidedAt = decision.decidedAt ?? transitionStartedAt;
+    const leaseOwner = `approval-resume-${platform.createFabricId("lease")}`;
+    const transition = await approvalStore.beginApprovalDecision({
+      actionInvocationId,
+      tenantId,
+      spaceId,
+      decision: { ...decision, decidedAt },
+      leaseOwner,
+      leaseDurationMs: options.approvalResumeLeaseDurationMs ?? 5 * 6e4,
+      now: transitionStartedAt
+    });
+    const transitioned = transition.invocation ?? await options.store.getActionInvocation(actionInvocationId, tenantId, spaceId);
+    if (!transition.applied || !transitioned) {
+      if (!transitioned) throw new Error(`ActionInvocation not found: ${actionInvocationId}`);
+      return actionResult(transitioned);
+    }
+    if (!decision.approved) return actionResult(transitioned);
+    return executeInvocation(actionInvocationId, tenantId, spaceId, { leaseOwner });
+  }
+  async function appendEvent(invocation, event, deduplicationKey) {
     const timestamp = now();
     const envelope = {
-      id: platform.createFabricId("evt"),
+      id: lifecycleId("evt", invocation.id, deduplicationKey),
       tenantId: invocation.tenantId,
       spaceId: invocation.spaceId,
       eventType: event.eventType,
@@ -350,9 +496,38 @@ function createGovernedActionHost(options) {
       invocation.spaceId,
       { status, error }
     );
-    return { actionInvocationId: invocation.id, status, error };
+    return {
+      actionInvocationId: invocation.id,
+      status,
+      error,
+      ...invocation.hitlRoute ? { hitlRoute: invocation.hitlRoute } : {},
+      ...invocation.hitlRiskTier ? { hitlRiskTier: invocation.hitlRiskTier } : {}
+    };
   }
-  return { submitAction, executeInvocation };
+  return { submitAction, executeInvocation, resumeApprovedInvocation };
+}
+function actionResult(invocation) {
+  return {
+    actionInvocationId: invocation.id,
+    status: invocation.status,
+    result: invocation.result,
+    ...invocation.error ? { error: invocation.error } : {},
+    ...invocation.hitlRoute ? { hitlRoute: invocation.hitlRoute } : {},
+    ...invocation.hitlRiskTier ? { hitlRiskTier: invocation.hitlRiskTier } : {}
+  };
+}
+function asApprovalStore(store) {
+  const candidate = store;
+  return typeof candidate.recordHitlDecision === "function" && typeof candidate.beginApprovalDecision === "function" ? store : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function isRiskTier(value) {
+  return value === "low" || value === "medium" || value === "high";
 }
 function toAuthorizationInput(action, input) {
   return {
@@ -391,6 +566,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 {
@@ -426,19 +605,64 @@ var MemoryPlatformHostStore = class {
     const record = await this.getActionInvocation(id, tenantId, spaceId);
     if (!record) throw new Error(`ActionInvocation not found: ${id}`);
     Object.assign(record, patch, { updatedAt: /* @__PURE__ */ new Date() });
+    if (patch.status === "waiting_for_approval" || patch.status === "completed" || patch.status === "failed" || patch.status === "blocked_by_policy" || patch.status === "validation_failed") {
+      delete record.leaseOwner;
+      delete record.leaseExpiresAt;
+    }
+  }
+  async recordHitlDecision(actionInvocationId, tenantId, spaceId, decision) {
+    const record = await this.getActionInvocation(actionInvocationId, tenantId, spaceId);
+    if (!record) throw new Error(`ActionInvocation not found: ${actionInvocationId}`);
+    record.hitlRoute = decision.route;
+    record.hitlRiskTier = decision.riskTier;
+    record.hitlReason = decision.reason;
+    if (decision.policyVersion) record.hitlPolicyVersion = decision.policyVersion;
+    record.updatedAt = decision.evaluatedAt;
+    return record;
+  }
+  async beginApprovalDecision(input) {
+    const record = await this.getActionInvocation(
+      input.actionInvocationId,
+      input.tenantId,
+      input.spaceId
+    );
+    if (!record || record.status !== "waiting_for_approval") {
+      return { applied: false, ...record ? { invocation: record } : {} };
+    }
+    record.approvalDecision = input.decision;
+    record.updatedAt = input.now;
+    if (!input.decision.approved) {
+      record.status = "failed";
+      record.error = `Approval rejected: ${input.decision.reason ?? "no reason provided"}`;
+      delete record.leaseOwner;
+      delete record.leaseExpiresAt;
+      return { applied: true, invocation: record };
+    }
+    record.status = "running";
+    record.error = void 0;
+    record.leaseOwner = input.leaseOwner;
+    record.leaseExpiresAt = new Date(input.now.getTime() + input.leaseDurationMs);
+    record.attemptCount = Math.max(record.attemptCount, 1);
+    return { applied: true, invocation: record };
   }
   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) {
@@ -497,14 +721,20 @@ var PostgresPlatformHostStore = class {
 				parameters jsonb NOT NULL, result jsonb NOT NULL DEFAULT '{}'::jsonb,
 				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,
+				lease_expires_at timestamptz, hitl_route text, hitl_risk_tier text,
+				hitl_reason text, hitl_policy_version text, approval_decision jsonb,
 				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;
+				ADD COLUMN IF NOT EXISTS lease_expires_at timestamptz,
+				ADD COLUMN IF NOT EXISTS hitl_route text,
+				ADD COLUMN IF NOT EXISTS hitl_risk_tier text,
+				ADD COLUMN IF NOT EXISTS hitl_reason text,
+				ADD COLUMN IF NOT EXISTS hitl_policy_version text,
+				ADD COLUMN IF NOT EXISTS approval_decision jsonb;
 			CREATE UNIQUE INDEX IF NOT EXISTS action_invocations_idempotency_idx
 				ON fabric_platform.action_invocations
 				(tenant_id, space_id, action_id, idempotency_key)
@@ -588,9 +818,9 @@ var PostgresPlatformHostStore = class {
       `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,
-			 lease_owner=CASE WHEN $4 IN ('completed','failed','blocked_by_policy','validation_failed')
+			 lease_owner=CASE WHEN $4 IN ('waiting_for_approval','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')
+			 lease_expires_at=CASE WHEN $4 IN ('waiting_for_approval','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`,
@@ -605,11 +835,59 @@ var PostgresPlatformHostStore = class {
       ]
     );
   }
+  async recordHitlDecision(actionInvocationId, tenantId, spaceId, decision) {
+    const result = await this.sql.query(
+      `UPDATE fabric_platform.action_invocations SET
+			 hitl_route=$4, hitl_risk_tier=$5, hitl_reason=$6,
+			 hitl_policy_version=$7, updated_at=$8
+			 WHERE id=$1 AND tenant_id=$2 AND space_id=$3
+			 RETURNING *`,
+      [
+        actionInvocationId,
+        tenantId,
+        spaceId,
+        decision.route,
+        decision.riskTier,
+        decision.reason,
+        decision.policyVersion ?? null,
+        decision.evaluatedAt
+      ]
+    );
+    const row = result.rows[0];
+    if (!row) throw new Error(`ActionInvocation not found: ${actionInvocationId}`);
+    return toActionRecord(row);
+  }
+  async beginApprovalDecision(input) {
+    const result = await this.sql.query(
+      `UPDATE fabric_platform.action_invocations SET
+			 approval_decision=$4::jsonb,
+			 status=CASE WHEN $5::boolean THEN 'running' ELSE 'failed' END,
+			 error=CASE WHEN $5::boolean THEN NULL ELSE $6 END,
+			 lease_owner=CASE WHEN $5::boolean THEN $7 ELSE NULL END,
+			 lease_expires_at=CASE WHEN $5::boolean THEN $8 ELSE NULL END,
+			 attempt_count=CASE WHEN $5::boolean THEN GREATEST(attempt_count,1) ELSE attempt_count END,
+			 updated_at=$9
+			 WHERE id=$1 AND tenant_id=$2 AND space_id=$3 AND status='waiting_for_approval'
+			 RETURNING *`,
+      [
+        input.actionInvocationId,
+        input.tenantId,
+        input.spaceId,
+        JSON.stringify({ ...input.decision, decidedAt: input.decision.decidedAt.toISOString() }),
+        input.decision.approved,
+        `Approval rejected: ${input.decision.reason ?? "no reason provided"}`,
+        input.leaseOwner,
+        new Date(input.now.getTime() + input.leaseDurationMs),
+        input.now
+      ]
+    );
+    return result.rows[0] ? { applied: true, invocation: toActionRecord(result.rows[0]) } : { applied: false };
+  }
   async appendPolicyEvaluation(record) {
     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,
@@ -625,7 +903,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,
@@ -644,6 +923,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
@@ -667,7 +953,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,
@@ -767,6 +1054,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),
@@ -785,11 +1090,27 @@ function toActionRecord(row) {
     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.hitl_route ? { hitlRoute: String(row.hitl_route) } : {},
+    ...row.hitl_risk_tier ? { hitlRiskTier: String(row.hitl_risk_tier) } : {},
+    ...row.hitl_reason ? { hitlReason: String(row.hitl_reason) } : {},
+    ...row.hitl_policy_version ? { hitlPolicyVersion: String(row.hitl_policy_version) } : {},
+    ...row.approval_decision ? { approvalDecision: toApprovalDecision(row.approval_decision) } : {},
     ...row.error ? { error: String(row.error) } : {},
     createdAt: new Date(row.created_at),
     updatedAt: new Date(row.updated_at)
   };
 }
+function toApprovalDecision(value) {
+  const decision = value;
+  return {
+    approved: Boolean(decision.approved),
+    approverId: String(decision.approverId),
+    approverType: String(decision.approverType),
+    ...decision.reason ? { reason: String(decision.reason) } : {},
+    ...decision.editsReference ? { editsReference: String(decision.editsReference) } : {},
+    decidedAt: new Date(decision.decidedAt)
+  };
+}
 function toEventRecord(row) {
   return {
     id: String(row.id),
@@ -830,21 +1151,29 @@ async function runPlatformActionWorkerCycle(options) {
   });
   let completed = 0;
   let failed = 0;
+  let waitingForApproval = 0;
   for (const invocation of claimed) {
     try {
       const result = await options.host.executeInvocation(
         invocation.id,
         invocation.tenantId,
-        invocation.spaceId
+        invocation.spaceId,
+        { leaseOwner: options.workerId }
       );
       if (result.status === "completed") completed += 1;
+      else if (result.status === "waiting_for_approval") waitingForApproval += 1;
       else failed += 1;
     } catch (error) {
       failed += 1;
       options.onError?.(error, invocation);
     }
   }
-  return { claimed: claimed.length, completed, failed };
+  return {
+    claimed: claimed.length,
+    completed,
+    failed,
+    ...waitingForApproval > 0 ? { waitingForApproval } : {}
+  };
 }
 async function runPlatformActionWorker(options) {
   while (!options.signal?.aborted) {