Skip to content

Channel: Governance (0x0004)

Policy and the approval workflow. Like every channel surface, Governance adds only kind codes and their declared effects over the one object model — the approval mechanism itself lives in the spine (the draft's Approval section); this surface is the workflow that reaches it (the draft's Channel Surfaces section).

Baseline kinds

Code Kind Effect Notes
0 PolicyPublish non_idempotent_write a signed policy naming, per effect class and capability, what is authorized
1 Approval non_idempotent_write the spine's approval object
2 ApprovalHeld read_only an action held pending approval
3 Consume non_idempotent_write the single-use ledger append
4 GatewayDecision non_idempotent_write portable, vendor-neutral enforcement-gateway evidence (§ below)
5 DecisionRecord non_idempotent_write the full governed-decision accountability record (§ below)
6 EgressAttestation non_idempotent_write signed egress-crossing evidence (§ below; wire-freeze pending)
7 HazardAuthorization non_idempotent_write physical-hazard authorization for manufacturing/robotics deployments (§ below)

This is the current registry impl/go/channels/channels.go carries verbatim (Table entry for Governance), cross-checked against an independent per-channel oracle so Go, Rust, and the oracle agree on every kind code and effect.

State model

An approvable action is requested → (held | approved) → consumed | expired. Consume is a single-use ledger append (the draft's Approval section): a replayed authorization is rejected AlreadyConsumed with no state change, never a second grant.

Vendor-neutral, third-party-reverifiable evidence: GatewayDecision

GatewayDecision is a signed decision object an enforcement gateway of any vendor emits as portable evidence that it decided about an action. Its load-bearing property is that authority lives in the signed bytes, never in the connection or the host that served them: VerifyDecision takes no serving-party or connection identity, so the identical signed decision re-verifies when a party other than the gateway serves it (the third-party re-serve property).

// impl/go/gateway/gateway.go — the closed decision outcome set
const (
    DecisionAllow uint64 = 0 // the gateway allows the action
    DecisionDeny  uint64 = 1 // the gateway denies the action
    DecisionHold  uint64 = 2 // the gateway holds the action pending a further step
)

(gateway.go:42-45). GatewayDecision {1: decision, 2: action, 3: policy, 4: effect} defines the evidence format only, never a policy language: action is the content id of the action decided about, policy is the opaque identity of the deciding policy (a name, not a policy program), and effect is the C5 effect class of the action.

The full accountability record: DecisionRecord

DecisionRecord is the signed record a governed decision point emits when it decides about an action under a closed, uniquely-selected condition set. It carries a three-part accountability claim (the draft's Channel Surfaces section): unique selection (the governing set, named in the clear as content ids), governed-at-decision-time (the consume-receipt spent at decision time), and binding-fixed-by-decision-time (established off-record by inclusion under a witnessed checkpoint root — see Audit). The record is deliberately clock-free: it carries no self-asserted timestamp anywhere in its own body; both time properties are positional, never claimed. ParseDecisionRecord and ValidateDecisionRecord follow the same structural-parse/semantic-validate split gateway.go established for GatewayDecision (decision_record.go).

Physical-hazard authorization: HazardAuthorization

HazardAuthorization is a manufacturing/robotics addition (design.md addendum) that authorizes an action carrying physical danger. It is an orthogonal dimension from the C5 effect lattice: the effect (envelope field 7) describes data reversibility, while a hazard claim describes physical danger — a data-reversible action can still be a high physical hazard, and neither dimension derives the other. HazardClassFromCode is the one fail-closed decode entry point: any missing or out-of-range raw value normalizes to the highest hazard class, MotionInSharedSpace, never a weaker one — mirroring the effect lattice's own unknown-to-destructive rule (hazard.go). HazardAuthorization's wire shape was frozen 2026-09-01 with the maintainer's approval; it is graded byte-identical against the shared, non-circular vectors/hazard corpus in both Go and Rust, with the remaining eight-port propagation tracked in the parity ledger.

Named, honest gap: EgressAttestation's wire freeze

EgressAttestation's Go implementation is built and tested, but — unlike HazardAuthorization — its CDDL production, top-level object-choice registration, parity-baseline entry, and conformance-corpus operation have not yet landed in a maintainer-approved wire-freeze commit as of this writing. It is documented here for completeness of the current code, not as a claim that its wire bytes are final; see the Audit page and the draft itself for the authoritative, frozen wire shape once that freeze lands.

Failure modes

Error kind When
ApprovalRequired an effecting action has no covering approval
ApprovalMismatch a bound approval does not match the action's content id
AlreadyConsumed a replayed single-use approval
EffectNotAuthorized the approval's granted effect does not cover the action's effect

Every check is fail-closed (the draft's Security Considerations section): a failing action is rejected whole, returns its named error, and causes no state change.

See also: the twenty channels, effects and safety, the Audit channel for the checkpoint-root anchor a DecisionRecord binds to.