Governance

Governance is the per-contract decision about who owns the billing logic for this contract. It is distinct from invoice generation: a concorbit-governed contract can still be in at_mirrored billing mode, where AT keeps generating the customer's actual invoice while concorbit computes billing parity against it in the background.

Governance lives on support_contracts.governance (concorbit or autotask). The matching invoice marker is invoices.governance and can be one of concorbit, autotask, or quickbooks. The axes are intentionally separate; flipping governance does not flip the billing mode.

What changes when a contract flips to concorbit-governed

For an AT-governed contract, Autotask is the system of record for the contract's overage and quantity-change logic. concorbit reads but does not decide.

For a concorbit-governed contract:

Overage resolution. concorbit's CoverageResolver decides when a ticket's time entry consumes the contract block versus when it spills into a billable overage charge. AT's contract-services trigger no longer drives the decision.
Service-change pipeline. Quantity changes the customer requests in the portal (or staff enters in the Service catalogue) flow through concorbit's approval workflow, then become charges. push_contract_adjustments never echoes these back to AT once a contract is concorbit-governed, AT no longer owns it, so there is nothing to keep in sync. The echo-push is for AT-governed lines only (EchoServiceChangeToAutotask and the push service both refuse for a concorbit-governed line, even one that still carries an AT link from before the flip).
Recurring service charges. The ConcorbitRecurringServiceCreator emits real recurring charges for future periods of this contract. Past periods stay AT-governed evidence.

The per-contract flip

From Settings, Autotask, Governance:

Open the Governance tab. Contracts are grouped per customer.
Click a contract to see the preflight check. The system blocks the flip unless every gate passes.
Provide a reason (required, audited) and confirm.

BlockGovernanceFlipPreflightService evaluates five gates:

Gate	What it checks
contract_type_supported	The AT contract type maps to a model concorbit can govern (block-hour, recurring service).
status_active	The contract is active in both systems.
parity_green	Recent invoice parity has been green; the AT mirror is faithful.
block_sync_fresh	Block balances have synced recently enough to trust.
no_in_flight_billables	No unbilled charges are in the middle of a billing run.

Operators with autotask.manage can bypass with --force from the CLI, which writes a distinct governance_flipped_forced audit row.

Bulk flip per customer

The Governance tab also supports a bulk flip across every flippable contract for one company. The preflight runs per contract and reports which contracts would skip. With --skip-failures the bulk applies the flippable subset and reports the rest as refused.

The umbrella audit row records the per-contract outcomes. Already-applied contracts inside a bulk are not co-reverted if a later contract fails, each contract's flip is its own transaction.

Reversibility

A governance flip is reversible from the same UI. The reverse direction (concorbit, back to AT-governed) is a deliberate operator action with the same audit posture. The cardinal rule: a contract that is mid-billing-run cannot be flipped in either direction until the run completes, the no_in_flight_billables gate enforces this.

Governance versus billing mode

governance and autotask_billing_mode are different axes:

A concorbit-governed contract can be at_mirrored (AT still generates the invoice). That is the billing-parity window, the period where concorbit's billing logic has taken over the decisions but the customer keeps paying AT-generated invoices for continuity, with parity proving the numbers agree before the invoice itself moves too.
A flip to concorbit_native billing mode happens on the Cutover tab, separately. Governance is a precondition; cutover is the next step.

This separation is what lets a tenant prove out concorbit's billing logic for weeks against a real AT invoice stream before any customer-facing change.

Invoice governance

invoices.governance is set at creation time from the same axis:

concorbit (the default for natively-created invoices). concorbit's lifecycle applies (autopay, dunning, the £0 paid lifecycle, dispute freezes).
autotask. AT owns the mutable state; every reconciler pass hard-sets status from AT's flags. concorbit's lifecycle does not apply until the contract is flipped.
quickbooks. QB owns the lifecycle. AT wins over QB on co-linked invoices (precedence is AT, then QB).

Recording a payment via Payments refuses on AT-governed or QB-governed invoices to prevent ledger desync.

What governance does not do

Governance does not change who pays the AT invoice for past periods. AT continues to bill the customer until the contract is also flipped to concorbit_native billing mode through Cutover.
Governance does not silence AT. The mirror keeps pulling AT invoices and charges; that is what feeds the parity checks.
Governance does not break dunning. While a contract is at_mirrored, no concorbit dunning fires for its invoices because they are AT-governed and AT owns retries.

See Billing parity for the parity surface that proves concorbit's billing matches AT's before you cutover.