Glossary

The terms the sizing and staffing output depends on, each with the tool that will run it, why it exists, and the rough math it uses. The tools are planned and not built yet, and every formula is an assumption until real work tests it.

Where each rule stands is on Status & Pilot Readiness.

Measures

TermKindToolWhy it existsRough math
Scope Units deterministic size How many independent instances of a capability an engagement needs, as opposed to how senior the work is. A human override is a correction, since a formula exists, even a rough one. 
instances = ceil(scope_units / leverage_by_level[level])
Surface area deterministic size How many units of work run at once, so need attention at the same time; sequenceable units take turns and do not add to it. A human override is a correction, since a formula exists, even a rough one. 
concurrent:   surface_area = instances
sequenceable: surface_area = ceil(scope_units / (engagement_duration / unit_duration))
Required level judgment size The level the work demands: the highest stake any live risk shape puts on the capability, never the dial, which moves, and never who is available. Recorded as a variation, not a correction. The first logged variations should show whether a dial intensity lookup would reproduce them or whether `basis` needs its own scale, read from clustering in the rationale and not assumed in advance. 
demanded_level = max(stake(shape, capability) for shape in live_shapes)
#  stake() is a human call, logged with its basis
Effective capacity judgment size How much surface area one operator holds at the demanded level, given how far their caliber sits above it. Recorded as a variation until the multiplier curve has backtested values. By hand, read the multiplier for the caliber gap, multiply the nominal capacity, cap at `hard_ceiling`, and log the variation with its rationale. 
effective_capacity = min(nominal_capacity[demanded_level] * multiplier_by_gap[gap], hard_ceiling)
Seat count deterministic size How many seats the work needs: a ceiling from demand, and a floor from validated surface area only. Operator-specific counts use effective capacity, which is not yet defined. A human override is a correction, since a formula exists, even a rough one. Any operator-specific path inherits `effective_capacity`, which is a judgment term. 
demanded_count = ceil(surface_area / nominal_capacity[demanded_level])

Checks

TermToolWhy it existsFails when
Build and QA segregation segregation_check One person may not hold both Product & interface building and Validation & testing on the same engagement, whatever the scheduling says. Fails when one seat, or one title's default_executes, covers both capabilities of a segregated pair.
Undefined scope gap_list A capability with no scope block, or a missing field, is undefined and is never read as one. Fails for each capability with no scope_decomposition, a status of not_yet_defined, or a field left out.
Caliber eligibility gap_list An operator below the demanded level is ineligible for the seat, not a smaller share of it. Fails when operator_caliber minus demanded_level is below zero.

Intake and ledger fields

TermToolWhy it existsValues
concurrency_flag intake A presales or discovery input, never computed. There is no default: a row that leaves it out is incomplete, and a missing field is not read as either value. The capability's own `concurrency` is the prompt for the answer, and this field is the answer for one engagement. 
concurrent | sequenceable
engagement_duration intake Without it, the seat count for sequenceable work cannot be computed. The unit is weeks. 
a number of weeks
unit_duration intake How long one unit takes, a flat estimate per capability, independent of level. Watch during backtesting whether it needs to become level-dependent the way leverage is. 
a number of weeks
allocation ledger How much of one person an active unit takes, as a percentage. Carries a rationale on every row, because there is no formula to deviate from. 
50 | 100

Other terms the math depends on

TermToolWhy it existsRough math
Nominal capacity size How many surface-area units one matched-caliber operator holds — an operator whose caliber equals the demanded level exactly. It is the denominator everything else adjusts. 
L1: 5
L2: 3
L3: 2
# units per operator
Hard ceiling size The most surface area any single operator holds, however overqualified. 
hard_ceiling = 6
# units
Multiplier by gap size A positive gap multiplies capacity upward, and the result is capped by `hard_ceiling` regardless of how far above the bar the operator sits. 
gap 0: x1
gap 1: x1.5
gap 2: x2
Caliber gap gap_list How far an operator's caliber sits above the demanded level. A negative gap is ineligible; see `caliber_gap_rule`. 
caliber_gap = operator_caliber - demanded_level
Stake (per risk shape)presales_chain, demanded_level size How much rides on one capability for one live risk shape. A human reads it from the collapse risk and logs it as a variation with a basis. It is not the intensity dial, which moves, and it sets the floor for the demanded level. 
stake(shape, capability) = low | material | critical
floor: low = L1, material = L2, critical = L3
Collapse riskaxes, demanded_level size The question a human answers to set stake: what breaks, and how badly, if this capability is run at L1 on this engagement. 
none, a human question
ask: what breaks, and how badly, if this runs at L1?
Leveragecapabilities scope_decomposition (leverage_by_level) size How many scope units one person at a level can span for one capability. It is declared per capability and is not the nominal capacity, which counts what runs at once. 
leverage_by_level[level] = units one person spans
default shape: L1 <= L2 <= L3 <= L4, adjusted per capability
Operator caliberaxes, caliber_gap gap_list The level a person is certified at for a capability, read from the capability profiles. It is a property of the person, not of the work. 
operator_caliber(person, capability) = certified_level
an L4 owner counts as L3
Committed countcount_derivation size The floor on seats: only surface area a human has validated can raise it. The demanded count is the ceiling. 
committed_count = ceil(validated_surface_area / nominal_capacity[demanded_level])
Qualified pooldoctrine/seat-fulfilment.yaml gap_list Who can fill a seat: the capability's L4 owners plus anyone certified at or above the level. 
pool(capability, level) = { person : certified_level(person, capability) >= level } + owners(capability)