SIGNALS Docs

Workflows

Delivered workflow authoring, execution, recovery, and extension contracts.

Delivered engine

Signals workflows combine a trigger, ordered steps, conditions, delays, and approval or external continuations. A workflow definition has an editable draft and immutable published versions. Runs pin the published version they started on, so later draft edits cannot rewrite executed history.

The delivered runtime supports domain-event, scheduled, inbound signed integration, and explicitly authorized manual starts. It records lifecycle transitions, attempts, outcomes, branches, context changes, domain outputs, and effect risk in the evidence projection, subject to redaction and retention. See Workflow operations for operator recovery and the workflow-run operations in the OpenAPI reference for workflow authoring, execution and evidence operations.

Authoring, versions, and publishing

Authoring is built and separate from execution. A workflow's draft lives in workflows and workflow_steps; publishing validates the draft and records a sequential WorkflowSnapshot in workflow_versions. A workflow must be published before activation, and must be inactive before deletion. Deletion is soft and retains versions and run history.

Action Responsibility
App\Actions\Workflows\CreateWorkflow Create an unpublished draft
App\Actions\Workflows\UpdateWorkflow Replace the ordered draft step list and bump draft_revision
App\Actions\Workflows\PublishWorkflow Validate handlers and configuration, then write the next immutable version
App\Actions\Workflows\ActivateWorkflow / DeactivateWorkflow Arm or disarm a published workflow
App\Actions\Workflows\DeleteWorkflow Soft-delete an inactive definition

The policy separates workflows.view, workflows.create, workflows.update, workflows.publish, workflows.delete, and workflows.run. Recovery additionally checks workflows.retry-failed-step or workflows.run-again; sensitive evidence requires workflows.view-sensitive-run-data. The admin workflow guide covers the UI and permissions.

Runtime contracts

Core action steps resolve through the version-aware WorkflowHandlerRegistry. Handlers declare their configuration, outcomes, capabilities, retry safety, schemas, and sensitive fields. The workflow service principal checks those capabilities at execution time. Handler registration is namespaced and collision-safe; plugin registrations cannot shadow core identifiers.

Plugin-owned handlers, triggers, and conditions are declared in signals.yaml, validated against the host version and contract, and registered only while the plugin is enabled and healthy. Conditions receive an allowlisted sanitized context and cannot query or mutate application state. See Workflow extensions, the manifest reference, and registries and resolvers.

Execution and recovery

Runs move through pending, running, delayed, and awaiting before a terminal completed, failed, or cancelled state. Cancellation is a cooperative, reasoned request. Retry starts a new run, linked to the failed source run, that resumes from the eligible failed step; run-again creates a separately authorized linked run from the start. Neither undoes preceding effects. Queued runs execute one step per queue job, and each settled step queues the next. A manual start without an Idempotency-Key always starts a new run; send the same key to replay a command without starting another. Existing run evidence is redacted and retained according to the configured policy; detailed evidence is not recoverable after pruning.

There is no arbitrary handler discovery, execution shadow mode, or live-query condition path. Features outside the delivered handler and extension contracts must not be represented as available workflow behavior.

Event capability providers

Domain-event publication requires an executable WorkflowEventRuntime capability even when no conditions are configured. Drafts and template clones accept any known workflow catalogue event; unknown names are rejected on the server. The editor keeps unsupported catalogue choices visible and disabled. Fire Event remains restricted to workflow.custom.*; use typed Actions/handlers to perform domain changes that emit their own real facts.

WorkflowEventCapabilityProvider owns each family's subject resolver, authorization, payload adaptation, redaction, and contract version. The runtime has scoped lifetime for Octane and queue workers. Rental and custom adapters preserve the existing rental subject paths and rentals.view authority. Plugin manifests retain provider class descriptors, with fresh instances constructed per scope and lifecycle compensation restoring preceding descriptors.

Published domain-event snapshots pin the provider key, contract version, and payload version. Captured envelopes also carry a runtime_pin. Admission refuses incompatible or unavailable contracts with reason codes and fully redacted payload evidence. Snapshots without provider pins use the unversioned.unpinned sentinel and report workflow_pin_requires_republication for new admission. Republish against the enabled provider to establish the required contract evidence. Already admitted nonterminal runs marked unversioned.unpinned skip provider pin and identity comparisons, but still resolve and authorize their subject whenever an event provider exists. A deleted or unauthorized subject cannot continue merely because the next handler makes its subject optional. The sentinel continues to refuse new admission. Nonterminal runs with provider pins retain event-specific provider declarations in the existing extension-retention repository. Retention never enables new admission or recovery against a removed provider. Deployments must keep the corresponding provider class available until those runs settle.

