Understanding Government as a Civilisation Coordination OS

(V1.1 — Civilisation OS lens)

Most people think government is “leaders + laws + elections.”
Civilisation OS treats government as something more basic:

Government is a coordination and repair Operating System for a dense, role-dependent society.
It exists because minSymm was crossed (exchangeability broke, roles became mandatory), and it survives only while regeneration stays ahead of decay + load.

If you remove the slogans, the mechanics are simple:

people collide in the same space
disputes and risks become unavoidable
public goods must be maintained
replacement and repair must be routed
trust must be stabilised with verification

That is what governments are for.

Start Here:

Definition Lock Box (copy/paste) Immutable. Do Not Drift

Government: the civilisation-scale coordination organ that sets rules, resolves disputes, funds shared buffers, and routes repair under load so a society can stay inside its survivability band.

minSymm: the point where perfect agent exchangeability becomes impossible; above it, roles + dependency are forced by space–time density.

MVCₓ: a system survives only while Regeneration Capacity R(t) ≥ Decay + Load D(t).

Buffers: counted, trusted reserves (people, capacity, stock, time, credibility) that absorb shocks.

Phase (P0–P3): reliability under load. P0 unsafe, P1 supervised, P2 reliable, P3 robust + teaches/standardises.

Zoom (Z0–Z3): skills → person-in-role → institution → city/nation.

MinSymm Formula Box (Copy/Paste — WordPress-ready)

Definition lock (canonical):
minSymm (Minimum Symmetry-Breaking Condition) is the point where perfect agent exchangeability becomes impossible.
Operationally, it is the coordination crossover where independence becomes more expensive than coordination, forcing roles + dependency.

A) Master threshold (most general)

Cost crossover (minSymm): $C_{ind} (N, ρ, \dots) \geq C_{coord} (N, ρ, \dots)$ Cind(N,ρ,…)≥Ccoord(N,ρ,…)

Plain English: when duplication + collisions + search time cost more than rules + queues + protocols.

B) Space saturation / territory overlap form

Density: $ρ = \frac{N}{A}$ ρ=AN

Overlap ratio: $ϕ = \frac{N \cdot π R_{f}^{2}}{A}$ ϕ=AN⋅πRf2

minSymm (space form): $ϕ \geq ϕ_{crit} \approx 1$ ϕ≥ϕcrit≈1

Plain English: when combined “territory footprints” saturate the same space, overlap becomes unavoidable → roles/protocols become cheaper.

C) Encounter / collision rate form (contact mechanics)

Unplanned encounter rate (per agent): $λ_{e} \approx 2 r v ρ$ λe≈2rvρ

minSymm (contact form): $λ_{e} \geq λ_{crit} ⟺ ρ \geq \frac{λ_{crit}}{2 r v}$ λe≥λcrit⟺ρ≥2rvλcrit

Plain English: when collisions/interruptions become frequent enough, you need protocols (queues, boundaries, handoffs).

D) Search / travel time dominates form

Nearest-neighbour distance in 2D scales as: $ℓ \sim \frac{1}{\sqrt{ρ}}$ ℓ∼ρ1

Search/travel time: $T_{search} \sim \frac{ℓ}{v} \sim \frac{1}{v \sqrt{ρ}}$ Tsearch∼vℓ∼vρ1

minSymm (time-budget form): $T_{search} \geq α T_{budget}$ Tsearch≥αTbudget

Plain English: when “finding stuff/people” eats too much of the day, coordination beats independence.

E) Exchangeability break form (substitution index)

Define exchangeability: $X = 1 - \Pr (substitution failure under normal load)$ X=1−Pr(substitution failure under normal load)

minSymm (exchangeability form): $X \leq X_{crit}$ X≤Xcrit

Plain English: when replacement by “any other agent” fails often enough, symmetry has broken.

F) Role-splitting becomes optimal (specialisation inequality)

$P_{spec} - P_{gen} > C_{switch} + Δ C_{coord}$ Pspec−Pgen>Cswitch+ΔCcoord

Plain English: specialists outperform generalists once switching overhead + errors exceed added coordination cost.

G) Below-minSymm binary regime detector (one-deep redundancy)

Let $d_{j}$ dj be redundancy depth for critical role $j$ j (number of capable substitutes). $\min_{j} d_{j} \leq 1 \Rightarrow binary open/closed dynamics$ jmindj≤1⇒binary open/closed dynamics

