python-hwpx-automation 6.0.3__py3-none-any.whl

hwpx_automation/workflow/dispatcher.py

@@ -0,0 +1,213 @@
+# SPDX-License-Identifier: Apache-2.0
+"""ToolSpec-bound allow-listed primitive dispatcher."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from hwpx_automation.tool_contract import expected_tool_names
+
+from .models import WorkFamily, WorkflowEvent, content_hash
+from .policy import ActionRequest, PolicyViolation, WorkflowPolicyEngine
+from .store import WorkflowStore
+
+
+FAMILY_TOOL_ALLOWLISTS: dict[WorkFamily, frozenset[str]] = {
+    WorkFamily.READ_EXTRACT: frozenset(
+        {
+            "get_document_text",
+            "get_document_info",
+            "get_document_outline",
+            "get_document_map",
+            "hwpx_to_markdown",
+            "hwpx_extract_json",
+        }
+    ),
+    WorkFamily.TRANSACTIONAL_EDIT: frozenset(
+        {
+            "get_document_info",
+            "apply_edits",
+            "undo_last_edit",
+            "doc_diff",
+        }
+    ),
+    WorkFamily.KNOWN_TEMPLATE_FILL: frozenset(
+        {
+            "list_form_fields", "fill_form_field", "analyze_template_formfit",
+            "apply_template_formfit", "inspect_fill_residue", "verify_form_fill",
+            "scan_form_guidance", "apply_table_ops",
+        }
+    ),
+    WorkFamily.UNKNOWN_FORM_FILL: frozenset(
+        {"scan_form_guidance", "apply_table_ops", "apply_body_ops", "inspect_fill_residue", "verify_form_fill"}
+    ),
+    WorkFamily.STRUCTURAL_TABLE_EDIT: frozenset(
+        {"scan_form_guidance", "apply_table_ops", "doc_diff"}
+    ),
+    WorkFamily.TYPED_AUTHORING: frozenset(
+        {
+            "get_document_plan_schema",
+            "validate_document_plan",
+            "analyze_document_plan",
+            "create_document_from_plan",
+            "inspect_document_authoring_quality",
+            "inspect_official_document_style",
+        }
+    ),
+    WorkFamily.MUST_ABSTAIN: frozenset(),
+}
+
+
+@dataclass(frozen=True, slots=True)
+class DispatchOutcome:
+    result: Any
+    replayed: bool
+    receipt: WorkflowEvent
+
+
+def _result_evidence(result: Any) -> dict[str, Any]:
+    """Extract only policy booleans; never persist tool result bodies."""
+
+    if not isinstance(result, Mapping):
+        return {"ok": True, "openSafetyOk": None}
+    ok = result.get("ok")
+    if ok is None:
+        ok = result.get("created")
+    if ok is None and isinstance(result.get("verificationReport"), Mapping):
+        ok = result["verificationReport"].get("ok")
+    open_safety = result.get("openSafety")
+    if not isinstance(open_safety, Mapping) and isinstance(result.get("verificationReport"), Mapping):
+        open_safety = result["verificationReport"].get("openSafety")
+    if not isinstance(open_safety, Mapping) and isinstance(result.get("verification"), Mapping):
+        open_safety = result["verification"].get("openSafety")
+    open_safety_ok = open_safety.get("ok") if isinstance(open_safety, Mapping) else None
+    return {"ok": ok is not False, "openSafetyOk": open_safety_ok}
+
+
+class AllowlistedDispatcher:
+    def __init__(self, namespace: Mapping[str, Callable[..., Any]]) -> None:
+        contract_names = expected_tool_names(advanced=True)
+        invalid = set().union(*FAMILY_TOOL_ALLOWLISTS.values()) - contract_names
+        if invalid:
+            raise RuntimeError(f"workflow allowlist contains tools absent from ToolSpec: {sorted(invalid)}")
+        self._namespace = namespace
+
+    def resolve(self, family: WorkFamily, action: ActionRequest) -> Callable[..., Any]:
+        if action.tool_name not in FAMILY_TOOL_ALLOWLISTS[family]:
+            raise PolicyViolation(
+                "TOOL_NOT_ALLOWED",
+                f"{action.tool_name} is not allowed for {family.value}",
+                details={"family": family.value, "tool": action.tool_name},
+            )
+        function = self._namespace.get(action.tool_name)
+        if not callable(function):
+            raise PolicyViolation(
+                "TOOL_UNAVAILABLE",
+                f"ToolSpec tool is not callable in the active server: {action.tool_name}",
+            )
+        return function
+
+    def dispatch(self, family: WorkFamily, action: ActionRequest) -> Any:
+        return self.resolve(family, action)(**dict(action.arguments))
+
+    def dispatch_durable(
+        self,
+        store: WorkflowStore,
+        workflow_id: str,
+        action: ActionRequest,
+        *,
+        expected_version: int,
+        capability_ok: bool,
+        policy: WorkflowPolicyEngine | None = None,
+    ) -> DispatchOutcome:
+        """Execute once behind durable started/completed/failed receipts.
+
+        A recovered completed action is not executed again.  A recovered
+        ``started`` action without a terminal receipt fails as in-doubt because
+        executing it again could duplicate a mutation.
+        """
+
+        engine = policy or WorkflowPolicyEngine()
+        record = store.get(workflow_id)
+        events = store.events(workflow_id)
+        action_events = [event for event in events if event.payload.get("actionHash") == action.action_hash]
+        completed = next((event for event in reversed(action_events) if event.event_type == "dispatch.completed"), None)
+        if completed is not None:
+            # The primitive result is encrypted outside the append-only ledger.
+            # Replays must return the exact prior result so workflow planning and
+            # verification never depend on an in-memory first execution.
+            return DispatchOutcome(
+                result=store.get_action_result(workflow_id, action.action_hash),
+                replayed=True,
+                receipt=completed,
+            )
+        started_attempts = [event for event in action_events if event.event_type == "dispatch.started"]
+        terminal_attempts = {
+            int(event.payload["attempt"])
+            for event in action_events
+            if event.event_type in {"dispatch.completed", "dispatch.failed"} and "attempt" in event.payload
+        }
+        unresolved = next(
+            (event for event in reversed(started_attempts) if int(event.payload["attempt"]) not in terminal_attempts),
+            None,
+        )
+        if unresolved is not None:
+            raise PolicyViolation(
+                "DISPATCH_IN_DOUBT",
+                "action has a durable started receipt but no terminal receipt; automatic re-execution is unsafe",
+                details={"actionHash": action.action_hash, "attempt": unresolved.payload["attempt"]},
+            )
+
+        if record.state_version != expected_version:
+            from .store import WorkflowConflict
+
+            raise WorkflowConflict(
+                f"stale workflow state: expected {record.state.value}@{expected_version}, "
+                f"actual {record.state.value}@{record.state_version}"
+            )
+
+        engine.authorize_action(record, action, events, capability_ok=capability_ok)
+        function = self.resolve(record.work_order.family, action)
+        attempt = len(started_attempts) + 1
+        common = {
+            "actionHash": action.action_hash,
+            "argumentsHash": content_hash(dict(action.arguments)),
+            "attempt": attempt,
+            "tool": action.tool_name,
+        }
+        running, started, _ = store.append_event(
+            workflow_id,
+            "dispatch.started",
+            expected_state=record.state,
+            expected_version=record.state_version,
+            payload=common,
+            event_key=f"dispatch:{action.action_hash}:{attempt}:started",
+        )
+        try:
+            result = function(**dict(action.arguments))
+        except Exception as error:
+            store.append_event(
+                workflow_id,
+                "dispatch.failed",
+                expected_state=running.state,
+                expected_version=running.state_version,
+                payload={**common, "errorType": type(error).__name__},
+                event_key=f"dispatch:{action.action_hash}:{attempt}:failed",
+            )
+            raise
+        store.put_action_result(workflow_id, action.action_hash, result)
+        completed_record, completed_receipt, _ = store.append_event(
+            workflow_id,
+            "dispatch.completed",
+            expected_state=running.state,
+            expected_version=running.state_version,
+            payload={**common, "resultHash": content_hash(result), **_result_evidence(result)},
+            event_key=f"dispatch:{action.action_hash}:{attempt}:completed",
+        )
+        del completed_record, started
+        return DispatchOutcome(result=result, replayed=False, receipt=completed_receipt)
+
+
+__all__ = ["AllowlistedDispatcher", "DispatchOutcome", "FAMILY_TOOL_ALLOWLISTS"]

hwpx_automation/workflow/models.py

@@ -0,0 +1,243 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Versioned contracts for durable server-side HWPX workflows.
+
+These models deliberately accept typed work rather than a free-form prompt.  Prompt
+bodies belong to the MCP request boundary, not the durable event ledger.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import datetime, timezone
+from enum import Enum
+from pathlib import Path
+from typing import Any, Mapping
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+WORKFLOW_SCHEMA_VERSION = "hwpx.workflow.v1"
+
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def canonical_json(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+def content_hash(value: Any) -> str:
+    raw = value if isinstance(value, bytes) else canonical_json(value).encode("utf-8")
+    return f"sha256:{hashlib.sha256(raw).hexdigest()}"
+
+
+_SENSITIVE_LEDGER_KEY_PARTS = ("prompt", "instruction", "body", "text", "content", "bytes", "binary")
+
+
+def sanitize_ledger_payload(value: Any, *, key: str = "value") -> Any:
+    """Remove prompt/document content before an event reaches durable storage."""
+
+    normalized_key = "".join(character for character in key.lower() if character.isalnum())
+    already_a_hash = normalized_key.endswith("hash") or normalized_key.endswith("revision")
+    if not already_a_hash and any(part in normalized_key for part in _SENSITIVE_LEDGER_KEY_PARTS):
+        return {"redacted": True, "hash": content_hash(value)}
+    if isinstance(value, (bytes, bytearray, memoryview)):
+        return {"redacted": True, "hash": content_hash(bytes(value))}
+    if isinstance(value, Mapping):
+        return {str(nested_key): sanitize_ledger_payload(nested, key=str(nested_key)) for nested_key, nested in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [sanitize_ledger_payload(nested, key=key) for nested in value]
+    return value
+
+
+class WorkFamily(str, Enum):
+    READ_EXTRACT = "read_extract"
+    TRANSACTIONAL_EDIT = "transactional_edit"
+    KNOWN_TEMPLATE_FILL = "known_template_fill"
+    UNKNOWN_FORM_FILL = "unknown_form_fill"
+    STRUCTURAL_TABLE_EDIT = "structural_table_edit"
+    TYPED_AUTHORING = "typed_authoring"
+    MUST_ABSTAIN = "must_abstain"
+
+
+class WorkflowState(str, Enum):
+    INTAKE = "intake"
+    RECON = "recon"
+    PLAN = "plan"
+    DECISION = "decision"
+    EXECUTE = "execute"
+    VERIFY = "verify"
+    REPAIR = "repair"
+    COMPLETED = "completed"
+    NEEDS_REVIEW = "needs_review"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+TERMINAL_STATES = frozenset(
+    {
+        WorkflowState.COMPLETED,
+        WorkflowState.NEEDS_REVIEW,
+        WorkflowState.FAILED,
+        WorkflowState.CANCELLED,
+    }
+)
+
+
+class WorkflowBudget(BaseModel):
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    max_attempts: int = Field(default=3, ge=1, le=20)
+    max_tool_calls: int = Field(default=50, ge=1, le=1000)
+    max_elapsed_seconds: int = Field(default=900, ge=1, le=86_400)
+    max_repair_rounds: int = Field(default=3, ge=0, le=10)
+
+
+class WorkflowPolicy(BaseModel):
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    preserve_original: bool = True
+    require_expected_revision: bool = True
+    require_decision_for_destructive: bool = True
+    require_open_safety: bool = True
+    require_verified_completion: bool = True
+    require_real_hancom_render: bool = False
+
+    @field_validator("preserve_original")
+    @classmethod
+    def original_preservation_cannot_be_disabled(cls, value: bool) -> bool:
+        if not value:
+            raise ValueError("server workflows always preserve the original document")
+        return value
+
+
+class WorkOrder(BaseModel):
+    """Typed, restartable request accepted by the workflow engine.
+
+    ``parameters`` may contain structured adapter input but never raw bytes.  Event
+    records persist only its hash and key list, not its values.
+    """
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    schema_version: str = WORKFLOW_SCHEMA_VERSION
+    family: WorkFamily
+    source_path: str | None = None
+    output_path: str | None = None
+    expected_revision: str | None = None
+    idempotency_key: str = Field(min_length=8, max_length=200)
+    parameters: dict[str, Any] = Field(default_factory=dict)
+    budget: WorkflowBudget = Field(default_factory=WorkflowBudget)
+    policy: WorkflowPolicy = Field(default_factory=WorkflowPolicy)
+
+    @field_validator("schema_version")
+    @classmethod
+    def supported_schema(cls, value: str) -> str:
+        if value != WORKFLOW_SCHEMA_VERSION:
+            raise ValueError(f"unsupported workflow schema: {value}")
+        return value
+
+    @field_validator("source_path", "output_path")
+    @classmethod
+    def normalize_path(cls, value: str | None) -> str | None:
+        return str(Path(value).expanduser().resolve()) if value else None
+
+    @field_validator("parameters")
+    @classmethod
+    def reject_binary_parameters(cls, value: dict[str, Any]) -> dict[str, Any]:
+        def walk(item: Any) -> None:
+            if isinstance(item, (bytes, bytearray, memoryview)):
+                raise ValueError("document bytes are not accepted in workflow parameters")
+            if isinstance(item, Mapping):
+                for nested in item.values():
+                    walk(nested)
+            elif isinstance(item, (list, tuple)):
+                for nested in item:
+                    walk(nested)
+
+        walk(value)
+        return value
+
+    def fingerprint(self) -> str:
+        return content_hash(self.model_dump(mode="json"))
+
+    def ledger_summary(self) -> dict[str, Any]:
+        """Return the non-content request summary safe for append-only events."""
+
+        return {
+            "schemaVersion": self.schema_version,
+            "family": self.family.value,
+            "sourcePathHash": content_hash(self.source_path) if self.source_path else None,
+            "outputPathHash": content_hash(self.output_path) if self.output_path else None,
+            "expectedRevision": self.expected_revision,
+            "parameterKeys": sorted(self.parameters),
+            "parametersHash": content_hash(self.parameters),
+            "workOrderHash": self.fingerprint(),
+        }
+
+
+class WorkflowEvent(BaseModel):
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    workflow_id: str
+    index: int = Field(ge=0)
+    event_type: str
+    from_state: WorkflowState | None
+    to_state: WorkflowState
+    occurred_at: datetime
+    payload: dict[str, Any]
+    previous_hash: str | None
+    event_hash: str
+    event_key: str | None = None
+
+
+class WorkflowRecord(BaseModel):
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    workflow_id: str
+    work_order: WorkOrder
+    state: WorkflowState
+    state_version: int = Field(ge=1)
+    created_at: datetime
+    updated_at: datetime
+    original_content_hash: str | None = None
+    output_content_hash: str | None = None
+    stop_reason: str | None = None
+
+    @property
+    def terminal(self) -> bool:
+        return self.state in TERMINAL_STATES
+
+
+class ActionResult(BaseModel):
+    """Decrypted durable result plus non-sensitive retention metadata."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True, populate_by_name=True)
+
+    workflow_id: str = Field(serialization_alias="workflowId")
+    action_hash: str = Field(serialization_alias="actionHash")
+    result: Any
+    content_hash: str = Field(serialization_alias="contentHash")
+    size_bytes: int = Field(ge=0, serialization_alias="sizeBytes")
+    created_at: datetime = Field(serialization_alias="createdAt")
+    expires_at: datetime = Field(serialization_alias="expiresAt")
+
+
+__all__ = [
+    "TERMINAL_STATES",
+    "WORKFLOW_SCHEMA_VERSION",
+    "ActionResult",
+    "WorkFamily",
+    "WorkOrder",
+    "WorkflowBudget",
+    "WorkflowEvent",
+    "WorkflowPolicy",
+    "WorkflowRecord",
+    "WorkflowState",
+    "canonical_json",
+    "content_hash",
+    "sanitize_ledger_payload",
+    "utc_now",
+]