Account and contact facts

core.account enables exactly these 22 facts:

Family Actions
account created, updated, archived, restored, deleted, merged, anonymised, vat_validated
address created, updated, deleted
activity created, updated, deleted, completed
conversation created, updated, deleted, mentioned
conversation_comment created, updated, deleted

The workflow subject is the owning Account. Addresses resolve through addressable, activities through regarding, conversations through conversable, and comments through their conversation's conversable. An activity owner, conversation author, or a rental's customer is not substituted for that relationship. Non-Account parents and foreign database connections are refused. Admission requires the existing accounts.view capability. The account.archived, account.deleted, and account.anonymised facts may start runs for a soft-deleted Account; other Account facts require an unarchived subject. The executor resolves and attaches lifecycle Accounts before applying the handler subject contract, including for optional-subject handlers. communications.send requires a subject and accepts an Account directly as its recipient. Queued delivery may resolve an archived recipient only when the communication log has a workflow idempotency key and agrees with the published lifecycle run on the Account and event. The user-controlled display pin does not grant or revoke this delivery provenance. Consequential effect guards and recovery retain their live-subject eligibility checks.

Outbound HTTP and signed-webhook bodies are literal configuration, with no subject or trigger-payload interpolation. WorkflowExecutor::execute() passes the published step configuration unchanged. CallExternalHttpWorkflowHandler::execute() serializes only configuration.body; SendSignedWebhookWorkflowHandler::envelope() uses only configuration.payload for its data and adds workflow/attempt identifiers plus causal metadata. Capture and admission restrict that metadata to correlation, causation, and depth fields. Attaching an archived Account therefore does not expose its contact attributes or raw trigger payload to either outbound body. This is an absence of automatic data binding, not a general PII filter: authors can supply literal values and producers control causal identifier strings. Any future templating support must apply the event family's redaction before exposing subject or payload fields. The archived-Account outbound test covers JSON, form, plain-text HTTP, and signed JSON with populated contact records and literal template-like strings.

Account payloads contain the nested source entity and subject.id. The adapted DTO is stored in the payload, matching the rental contract. Declared sensitive_fields redact contact and PII fields in redacted_summary; metadata must be updated when DTOs add sensitive fields. Account name and number (the business reference number) remain available to conditions. Nested condition paths are intentionally supported for every event family, including rental events, when each segment is an explicit object property in the workflow schema. Leaf values retain their declared types; array items, additional properties, and undeclared fields remain opaque. account.anonymised records identifiers only, regardless of the audit event's original/new values. Workflow schemas describe this adapted payload separately from stable webhook schemas.

Account Actions emit non-Verbs audit facts. The manifestless event replay key is audit: followed by the SHA-1 of the serialized tuple (action, morph class, model key, oldValues, newValues, occurrence Unix second). Deduplication uses the explicit createdAt, otherwise the persisted model updated_at, otherwise the event construction time. The event records its precise workflowOccurredAt independently; the envelope timestamp column remains second-resolution. Redispatching the same event reuses the capture. When the original event used the persisted timestamp fallback, reconstruction with the same mutation values and unchanged persisted timestamp also reuses it, even when reconstruction happens later. An originally explicit occurrence must instead be preserved when reconstructing that event. Different mutation values remain distinct, but identical mutations in the same occurrence second deliberately collide. If the model timestamp has since changed, replay needs the original deduplication occurrence supplied explicitly. Without a persisted or explicit timestamp, reconstruction in another second cannot deduplicate. Verbs events retain verb:<event id> replay keys. Address audit aliases (account.address.*) are bridged to the canonical address.* workflow vocabulary while preserving the recording contract. Mention notification dispatch emits the real conversation.mentioned audit fact with comment identity, and matching is queued after commit. Account payload adaptation and envelope storage occur only when a published snapshot subscribes to the canonical event; draft edits cannot change that subscription.

Provider-declared capture behaviour