Plain English: one-person-deep roles create open/closed behaviour.

H) Reverse minSymm / re-symmetrisation trigger (collapse direction)

Let $L_{rep}$ Lrep = replacement latency; $T_{half}$ Thalf = skill memory half-life / churn window. $L_{rep} > T_{half}$ Lrep>Thalf

and/or $\frac{d}{d t} (\min_{j} d_{j}) < 0 persistently$ dtd(jmindj)<0 persistently

Plain English: if replacement is slower than decay/churn, the lattice thins back toward one-deep binary behaviour.

Variable legend (minimal)

$N$ N: agents; $A$ A: usable area; $ρ$ ρ: density
$r$ r: interaction radius; $v$ v: typical movement/search speed
$R_{f}$ Rf: effective footprint/territory radius for the task lane
$λ_{e}$ λe: encounter rate; $T_{budget}$ Tbudget: time window; $α$ α: tolerable fraction
$X$ X: exchangeability; $d_{j}$ dj: redundancy depth; $L_{rep}$ Lrep: replacement latency; $T_{half}$ Thalf: memory half-life

MinSymm Sensor Panel (Copy/Paste — Field Diagnostics)

Goal: classify a system as Below minSymm, At/near minSymm, Above minSymm, or Reverse minSymm (re-symmetrising) using observable signals.

1) Coordination Crossover Test (the fastest sensor)

Run a simple A/B:

A (independent): everyone acts without protocol
B (coordinated): add a basic rule (queue, roster, handoff, checklist, boundary)

If B increases throughput or reduces conflict dramatically, you are at/above minSymm.
This is the operational meaning of $C_{ind} \geq C_{coord}$ Cind≥Ccoord.

2) Collision / interruption sensor (contact proxy)

Track for one day:

unplanned interruptions per person per hour
conflict events per shift (overlap, double-work, “you took my slot”)
queue formation frequency

If collisions become “normal operating conditions,” you’ve crossed minSymm in that lane.

3) Search/travel tax sensor (time-budget proxy)

Ask:

“How much of the day is spent finding people/resources/info rather than doing the work?”

If search/time-to-find exceeds a meaningful fraction of the day (choose (\alpha) per lane), you’re in minSymm territory:

clinic/pharmacy lanes → low tolerance
casual/low-stakes lanes → higher tolerance

4) Exchangeability test (substitution drill)

Pick a role/task and test substitution:

Can another person take over today without quality collapse?
What is the success rate over 10 attempts?

Define:

X ≈ success rate

If X is consistently low, symmetry is broken (above minSymm).

5) Redundancy depth scan (one-deep detector)

List critical roles and count substitutes:

“How many people can do this task to acceptable standard right now?”

Let that count be (d_j).

If any high-bearing role has $d_{j} \leq 1$ dj≤1, you have binary open/closed fragility in that pocket.

6) Replacement latency vs memory half-life (reverse-minSymm detector)

Measure:

$L_{rep}$ Lrep: time to train + verify + deploy a competent replacement
$T_{half}$ Thalf: time before capability drifts / people churn / skill becomes unreliable

If Lrep>ThalfLrep>Thalf, you are re-symmetrising (reverse minSymm).
This is the clean “collapse direction” sensor.

7) MinSymm Status (quick classification)

Below minSymm: few explains-needed protocols; low collision; substitution easy; many roles not persistent
At/near minSymm: collisions rising; basic rules suddenly help; roles start splitting; substitution begins failing
Above minSymm: role dependency obvious; protocols/queues required; exchangeability low; verification becomes central
Reverse minSymm: one-deep roles spreading; closures become common; replacement too slow; trust/verification degrading

One-line lock (optional)

minSymm is crossed when basic coordination outperforms independence because space–time density makes exchangeability impossible; reverse minSymm occurs when replacement latency exceeds capability half-life and the lattice thins back toward binary open/closed behaviour.

The first principle: why government exists at all

In a low-density world, people can live more independently.
In a high-density world, independence becomes expensive:

travel/search time rises
overlap creates conflict
duplication becomes waste
coordination becomes cheaper than independence

That is the minSymm threshold.

Once minSymm is crossed, you get a role-dependent lattice (economy, schools, hospitals, ports, courts, utilities).
And role-dependent lattices require a coordination OS to prevent constant collision and cascade failure.