hwpx_automation/workflow/policy.py

@@ -0,0 +1,198 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Fail-closed policy decisions for durable HWPX workflows."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Iterable, Mapping
+
+from hwpx_automation.document_state import document_revision
+
+from .models import WorkFamily, WorkflowEvent, WorkflowRecord, WorkflowState, content_hash, utc_now
+
+
+MUTATING_FAMILIES = frozenset(
+    {
+        WorkFamily.TRANSACTIONAL_EDIT,
+        WorkFamily.KNOWN_TEMPLATE_FILL,
+        WorkFamily.UNKNOWN_FORM_FILL,
+        WorkFamily.STRUCTURAL_TABLE_EDIT,
+        WorkFamily.TYPED_AUTHORING,
+    }
+)
+
+
+class PolicyViolation(RuntimeError):
+    def __init__(self, code: str, message: str, *, details: Mapping[str, Any] | None = None) -> None:
+        self.code = code
+        self.details = dict(details or {})
+        super().__init__(message)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"ok": False, "code": self.code, "message": str(self), "details": self.details}
+
+
+@dataclass(frozen=True, slots=True)
+class ActionRequest:
+    tool_name: str
+    arguments: Mapping[str, Any]
+    destructive: bool = False
+
+    @property
+    def action_hash(self) -> str:
+        return content_hash(
+            {"tool": self.tool_name, "arguments": self.arguments, "destructive": self.destructive}
+        )
+
+
+class WorkflowPolicyEngine:
+    """Evaluate invariants using durable record/event evidence only."""
+
+    def validate_intake(self, record: WorkflowRecord) -> None:
+        order = record.work_order
+        if order.family not in MUTATING_FAMILIES:
+            return
+        if order.source_path and order.output_path and order.source_path == order.output_path:
+            raise PolicyViolation(
+                "ORIGINAL_OVERWRITE_FORBIDDEN",
+                "workflow output must be a distinct copy; the original cannot be overwritten",
+            )
+        if order.family != WorkFamily.TYPED_AUTHORING and not order.source_path:
+            raise PolicyViolation("SOURCE_REQUIRED", "this workflow family requires a source document")
+        if not order.output_path:
+            raise PolicyViolation("OUTPUT_COPY_REQUIRED", "mutating workflows require a distinct output path")
+        if order.policy.require_expected_revision and order.source_path and not order.expected_revision:
+            raise PolicyViolation("EXPECTED_REVISION_REQUIRED", "expected_revision is required before mutation")
+
+    def authorize_action(
+        self,
+        record: WorkflowRecord,
+        action: ActionRequest,
+        events: Iterable[WorkflowEvent],
+        *,
+        capability_ok: bool,
+    ) -> None:
+        self.validate_intake(record)
+        if not capability_ok:
+            raise PolicyViolation("CAPABILITY_SKEW", "workflow dispatch is disabled by capability/version skew")
+        if record.terminal:
+            raise PolicyViolation("WORKFLOW_TERMINAL", "terminal workflows cannot dispatch more tools")
+
+        event_list = list(events)
+        elapsed = (utc_now() - record.created_at).total_seconds()
+        if elapsed >= record.work_order.budget.max_elapsed_seconds:
+            raise PolicyViolation(
+                "ELAPSED_TIME_BUDGET_EXCEEDED",
+                "workflow elapsed-time budget is exhausted",
+                details={"elapsedSeconds": int(elapsed), "maximum": record.work_order.budget.max_elapsed_seconds},
+            )
+        calls = sum(event.event_type == "dispatch.started" for event in event_list)
+        if calls >= record.work_order.budget.max_tool_calls:
+            raise PolicyViolation(
+                "TOOL_CALL_BUDGET_EXCEEDED",
+                "workflow tool-call budget is exhausted",
+                details={"used": calls, "maximum": record.work_order.budget.max_tool_calls},
+            )
+        attempts = sum(
+            event.event_type == "dispatch.started" and event.payload.get("actionHash") == action.action_hash
+            for event in event_list
+        )
+        if attempts >= record.work_order.budget.max_attempts:
+            raise PolicyViolation(
+                "ACTION_ATTEMPT_BUDGET_EXCEEDED",
+                "action attempt budget is exhausted",
+                details={"used": attempts, "maximum": record.work_order.budget.max_attempts},
+            )
+        repair_rounds = sum(
+            event.from_state != WorkflowState.REPAIR and event.to_state == WorkflowState.REPAIR
+            for event in event_list
+        )
+        if repair_rounds > record.work_order.budget.max_repair_rounds:
+            raise PolicyViolation(
+                "REPAIR_BUDGET_EXCEEDED",
+                "workflow repair-round budget is exhausted",
+                details={"used": repair_rounds, "maximum": record.work_order.budget.max_repair_rounds},
+            )
+
+        order = record.work_order
+        if order.source_path and order.expected_revision:
+            actual = document_revision(order.source_path)
+            if actual != order.expected_revision:
+                raise PolicyViolation(
+                    "STALE_DOCUMENT_REVISION",
+                    "source document changed after workflow intake",
+                    details={"expected": order.expected_revision, "actual": actual},
+                )
+
+        if action.destructive and order.policy.require_decision_for_destructive:
+            approved = any(
+                event.event_type == "decision.approved"
+                and event.from_state == WorkflowState.DECISION
+                and event.to_state == WorkflowState.DECISION
+                and event.payload.get("actionHash") == action.action_hash
+                for event in event_list
+            )
+            if not approved:
+                raise PolicyViolation(
+                    "DECISION_REQUIRED",
+                    "this action requires an explicit matching decision receipt",
+                    details={"actionHash": action.action_hash},
+                )
+
+    def authorize_completion(self, record: WorkflowRecord, verification: Mapping[str, Any]) -> None:
+        if record.state != WorkflowState.VERIFY:
+            raise PolicyViolation("VERIFY_STATE_REQUIRED", "completion is only allowed from verify state")
+        if record.work_order.policy.require_open_safety and verification.get("openSafetyOk") is not True:
+            raise PolicyViolation("OPEN_SAFETY_REQUIRED", "openSafety evidence is required for completion")
+        if record.work_order.policy.require_verified_completion and verification.get("verified") is not True:
+            raise PolicyViolation("VERIFIED_COMPLETION_REQUIRED", "unverified work cannot be marked completed")
+        if verification.get("domainVerified") is not True:
+            raise PolicyViolation(
+                "DOMAIN_VERIFICATION_REQUIRED",
+                "family-specific result and quality verification are required for completion",
+            )
+
+    def record_decision(
+        self,
+        store: Any,
+        record: WorkflowRecord,
+        action: ActionRequest,
+        *,
+        approved: bool,
+    ) -> WorkflowRecord:
+        if record.state != WorkflowState.DECISION:
+            raise PolicyViolation("DECISION_STATE_REQUIRED", "decision receipts are only valid in decision state")
+        event_type = "decision.approved" if approved else "decision.rejected"
+        updated, _, _ = store.append_event(
+            record.workflow_id,
+            event_type,
+            expected_state=record.state,
+            expected_version=record.state_version,
+            payload={"actionHash": action.action_hash, "approved": approved},
+            event_key=f"decision:{action.action_hash}",
+        )
+        return updated
+
+    def complete(
+        self,
+        store: Any,
+        record: WorkflowRecord,
+        verification: Mapping[str, Any],
+        *,
+        output_content_hash: str | None = None,
+    ) -> WorkflowRecord:
+        """Policy-gated only path from VERIFY to COMPLETED."""
+
+        self.authorize_completion(record, verification)
+        return store.transition(
+            record.workflow_id,
+            WorkflowState.COMPLETED,
+            expected_state=record.state,
+            expected_version=record.state_version,
+            event_type="workflow.completed",
+            payload={"verification": dict(verification)},
+            output_content_hash=output_content_hash,
+        )
+
+
+__all__ = ["ActionRequest", "MUTATING_FAMILIES", "PolicyViolation", "WorkflowPolicyEngine"]