The capture path holds no per-family branches. A provider may implement the optional WorkflowEventCaptureBehaviour contract to declare whether a fact needs a Verbs event id before it is captured, whether capture is skipped unless a published workflow subscribes to the event, how a recording vocabulary is bridged onto the catalogue vocabulary, and whether an unavailable subject declines quietly instead of throwing. WorkflowEventCapturePolicy reads those declarations in one place; a provider that declares nothing keeps the framework defaults, which are the rental and custom behaviour (Verbs event id required, no subscription pre-check, no bridging, and exceptions propagate). Implementing the contract is optional so an installed plugin provider compiled against the original capability contract keeps working. WorkflowEventSubjectLifecycle is the matching optional declaration for archived subjects: WorkflowEventRuntime::allowsArchivedSubject() is the one site the provider's own authorization and the run executor both consult, and the executor additionally confines the allowance to the subject type the event definition declares.

Finance facts

core.finance enables 18 facts across two subject types under one provider key.

Subject Capability Actions
invoice invoices.view invoice.created, invoice.issued, invoice.voided, invoice.overdue, payment.recorded, payment.refunded, invoice_payment.updated, credit_note.draft_created, credit_note.issued, credit_note.applied, credit_note.voided, credit_note.updated
purchase_order purchase_orders.view purchase_order.created, purchase_order.updated, purchase_order.sent, purchase_order.received, purchase_order.cancelled, purchase_order.deleted

An event name's prefix is not the payload key here. EventDefinition::$entity is derived from that prefix, so credit_note.issued, payment.recorded and invoice_payment.updated all report a non-invoice entity while carrying an invoice. The provider keys its adapted payload by the SUBJECT it resolves, so every invoice-family payload is {"invoice": {...}, "subject": {"id": n}} and every purchase-order payload is {"purchase_order": {...}, "subject": {"id": n}}; workflow_subject, workflow_payload_schema and workflow_redaction describe that same shape, so redaction paths match real payload fields.

Subjects are resolved by re-reading the row, never by serialising the audit event's in-memory model. That model may be a credit note or a payment rather than the subject, and an unsaved instance is missing the database defaults that InvoiceData and PurchaseOrderData require for their non-nullable properties. credit_note.updated resolves through CreditNote::$invoice_id and invoice_payment.updated through InvoicePayment::$invoice_id; a record with no owning invoice declines. The read includes trashed rows so a fact recorded at deletion still resolves, and purchase_order.deleted is the family's only archived-subject allowance. Redaction covers document numbers and references, all money totals, exchange rates, tag lists, custom fields, nested relation collections, and the purchase-order delivery contact fields.

The family declares requiresVerbEvent() false because finance facts arrive from three producers: Verbs invoice projections (verb: replay keys), actions that dispatch their own audit fact, and the overdue console command (audit: replay keys). It declares requiresSubscribedWorkflow() true, so no evidence row is written for an invoice or purchase-order mutation nobody subscribes to, and declinesQuietly() true, so an unresolvable subject cannot throw into the audit listener chain.

Deliberately catalogue-only: the tax, currency and exchange-rate reference families and billing_run.* have no per-tenant subject and no *.view ability in the permission catalogue. invoice.updated, invoice.deleted and the invoice.item_* facts are system_protected in config/events.php, so they are absent from every discovery accessor and cannot be triggerable without changing their consumer visibility. invoice.portal_payment_received is dispatched straight to WebhookService and never emits an AuditableEvent, so the capture path cannot observe it.

Document and communication facts

core.document enables 17 facts across two subject types under one provider key.

Subject Capability Actions
document documents.view document.created, document.pdf_generated, document.finalised, document.voided, document.emailed, document.public_link_created, document.public_link_accessed, document.public_link_revoked, document.public_link_configured, document.approval_requested, document.portal_question, document.approved, document.declined
communication_draft communications.draft communication_draft.created, communication_draft.approved, communication_draft.discarded, communication_draft.sent

Both halves are PayloadShape::LeanEnvelope in the catalogue, so neither carries a payload_dto/payload_key the runtime could adapt for them; the provider builds the payload itself and keys it by the subject it resolves, giving {"document": {...}, "subject": {"id": n}} and {"communication_draft": {...}, "subject": {"id": n}}. workflow_payload_schema, workflow_sample_payload and workflow_redaction describe that adapted shape rather than the stable lean webhook envelope.

A document is polymorphic over its owner through documentable, but the workflow subject is the Document itself. Nothing in the provider traverses that relation, so an owner's record can never be substituted for the declared subject, and a payload whose document.id disagrees with subject.id is refused. Reading a drafted communication is gated on communications.draft: there is no communications.view in the permission catalogue, and communications.draft is what the draft API index/show endpoints and the record-page draft queue actually assert. communications.approve is the decision half of the lifecycle, not its read gate.