That OS is government.

What government actually does (the 6 core functions)

If you strip away ideology, governments do six mechanical jobs:

1) Rule-setting (protocols)

Rules reduce coordination cost by making behaviour predictable.

property rules
contract rules
safety standards
zoning and use of shared space

A rule is not “control” first. It is compression: fewer disputes, less friction, faster coordination.

2) Dispute resolution (courts and enforcement)

A dense system generates conflicts even among good people.

who owns what
who owes what
who caused harm
what counts as evidence

Without a resolution engine, disputes become private warfare, which raises coordination cost and collapses trust.

3) Public goods (things markets don’t maintain well alone)

Some systems are shared by nature:

roads and transport corridors
sanitation
disease control
national defense
baseline education and safety systems

Public goods are often “invisible until broken,” which makes them classic buffer organs.

4) Buffer funding and replenishment (taxation as throughput)

Tax is not just revenue. In system terms:

Taxation is a replenishment channel that keeps shared buffers from thinning.

Buffers include:

emergency capacity
maintenance throughput
trained operators (civil service, teachers, healthcare)
redundancy in critical systems

When buffer funding fails, collapse happens as silent attrition first, then sudden brittleness.

5) Verification and trust (measurement layer)

A civilisation needs shared reality:

statistics, registries, IDs
audits and standards
reliable measurement (from land titles to medicine safety)

When verification fails, trust collapses and coordination becomes expensive (everyone retreats into small circles).

6) Repair routing under load (crisis management)

Shocks are normal: pandemics, floods, financial stress, migration waves, war risk.

Government’s real test is whether it can:

detect drift early
prioritise repairs
route scarce resources
prevent cascades

This is Civilisation Flight Control in action: keeping the system inside the envelope.

Government is not “one thing” (it’s a stack)

Most confusion comes from treating government as a single object.
In reality it’s a layered machine:

Policy layer: intent, priorities, budgets
Implementation layer: agencies, civil service, logistics
Verification layer: audits, statistics, courts, inspectors
Feedback layer: elections, oversight, media, reviews
Repair layer: emergency response, upgrades, recovery

If the implementation and verification layers degrade, “good policy” becomes theatre.
If feedback degrades, corruption and drift go uncorrected.

Phase×Zoom: how government works (Z0 → Z3)

Z0 — Civic primitives (skills)

The atomic skills that make government possible:

basic numeracy and shared measurement
literacy and rule comprehension
queueing, turn-taking, procedural discipline
verification habits (“show evidence, reconcile numbers”)

A society can’t “vote itself” into competence if Z0 primitives collapse.

Z1 — Person-in-role (operators)

honest, trained civil servants
inspectors who understand standards
police who can apply rules without chaos
judges and administrators who can process cases under load

At Z1, failure looks like: one-deep roles, bottlenecks, arbitrary decisions.

Z2 — Institutions (org reliability)

ministries/agencies that can execute repeatedly
procurement that doesn’t rot
courts that clear cases
emergency services with real surge capacity

Z2 is where trust is won or lost: “does the machine work daily?”

Z3 — Nation/city survivability

maintaining buffers across decades
preventing cascades across sectors
balancing redundancy vs overshoot
managing corridor shocks (trade, finance, security, disease)

Z3 is what people call “stability.”

The Governance OS Lattice

Governance, in CivOS terms, is the control layer that keeps a role-dependent lattice inside its survivable envelope. It isn’t “politics” (preference debate) and it isn’t “government” (one institution). It’s the distributed control system that sets rules, measures reality, routes repairs, and stabilises trust so the whole lattice can keep running under load.

Below is governance mapped cleanly into your 3D scaffold: Phase × Zoom (Z0–Z3) plus the pocket/layer grid(capability pockets × responsibility layers).

Governance in the 3D scaffold

Axis 1: Zoom (where governance lives)

Governance exists at every zoom level:

Z0 (atomic): the micro-rules that make actions safe and verifiable (units, checklists, evidence habits)
Z1 (person-in-role): how individuals apply rules, escalate, and repair under load (operator discipline)
Z2 (organisation/institution): how agencies/companies/schools standardise, audit, and correct drift (org control loops)
Z3 (city/nation/civilisation): cross-system coordination, buffer funding, emergency routing, legitimacy and trust at scale

