Where the weights come from

The scoring function lives in one module, decitect/domain/simulation.py; every coefficient lives in one frozen dataclass, SimulationParameters. There are no hidden constants: the table below is the complete set. The honest split is this: the mechanisms (what is penalised and why) come from the books; the magnitudes (the specific numbers) are engineering judgement, constrained where the code enforces a structural rule. A table claiming every number was derived from theory would not be believed and would not be true.

Signal / weight	What it does	Mechanism source	Magnitude
`authority_penalty` = 0.45	Multiplies a team's decision capacity when it lacks local authority.	Decision Architecture (authority before accountability); Relativistic Decision Architecture, Axiom 2 (authority worldlines)	Engineering judgement
`contested_penalty` = 0.35	Multiplies capacity for a team whose decisions carry a standing claim (matrix and dual reporting). Enforced to be at most `authority_penalty`; above the prince band the price deepens in proportion to the scaled escalation price, so contest costs strictly more than clean escalation at every scale.	Relativistic Decision Architecture, Axiom 2 refinement (a worldline that cannot name its owner is broken; the meta-question is the cost)	Judgement; the ordering constraint is enforced in code
`dunbar_headcount` = 150 `prince_band_upper` = 200 `prince_attenuation` = 0.3 `prince_amplification` = 0.25 `prince_survivor_ceiling` = 1.6	Price clean concentration by scale (the prince band). Up to 150 people the authority charges cost 0.3 of their flat price: the centre's light cone covers the whole organisation, so escalating to it is a conversation rather than a queue. Across 150 to 200 the price rises linearly to parity; above 200 it grows with the log of the population and caps at 1.6, so concentration at scale is graded, never prohibited. Contested ownership is never attenuated, only amplified.	Machiavelli, The Prince and the Discourses, unified by scale; Dunbar's number for the horizon; Relativistic Decision Architecture, Axiom 3 (light cones) and the limits of control (beyond its causal reach, authority becomes observation)	Horizon and band edge from Dunbar's number; magnitudes engineering judgement; the positive-capacity cap on the ceiling is enforced in code
`escalation_load_share` = 0.25	The fraction of an escalating team's workload that lands on its resolving authorities' queues. Each escalating team resolves at the nearest enclosing unit holding a clean authority: its concentration charges are priced at that unit's population (a desk-distance escalation is never priced at conglomerate scale) and its shed decisions load that unit's authorities, so a centre absorbing thirty teams' escalations saturates and prices itself. Deliberately not attenuated by the prince band: the band forgives communication friction at small scale, never decision bandwidth.	Decision Architecture (over-centralisation as bottleneck); LatencyLab's placement result (the singularity is a queue and it prices itself); Relativistic Decision Architecture (authority placement within causal reach)	Engineering judgement (a centre saturates at roughly a dozen escalation lines at typical workloads)
`dependent_demand_weight` = 0.15	Routes demand along dependencies. Each team waiting on an upstream lands this fraction of the frame's workload on the upstream's queue, authority notwithstanding: an empowered hub that thirty teams wait on saturates exactly as a deciding centre does. A light fan-out stays free while the upstream's capacity absorbs it, so the cost begins where the queue does.	Little's law (the shared upstream is a server and its wait grows with demand); LatencyLab's placement result (the singularity is a queue and it prices itself), applied to dependency concentration as it already was to authority concentration	Engineering judgement; held at or below `escalation_load_share` (enforced in code), since waiting on a supplier may never cost more than resolving through an authority
`unowned_interface_weight` = 0.5	Prices fragmentation. A dependency between two clean sovereigns that share no enclosing domain has no institutional roof under which its conflicts can be arbitrated, so each such edge pushes its endpoints toward the cannot-decide-cleanly share, scaled by the prince factor: two founders across a desk stay near-free while a roofless sovereign network at scale is priced. Any shared unit counts as a roof, which is a modelling claim the declared structure makes.	Machiavelli's Discourses (the republic is institutionalised: a senate, not merely distributed sovereignty); Decision Architecture (fragmentation: decisions made locally but conflicting globally)	Engineering judgement (two unowned interfaces fully compromise a team's clean-decision standing)
`coupling_weight` = 0.6	Divides capacity by 1 + 0.6 × the dependencies touching the team.	Decision Architecture (latency accumulation); The Move Space (coordination overload)	Engineering judgement
`incentive_weight` = 0.8	Divides capacity as the team's incentive skew rises.	Relativistic Decision Architecture, Axiom 5 (incentive-induced curvature)	Engineering judgement
`delay_arrival_weight` = 0.25	Inflates a team's effective arrivals per unit of incoming propagation delay.	Relativistic Decision Architecture, Axiom 4 (causal propagation)	Engineering judgement
`cognitive_load_weight` = 0.6 `ideal_team_size` = 3	Divides capacity per unit of team size beyond the comfortable band; zero for teams at or below it.	Engineering judgement (deliberately gentle: zero in the benign case, so it never disturbs an existing position)	Engineering judgement
`latency_weight` = 0.5	Share of the composite penalty carried by backlog at boundaries.	Decision Architecture ("decision latency is the first scaling bottleneck") justifies this being the largest share	Judgement; the three shares must sum to 1.0, enforced in code
`escalation_weight` = 0.3	Share carried by the fraction of teams that cannot decide locally.	Decision Architecture (escalation as the signal of missing authority)	Judgement; same sum-to-one constraint
`rework_weight` = 0.2	Share carried by mean incentive skew across the teams.	Relativistic Decision Architecture, Axiom 5 (skewed incentives surface later as rework)	Judgement; same sum-to-one constraint
`influence_weight` = 0.08 `influence_tolerance` = 1	Divides the whole score by the per-team mean of influence-without-authority load (excess inbound dependence on teams that cannot decide locally), so one overloaded hub costs a large organisation a proportionate slice of its score rather than half of it.	Decision Architecture (delegation without authority); Decision Architecture Patterns (decision shadow, phantom authority)	Engineering judgement (gentle by design)
`contested_weight` = 0.1	Divides the whole score per standing claim: the structural owner is claimant one, so each claim is one claimant too many.	Decision Architecture Patterns (decision semaphore, phantom authority); Relativistic Decision Architecture (authority fragmenting within a domain manufactures coordination load)	Engineering judgement (gentle by design)
`base_capacity` = 12.0	Decisions a team can clear per turn before penalties; sets the scale that arrivals are measured against.	Queueing framing (arrivals against capacity)	Engineering judgement
Classification bands: great ≥ +9, good ≥ +3, blunder ≤ −1	Turn a move's score delta into a grade from blunder to great.	The Move Space (the move taxonomy itself)	Band edges are engineering judgement
Move constants: approval gate delay = 3; stabilise and realign retention = 0.4; consultation delay = 1	Shape what each move does: a new approval gate arrives with delay on every team; stabilising interfaces and realigning incentives pull values toward zero without forcing them there; downgrading a claim prices the consulted party as one turn of explicit waiting. The matrix overlay needs no constant: its damage is pure contest.	The Move Space (the blunder and good-move catalogues)	Engineering judgement

The magnitude column is uniform on purpose. The books argue what should be penalised and in which direction, which is why the mechanism column can cite chapters; they state no coefficient values, so no derivation is claimed for any. The chosen values are held accountable a different way: each sits in one published dataclass, every score decomposes into named penalties and the structural constraints (the sum-to-one shares, the contest ordering) are enforced in code, so a disputed magnitude is something you change and rerun rather than something you argue about.

The model Assumptions and known limits Testing the model