Subjects are resolved by re-reading the row, never by serialising the audit event's in-memory model: documents.status, documents.locale and documents.currency_code are database defaults, and an unsaved instance would fail the matching non-nullable DocumentData properties at runtime. The document DTO is built with template, public-link and download-URL inclusion off, so no public token and no signed download URL ever reaches a stored envelope. Redaction additionally covers the document number, the rendered snapshot, the stored PDF and HTML paths, the email recipient, the generating and issuing user ids, the customer's responder name and decline reason, and the whole draft body, subject line, merge data, attachments, recipient id and creator attribution. Document type, status, warehouse, locale, currency, and the draft's channel, status and notification type stay available to conditions.

No document or draft fact is dispatched after its subject is archived — document.voided and document.declined record a status change rather than a delete, and drafts are not soft-deletable — so the family declares no archived-subject allowance and an archived document stops the run. The family declares requiresVerbEvent() false because DocumentEventDispatcher and CommunicationDraftEvents each construct their own AuditableEvent with no Verbs event id; requiring one would have captured nothing for all seventeen facts. It declares requiresSubscribedWorkflow() true and declinesQuietly() true, the latter because document.public_link_accessed and document.portal_question are fired by unauthenticated portal traffic inside the audit listener chain, where a capture that cannot proceed must decline rather than throw.

Deliberately catalogue-only: document_template.*, document_sequence.*, communication_template.*, email_layout.* and email_template.* are tenant configuration rather than per-subject facts. attachment.* is PayloadShape::AdHoc and polymorphic across many owners, so it is deferred to the polymorphic pattern rather than given a document subject. document.link_shared and document.printed carry 'workflow' => false and are recorded against the source record (an account, a rental) instead of the document, so enabling them is a catalogue-visibility decision rather than a workflow one.

Asset and equipment facts

core.asset enables 21 facts across seven source entities under one provider key. Every one of them resolves to the ONE Asset it belongs to, so the envelope subject is always asset and the adapted payload is always {"<source>": {...}, "subject": {"id": n}}.

Source entity Capabilities Actions
asset assets.view asset.created, asset.updated
asset_ledger_entry assets.view asset_ledger_entry.created, asset_ledger_entry.deleted
asset_cost assets.view asset_cost.created, asset_cost.updated, asset_cost.deleted
asset_retirement assets.view asset_retirement.created, asset_retirement.voided, asset_retirement.reinstated
usage_reading assets.view usage_reading.recorded, usage_reading.deleted
equipment_test_result assets.view + equipment_tests.view equipment_test.completed, equipment_test.failed, equipment_test_certificate.issued, equipment_test_result.created, equipment_test_result.updated, equipment_test_result.deleted
repair assets.view + repairs.view repair.created, repair.updated, repair.released

The payload key comes from an explicit map rather than from EventDefinition::$entity, because equipment_test.completed, equipment_test.failed and equipment_test_certificate.issued are named for the equipment test while the model they carry — and therefore the row that owns an asset — is an EquipmentTestResult. Equipment test and repair facts assert their own read ability AND assets.view, because the subject handed to the workflow is the asset rather than the compliance record.

An EquipmentTest is a DEFINITION: it has no asset_id, it is attached to catalogue items through equipment_test_catalogue_item, and its EquipmentTestItem rows are task lines on that definition. One definition therefore covers many assets, and equipment_test.created, equipment_test.updated and equipment_test.deleted have no single owning asset — they stay catalogue-only. A Repair is the opposite: repairs.asset_id names exactly one asset, and its quantity/released_quantity count units of that one asset, so RepairTransaction rows are a ledger of that single repair rather than a fan-out across assets.

Subjects and payloads are built by re-reading the row, never by serialising the audit event's in-memory model: ledger quantities and manual flags, asset_costs.currency_code and every created_at/updated_at in this family are database-side values that would fail a non-nullable DTO property on an unsaved instance. Re-reading also makes the payload deterministic, because RepairData and EquipmentTestResultData include their eager relations conditionally and a freshly read row always carries the same ones. Deletion facts publish identifiers only ({"id": n, "asset_id": m}): asset_ledger_entry.deleted is dispatched AFTER its row is removed so no DTO can be rebuilt for it, and declaring one identifier shape for all four deletions keeps the contract independent of that ordering.