Axis 2: Phase (reliability under load)

Each governance cell has a Phase value:

P0: arbitrary / unsafe / non-verifiable
P1: works only with supervision or exceptional people
P2: reliable routine execution (defined scope)
P3: robust under shock; handles exceptions; teaches/standardises

Axis 3: Governance “pockets” (functional lanes of control)

Governance isn’t one lane. It is a bundle of control pockets that must all stay above threshold together:

Rule-making / Protocols (standards, laws, operating rules)
Execution / Operations (implementation, service delivery)
Verification / Measurement (audits, statistics, evidence, registries)
Enforcement / Compliance (sanctions, inspections, policing)
Dispute Resolution (courts, arbitration, appeals)
Resource Routing (budgeting, procurement, staffing)
Buffer Management (surge capacity, reserves, redundancy)
Learning / Repair Loops (after-action reviews, policy update cycles, continuous improvement)
Legibility / Interface (clarity to citizens/operators; forms, portals, published rules)
Crisis Command (incident response, prioritisation, triage under load)

Think of these as governance pockets that can each be P0–P3 at each zoom level.

The Governance Lattice: what it looks like

1) The Phase×Zoom Governance Grid

You can represent governance as a grid:

Rows: Zoom (Z0, Z1, Z2, Z3)
Columns: Governance pockets (rules, execution, verification, etc.)
Each cell: Phase P∈[0,3] (decimal Phase is allowed)

A high-functioning system is not “P3 everywhere.”
It’s no P0 holes in high-bearing pockets and fast repair routing when a pocket drifts.

2) The Pocket–Layer view (PPP-style, applied to governance)

Governance also has “responsibility layers” (who is allowed to decide, how much scope, how much autonomy). So you can mirror PPP:

X-axis (pockets): the governance pockets above
Y-axis (layers): responsibility layers (local operator → supervisor → director → national policy)
Each cell has a Phase (reliability)

This is why “good laws” can fail: the rule pocket might be P2/P3, but the execution or verification pocket at Layer 2–4 is P0/P1.

A practical 3D definition of governance

Governance = the lattice of rules, verification, enforcement, dispute resolution, and repair-routing that keeps a society’s role-graph stable under load.

Or in your canonical threshold language:

minSymm forces role dependency (governance becomes mandatory)
MVCₓ is survivability: governance must help keep R(t) ≥ D(t)
Buffers are counted, trusted reserves that governance funds and protects
Phase×Zoom is the instrument panel for governance reliability

Why governance is “lattice-structured” (not top-down)

Governance is not a single command chain. It is distributed because:

rules are created at many layers (national, sector, organisation, team)
verification is distributed (auditors, logs, statistics, reconciliations)
enforcement exists at many interfaces (inspectors, managers, courts)
repair happens locally first, escalates only when local Phase collapses

So governance is a network of control loops, not one loop.

This is exactly why it behaves like a lattice:
holes in one pocket can be compensated—until coupling + load make the hole propagate.

Failure physics: how governance collapses in the lattice

The most common collapse sequence (re-symmetrisation)

Verification drifts (numbers no longer trusted)
Enforcement becomes arbitrary (rules apply inconsistently)
Execution becomes workaround-based (informal routes replace official ones)
Trust collapses (people retreat into small circles)
The system becomes “one-deep” again → binary open/closed behaviour returns in critical services

That is re-symmetrisation in governance form: the lattice thins, redundancy vanishes, and institutions behave like below-minSymm systems.

The “high-bearing pocket” rule

Governance can look fine even with many weak pockets—until a high-bearing pocket hits P0. High-bearing pockets are usually:

Verification
Dispute resolution
Buffer management
Procurement/resource routing
Crisis command

A P0 in any of these tends to propagate upward fast.

Governance sensors (instrumentation) inside the lattice

If you want a governance dashboard, these are the simplest “Phase sensors” per pocket:

Verification pocket sensors

reconciliation error rates rising
audit backlog growing
statistics disputed / inconsistent across sources
“phantom inventory” or budget mismatch

Dispute-resolution sensors

case backlog time-to-resolution lengthening
inconsistent outcomes for similar disputes
rising private enforcement (people bypassing courts)

Enforcement sensors

selective enforcement reports increasing
bribery/informal payment frequency rising
inspection coverage falling under load