Redaction covers the asset serial number, barcode, asset number, physical location, custom fields and loaded account reference; the free-text movement description; asset cost amount, supplier and description; retirement proceeds, notes and the TCO snapshot; the reading recorder; the repair reference, notes, description, custom fields, origin and user attributions; and equipment test result notes, task results, result items and performer. Warehouse, quantities, transaction type, cost type, currency, retirement reason, metric, reading value, repair status and phase, and test outcome all stay available to conditions.

Nothing in this family is soft-deletable, so no fact can be dispatched against a trashed subject and the family declares no archived-subject allowance. Retirement does not delete an asset — it stamps assets.ends_at and writes an asset_retirements row — so asset_retirement.* and repair.released resolve their subject normally. requiresVerbEvent() is false because every action in the family constructs its own AuditableEvent with no Verbs event id, including the purchase-order receipt path that records asset_ledger_entry.created from inside a Verbs handler; requiring one would have captured nothing at all. requiresSubscribedWorkflow() and declinesQuietly() are both true, the latter because retirement, repair release and every deletion run inside a database transaction whose audit listener chain must not be interrupted.

Deliberately catalogue-only: asset.deleted hard-deletes the very row that would be its subject (assets carry no soft deletes), so the fact is dispatched when the asset is already gone and no run could ever resolve a subject; the same user-visible moment is reachable through asset_retirement.created, which DeleteAsset itself directs operators to for any asset with movement or allocation history. equipment_test.created, equipment_test.updated and equipment_test.deleted change a definition shared across many assets, and the per-asset moment they imply is already covered by equipment_test.completed, equipment_test.failed and equipment_test_result.*. equipment_test.due, equipment_test.overdue, equipment_test.auto_repair_rejected and equipment_test.dispatch_acknowledged are system_protected in config/events.php and absent from every discovery accessor, so a workflow_provider entry on them would have no effect; making them triggerable is an API, webhook and plugin-SDK visibility decision left to the classification sweep.

Stock, transfers and logistics facts

core.stock enables 28 facts across three subject types under one provider key.

Subject Capability Actions
stock_check stock_checks.view stock_check.created, stock_check.updated, stock_check.closed, stock_check.completed, stock_check.reopened, stock_check.cancelled, stock_check.discrepancy_resolved, stock_check.discrepancy_dismissed, stock_check.signed_off, stock_check.sign_off_cleared
warehouse_transfer warehouse_transfers.view warehouse_transfer.created, warehouse_transfer.updated, warehouse_transfer.dispatched, warehouse_transfer.received, warehouse_transfer.cancelled
flightcase flightcases.view flightcase.created, flightcase.updated, flightcase.nested, flightcase.sealed, flightcase.unsealed, flightcase.dissolved, flightcase.dispatched, flightcase.returned, flightcase.checkin_verified, flightcase.repack.started, flightcase.item.packed, flightcase.item.unpacked, flightcase.item.transferred

EventDefinition::$entity is the segment before the FIRST dot, so it cannot separate the event names in a dotted sub-namespace: flightcase.item.packed, flightcase.repack.started and flightcase.sealed all report the entity flightcase while carrying different rows. The provider keys its payload from an explicit map instead, and that key is not always the subject type. The ten facts dispatched with a Flightcase publish {"flightcase": {...}, "subject": {"id": n}}; the three flightcase.item.* facts dispatch a FlightcaseItem and publish {"flightcase_item": {...}, "subject": {"id": n}}, where n is the owning flightcase. workflow_payload_schema, workflow_sample_payload and workflow_redaction describe that adapted workflow shape. The internal event registrations use parent_flightcase and source_flightcase as payload_key for flightcase.nested and flightcase.item.transferred. HTTP webhook delivery retains both related flightcase objects and the other result fields under data, with delivery attributes in root meta; see webhook payload schemas.

A membership payload must name its owning flightcase, that owner must equal the envelope subject, and the stored row is re-read and compared, so a payload cannot nominate one flightcase as the subject of another's item. flightcase.nested is recorded against the CHILD flightcase, which is the row the nesting changes, and flightcase.item.transferred against the row created in the DESTINATION flightcase; the other half of each pair travels in the audit metadata. A transfer therefore emits flightcase.item.unpacked against the source and flightcase.item.transferred against the destination — the same event prefix, two different subjects.