Buffer sensors

surge capacity decreasing
maintenance deferrals rising
stockout frequency increasing
replacement/training pipeline latency rising

These are governance’s equivalent of vital signs.

Governance upgrades (how to climb Phase)

P0 → P1 (stop harm)

shrink scope to a narrow corridor
publish simple rules that can be followed
add supervision + checklists
restore minimum verification (count/measure/rate/verify)

P1 → P2 (stable routine)

standardise processes
train operators to independent execution
enforce consistently
install feedback loops (AARs, audits, reconciliation)

P2 → P3 (robust under shock)

build surge buffers
practice drills (crisis command)
shorten repair routing time
codify lessons so capability survives personnel changes

In lattice terms: repair the highest-bearing pockets first, then expand.

A clean way to say it (optional lock)

Governance is a Phase×Zoom control lattice: distributed rules, verification, enforcement, and repair-routing that keeps a role-dependent society inside its survivable buffer band.

The survivability equation (why governments fail)

Government failure is often explained as “bad leaders.”
Civilisation OS asks a more predictive question:

Did the system fall below MVCₓ?
R(t) ≥ Decay + Load D(t) no longer holds.

Common ways that flips:

maintenance debt grows faster than repair capacity
trained operators aren’t replaced (pipeline failure)
corruption destroys verification
coordination cost rises (too many rules, too many exceptions, too much fragmentation)
buffers thin while complexity stays high

When the inequality flips, institutions don’t fail all at once.
They fail as drift → backlog → brittleness → cascade.

The inversion test: what “Phase 0 Government” looks like

Phase 0 Government isn’t “no government.”
It’s government that cannot be trusted under normal load.

Signals:

laws exist but are inconsistently applied
permits require bribery or random luck
courts backlog for years
numbers cannot be trusted (statistics, budgets, inventories)
emergency response is improvisation, not protocol
people prefer private enforcement over institutions

The outcome is always the same mechanically:

coordination cost explodes → trust collapses → people retreat → the lattice thins → binary open/closed behaviour returns.

That is re-symmetrisation collapse at scale.

The Buffer Safety Band for governments

A government must operate between two cliffs:

Too thin (fragile asymmetry)

one-deep expertise
no surge capacity
maintenance postponed
slow replacement pipelines

Result: brittle cascades.

Too thick (overshoot/bureaucratic brittleness)

excessive structure
too many layers and approvals
coordination cost overwhelms execution
slow response under load

Result: paralysis, then informal workarounds, then trust collapse.

Good governance is staying inside the Buffer Safety Band: enough redundancy to survive shocks, not so much overhead that the system stalls.

How governments improve (recovery protocol)

This is the non-glamorous truth: recovery is mostly verification + pipelines + maintenance.

Step 1: Rebuild verification in a narrow corridor

Pick one lane (e.g., customs, permits, healthcare procurement) and restore:

count → measure → rate → verify

Step 2: Fix operator pipelines (Education OS)

training standards
apprenticeship and supervision (P1)
independent reliability (P2)
standardisation and teaching capacity (P3)

Step 3: Pay maintenance debt down

Maintenance is not optional; it is the price of staying above threshold.

Step 4: Reduce coordination drag

Cut complexity where it doesn’t add safety or trust:

simplify processes
standardise forms
remove redundant approvals
clarify interfaces between agencies

Step 5: Scale outward only after Phase 2 reliability holds

If you expand reforms before reliability stabilises, you spread fragility.

minSymm and when Governments start

Governments start at the exact moment a society crosses minSymm and then needs a persistent coordination + verification organ to stop the role-lattice from collapsing into constant conflict.

minSymm in one sentence

minSymm (Minimum Symmetry-Breaking Condition) is the point where perfect agent exchangeability becomes impossible.
Below minSymm, people can remain mostly interchangeable and independent. Above it, roles + dependency become mandatory.

Why minSymm forces “government” to appear

When space–time density rises, independence stops being cheap:

travel/search time rises
territories overlap
duplication becomes waste
conflict frequency rises
coordination becomes cheaper than independence

That crossover is the minSymm threshold.

And once coordination becomes cheaper than independence, the system must “compress” coordination using:

rules (“don’t do X here”, “queue like this”)
boundaries (property, territory, access)
verification (who owns what, who promised what)
dispute resolution (what happens when two claims collide)
enforcement (what happens when rules are broken)