Subjects and payloads are built by re-reading the row, never by serialising the audit event's in-memory model: stock_checks.reference, stock_checks.status_id, stock_checks.warehouse_id, warehouse_transfers.reference, both transfer warehouse ids, flightcases.uuid, flightcases.status, flightcases.scan_mode, the flightcase item's flightcase_id, serialised_item_id, catalogue_item_id and packed_at, and every created_at/updated_at in this family are database-side values that would fail a non-nullable DTO property on an unsaved instance. Stock checks, transfers and flightcases are all warehouse-scoped, so the reads drop global scopes: whether a fact is captured must not depend on the viewer's warehouse.

Redaction covers the stock check title, reference, scope location, tag filter, custom fields and creator; the transfer reference, both free-text notes, custom fields, requester, creator and polymorphic origin id; the flightcase name, barcode, UUID and notes; and the membership row's packed asset id, position, notes and packer. Warehouse routing, statuses, scope and tracking filters, transfer reason, dispatch and receipt timestamps, flightcase status, scan mode, availability mode, rental and catalogue item stay available to conditions.

Nothing in this family is soft-deletable and no fact removes its own subject — cancelling a stock check or a transfer and dissolving a flightcase each stamp a status column — so the family declares no archived-subject allowance and a missing row simply declines. requiresVerbEvent() is false because every action, job and service here constructs its own AuditableEvent with no Verbs event id; requiring one would have captured nothing at all. requiresSubscribedWorkflow() is true, which is what makes a family this busy affordable: the subscription pre-check runs in WorkflowTriggerCaptureService::capture() before any payload is adapted or any row re-read, and a system_protected event is refused prior still, before that query. declinesQuietly() is true because stock-check submission and revert, discrepancy resolution, transfer dispatch, receipt and cancellation, and every flightcase pack, transfer and dissolve record their fact from inside a database transaction whose audit listener chain must not be interrupted.

Deliberately catalogue-only: warehouse.* and facility.* are tenant configuration rather than per-subject facts. scan_session.* and scan_event.voided are device telemetry, where triggering a workflow per scan is a volume hazard. virtual_stock_intake.* is deferred rather than unsuitable — its intake row is a durable per-tenant subject and the permission catalogue already carries a read gate for it in virtual_assets.view, so it is a reasonable candidate for a later family.

The whole shortage group stays catalogue-only, for two independent reasons. shortage.detected and shortage.cleared never emit an AuditableEvent at all: ShortageEventRecorder writes an availability_events row and calls WebhookService::dispatch() directly, so the capture path cannot observe them, and those two are the moments a workflow would most want. The rest have no single stable subject: a shortage is a computed tuple of rental line, catalogue item, warehouse and window that is never persisted, and the rows that exist are records ABOUT shortages rather than the shortage itself. shortage.resolution.* carries a ShortageResolution, which has no owning rental, rental line, catalogue item or warehouse column — the only link is the shortage_resolution_items pivot, documented as one-to-many for the batch-resolution plugin. shortage.waitlist.* carries a ShortageWaitlistMonitor that cascade-deletes with its resolution, catalogue item or warehouse. shortage.acknowledged and shortage.escalated are dispatched with a Rental, which is a durable subject but belongs to the rental family and its rentals.view authority rather than to this one; shortages.view itself depends on rentals.view. Enabling any of them means choosing between three non-interchangeable stand-ins for one absent subject, so they are left to the classification sweep.

stock_check.count_recorded, stock_check.count_reset, stock_check.recounted, warehouse_transfer.line_received and flightcase.repack.item are system_protected in config/events.php and absent from every discovery accessor, so a workflow_provider entry on them would have no effect. They are also exactly the per-line facts of this family, where a five-hundred-line count or a fifty-item repack would fan out one envelope at a time; the catalogue flag already contains that. flightcase.contents_overrun carries 'workflow' => false as well as system_protected. Making any of them triggerable is an API, webhook and plugin-SDK visibility decision left to the classification sweep.

Approval facts, and the delegation rule for polymorphic subjects

core.approval enables exactly one fact.

Subject Capability Delegated capability Actions
approval_request approvals.view the approvable family's own approval.actioned

An ApprovalRequest is polymorphic over the thing being approved — subject_type/subject_id, called the APPROVABLE here to keep it distinct from the workflow subject. The workflow subject is the approval request itself, because that is the row the fact is recorded against; but authorization is two-sided and delegated. approvals.view gates reading the approval record, and the family that owns the approvable then authorizes the approvable, so an approval over an invoice additionally requires invoices.view and an approval over a rental additionally requires rentals.view.

Delegation fails closed, and that is the point of the pattern. The provider resolves the owning family from the runtime's own view of the catalogue: the triggerable definitions that declare that workflow_subject.type, resolved to their providers. Exactly one owning provider must be found. No owner (the approvable's family is not enabled), an ambiguous owner (two providers claim the type), a missing or archived approvable row, or a delegate that declines all refuse the run — with the reason codes workflow_approval_delegate_unavailable and workflow_approval_approvable_unavailable. There is deliberately no branch in which approvals.view stands in for the approvable family's ability. Ten morph types are delegatable today: account, asset, communication_draft, document, flightcase, invoice, purchase_order, rental, stock_check and warehouse_transfer. An approval over anything else — a user, a vehicle, a catalogue item — is refused rather than admitted.

The delegation target is read from the persisted approval request, never from the captured payload, so a payload can neither nominate a different approvable nor route the decision to a laxer family. The definition handed to the delegate is the alphabetically first of that provider's definitions for the morph type, which keeps the delegated ability stable across runs; which one is chosen cannot smuggle an archived approvable past the delegate, because the approval provider refuses an archived approvable itself before delegating. The approvable is re-read without global scopes, so a viewer-scoped filter cannot decide whether an approval workflow runs, and the soft-delete state is then checked explicitly because dropping global scopes also drops the soft-delete scope.

The adapted payload is {"approval_request": {...}, "approvable": {"type": t, "id": n}, "subject": {"id": n}}. The approvable contributes its IDENTITY only. Inlining its attributes would republish another family's record under this family's workflow_redaction, bypassing the redaction that family declares for its own fields, and the approval request's own context and snapshot columns are excluded for exactly the same reason — both hold a captured copy of the approvable's state. Redaction covers the requester's actor label, actor id and account id, the rejection reason and the intent key; status, event name, transition key, chain definition, timestamps and the approvable's type and id stay available to conditions. The payload is rebuilt from a freshly read row, so event_name, transition_key, intent_key, status and requester_actor_type — all non-nullable columns — are satisfied by the persisted record rather than by whatever the audit event's in-memory instance carried.

ApprovalRequest has no soft deletes and no fact removes it, so the family declares no archived-subject allowance. requiresVerbEvent() is false because both decision paths construct their own AuditableEvent with no Verbs event id. requiresSubscribedWorkflow() is true, and declinesQuietly() is true because the batch decision path anchors its audit fact on an Account when no request can be read, and both paths record from inside a database transaction whose audit listener chain must not be interrupted.

Deliberately catalogue-only: thirteen of the seventeen approval facts never emit an AuditableEvent at all. approval.requested, approval.assigned, approval.stage_resolved, approval.delegated, approval.reassigned, approval.delegation_revoked, approval.delegation_expired, approval.reminded, approval.escalated, approval.escalation_replaced, approval.stale, approval.expired and approval.completed are published exclusively through ApprovalLifecycleEvent, whose three listeners reach the webhook bus, the approval notification dispatcher and the workflow RESUME listener. The capture path is a listener on AuditableEvent, so none of them can be observed; giving them a provider would put triggers in the editor that could never fire. Adding an audit emission to ApprovalLifecycleEventDispatcher would change the recording contract for the whole family (new ActionLog rows, and a second webhook delivery path) and is an audit and API decision, not a workflow one.

approval.chain_archived, approval.chain_deleted and approval.chain_restored DO emit an AuditableEvent, but with an ApprovalChainDefinition — tenant configuration rather than a per-request subject, and approval.chain_deleted fires after a hard delete, so no run could resolve a subject for it. They stay catalogue-only alongside the other configuration families. The approval.completed fact is additionally the clearest illustration of the emission firewall: canEmit() returns false for the whole family, so no workflow can ever assert that an approval completed.

To enable another family, deliver its explicit metadata and provider together: resolve the real subject, enforce the real capability and active connection, define redaction and payload/schema behavior, pin versions, preserve nonterminal retention, and add the allowed/denied/missing/trashed/cross-connection/malformed/redaction/provider-removal tests. A catalogue flag alone never grants executable support. A family whose subject is polymorphic additionally owes the delegation rule above: identify the owning family from the persisted row, delegate authorization to it, and refuse when no single owner can be found.