That compression bundle is the seed of government.

The real start condition (not a headcount)

Governments don’t start at a magic population number. They start when a society needs persistent protocols to keep everyday life stable.

A clean mechanical start condition:

Government starts when:

Role dependency exists (specialisation is real, substitution is non-trivial)
Collision/dispute frequency is high enough that ad-hoc negotiation wastes too much time
Shared goods and shared risks appear (paths, water, sanitation, defense, disease)
Verification becomes necessary (property, debts, weights/measures, identity)
The society needs a repair router under load (famine, flood, war, epidemics)

When those five become true, “government” is no longer optional—it’s a forced OS.

The earliest forms of government (what it looks like at birth)

Early government doesn’t look like a modern state. It looks like:

a boundary rule + someone to enforce it
a queue rule + a referee
a standard weight/measure + a checker
a registry (who owns what / who owes what)
a council/elder/court function to settle disputes
a tax/tribute mechanism to fund shared buffers (guards, granaries, maintenance)

In CivOS terms: government begins as protocol + verification + enforcement + repair routing.

The “government emergence ladder” (minSymm → durability)

You can see governments “turn on” in phases:

Stage A: Below minSymm (binary)

one-deep roles
life is open/closed per person
disputes are personal
rules are informal

Stage B: At/just above minSymm (fragile asymmetry)

roles split (farmer, builder, guard, healer)
disputes rise (property, access, debts)
ad-hoc negotiation becomes too expensive
government appears as local refereeing + basic standards

Stage C: Redundancy band (stable governance)

stable courts/administration
predictable enforcement
buffers funded and counted (grain stores, maintenance, training)
repair routing works under load

Stage D: Overshoot/brittleness

too much structure or corruption destroys verification
coordination cost rises
enforcement becomes arbitrary
trust collapses and the lattice thins (re-symmetrisation)

One-line lock (optional)

Governments start when space–time density breaks exchangeability (minSymm), forcing role dependency and frequent collisions—so a persistent coordination, verification, dispute-resolution, and repair-routing OS becomes mandatory.

FAQ

Is government the same as politics?

No. Politics chooses priorities. Government executes coordination and repair.
A society can have loud politics and weak execution, or quiet politics and strong execution.

Why do good policies fail?

Because policy is upstream. If Z1 operators and Z2 institutions are P0/P1, outcomes won’t hold under load.

Why does corruption hurt so much?

Because corruption attacks verification. Once measurement and trust collapse, coordination cost spikes and the system becomes brittle.

Why do small countries sometimes look “better governed”?

Often because they can keep tighter verification loops, simpler interfaces, and clearer maintenance routing (lower coordination drag). It’s a scale and complexity problem, not a moral one.

What is the single most important government capability?

Reliable repair under load.
Everything else—rules, budgets, services—depends on whether the system can detect drift and route fixes before cascades.

One-line lock (optional)

Government is civilisation’s repair-and-coordination flight computer: it reduces collision cost, maintains shared buffers, enforces verification, and routes repair so the society stays above threshold.

Block B — Phase Gauge Series (Instrumentation)

Phase Gauge Series (Instrumentation)
https://edukatesg.com/phase-gauge
https://edukatesg.com/phase-gauge-trust-density/
https://edukatesg.com/phase-gauge-repair-capacity/
https://edukatesg.com/phase-gauge-buffer-margin/
https://edukatesg.com/phase-gauge-alignment/
https://edukatesg.com/phase-gauge-coordination-load/
https://edukatesg.com/phase-gauge-drift-rate/
https://edukatesg.com/phase-gauge-phase-frequency/

The Full Stack: Core Kernel + Supporting + Meta-Layers

Core Kernel (5-OS Loop + CDI)

Mind OS Foundation — stabilises individual cognition (attention, judgement, regulation). Degradation cascades upward (unstable minds → poor Education → misaligned Governance).
Education OS Capability engine (learn → skill → mastery).
Governance OS Steering engine (rules → incentives → legitimacy).
Production OS Reality engine (energy → infrastructure → execution).
Constraint OS Limits (physics → ecology → resources).

Control: Telemetry & Diagnostics (CDI) Drift metrics (buffers, cascades), repair triggers (e.g., low legitimacy → Governance fix).