sots-re/findings/subsystems/output-turn-path.md

# `ComputeOutput` on the turn path (lane C3, 2026-09-08)

`ServerSystem::ComputeOutput` 0x00751fb0 and the whole of `ComputeOutputFromRates`
0x00751bb0 — the money `ComputeBudget` actually sums during a turn, as opposed to the
projected-mode `ComputeMaxIncome` that lane E1 closed at 25/25 on the `BnkEl` oracle.

Evidence: own `objdump -d` pass over `Sword of the Stars.exe`. Both ranges disassembled to
the **next function start** and the real boundary found (rule 17). Field names per
`findings/objects/struct-recovery.md`. Everything marked *instruction-verified* is read off
the instruction stream; everything marked *inferred* is not.

This supersedes two labels in earlier notes:

* `income-term.md` §2.2 calls `[ebp-0x28]` "leftover **science** points". There is no science
  channel in this function. `OutputRates+4` is the **ship-construction** slider `SRsc`, the
  helper at 0x00746830 turns it into **construction points**, and the "leftover" is what the
  build queue and the ship-repair pass did not spend. `strategic-turn-internals.md` §3.3 had
  this right; the income lane's paraphrase did not.
* `output-term.md` §1 gives `ComputeOutputFromRates`'s end as 0x00751fa8. The `ret 8` is at
  **0x00751fa0**; 0x00751fa3..0x00751faf is `int3` padding. E1's 0x00751fa0 is correct.

---

## 1. The call chain

| addr | name | conv / boundary | note |
|---|---|---|---|
| 0x00751fb0 | `ServerSystem::ComputeOutput(int out[12])` | thiscall `ret 4`, ends 0x00752070 | Ghidra size 192 = correct |
| 0x00751bb0 | `ServerSystem::ComputeOutputFromRates(int out[12], OutputRates*)` | thiscall `ret 8`, ends 0x00751fa0 | **repairs ships in orbit** |
| 0x00747390 | `NormaliseOutputRates(float rates[4], ServerSystem*, float* pinned)` | **cdecl** | pinned = null → trade |
| 0x00750480 | `ServerSystem::ComputeTotalOutput(double SRoh)` | thiscall `ret 8` | lane N; side-effect free |
| 0x00746830 | `ServerSystem::ConstructionPoints(double consShare)` → int | thiscall `ret 8`, ends 0x00746883 | shipyard-station bonus |
| 0x00815c10 | `ServerSystem::StationCount(ServerPlayer*, int kind)` | cdecl-through-thiscall | **kind 1** here (shipyards) |
| 0x008251e0 | `BuildQueue::TotalConstructionLeft()` → int | thiscall `ret 0`, 23 bytes | Σ `conleft` over the order list |
| 0x00751590 | `ServerSystem::RepairShipsInOrbit(int points, bool estimateOnly)` → int | thiscall `ret 8`, ends 0x007517b5 | **the side effect**; returns points LEFT |
| 0x00745d60 | `ServerSystem::IdealSuitability()` → double | thiscall `ret 0`, ends 0x00745dc0 | §2.6 |
| 0x00746890 | `ServerSystem::TerraformPointsNeeded()` → double | thiscall `ret 0`, ends 0x0074690d | §2.5 |
| 0x0074c6f0 | `ServerSystem::CivilianConsumption()` → int | **reads `esi` as `this`** | resource ledger only |
| 0x007483b0 | `ServerSystem::OverHarvestDemand(double SRoh)` | thiscall `ret 8` | lane N |
| 0x007505b0 | `ServerSystem::TradePointsToMoney(double trade)` → double | thiscall `ret 8` | lane E1 |
| 0x008e5660 | `round(double)` | cdecl | `fistp`/`fild`, ties to **even** |
| 0x00925220 | `_ftol2` | — | truncating |
| 0x009dd1e4 | `ceil` (MSVCR100) | IAT | |
| 0x0083a5b0 | `TradeManager::SystemRouteIncome(mgr, sys, ServerPlayer*, int* a, int* b)` | `ret 0x10` | fills `out[4]`,`out[5]` |
| 0x007460b0 | `SystemRepairDemandForOwner(ServerPlayer*)` → int | **reads `ebx` as `sys`** | fills `out[6]` |

Two non-standard conventions worth flagging (both would be silently wrong if taken as
`__thiscall`): 0x0074c6f0 takes its `this` in **ESI** and 0x007460b0 takes the system in
**EBX**. Both are compiler-local helpers that inherit a register the caller happens to hold.

---

## 2. The formula

### 2.1 `ComputeOutput(out)` — 0x00751fb0 (instruction-verified)

```
if (out == 0) return
memset(out, 0, 48)                        // 12 dwords; slots 10 and 11 are FLOATS
if (sys->PID /*+0x100*/ == 0) return
ComputeOutputFromRates(out, &sys->Rts)    // sys+0x88 -- the system's OWN sliders, unnormalised
if (sys->[0x230] != 0) return             // a byte; NOT on the wire
mgr = server->vtbl[2]()                   // server = sys->+0x10, the RAW StrategyServer base
TradeManager::SystemRouteIncome(mgr, sys, sys->PID, &a, &b)
out[4] = a ; out[5] = b
out[6] = SystemRepairDemandForOwner(sys->PID)     // 0x007460b0, `sys` arrives in EBX
```

**`out[3]` — the money — is written entirely inside `ComputeOutputFromRates`.** Nothing after
that call touches it, so the trade-route and repair-demand slots are reporting only.

`ComputeBudget` 0x00863030 confirms this at 0x008631fd:

```
for s in player->systems:
    if (s->Abdn /*+0xc4*/) continue
    if (projected) money = ComputeMaxIncome(s)             // 0x007521c0
    else { int o[12]; ComputeOutput(s, o); money = o[3]; } // [ebp-0xe0 + 0xc]
    if (money > 0) income  += money            // budget+0x04
    if (money < 0) expense += -money           // budget+0x1c
```

### 2.2 The `OutputRates` memory layout (instruction-verified)

`ServerSystem+0x88`, 0x1c bytes, seven dwords. The **memory** order is not the wire order:

| offset | field | who reads it |
|---|---|---|
| +0x00 | `SRt` trade | trade points, and the leftover weight |
| +0x04 | `SRsc` **ship construction** | construction points |
| +0x08 | `SRtf` terraform | zeroed by normalisation when `Suit == IdealSuitability()` |
| +0x0c | `SRi` infrastructure | zeroed by normalisation when `f32(Infra + ibon) >= 1` |
| +0x10 | `SRoh` over-harvest | `ComputeTotalOutput` / `OverHarvestDemand` |
| +0x14 | `SRs` | not read here (slave death rate) |
| +0x18 | `SRnr` (int) | not read here |

The suppressions are read off `NormaliseOutputRates` 0x00747390: `[edi+0x8] := 0` under the
`Suit == IdealSuitability()` branch and `[edi+0xc] := 0` under `1.0 <= f32(ibon + Infra)`.
The wire order (`SRs, SRt, SRsc, SRtf, SRi, SRoh, SRnr`) is a serialiser choice.

### 2.3 `ComputeOutputFromRates(out, rates)` — 0x00751bb0 (instruction-verified)

```
memset(out, 0, 48)
if (sys->PID == 0) return
r = *rates                                   // 7 dwords copied to the stack: the caller's
NormaliseOutputRates(&r, sys, 0)             // struct is never modified

T          = round( ComputeTotalOutput(r.SRoh) )      // ties to even, kept as a double
tradePts   = round( T * r.SRt   )
consPts    = round( r.SRsc * T  )
terraPts   = round( r.SRtf * T  )
infraPts   = round( r.SRi  * T  )
out[0]     = ftol(T)

// --- resource ledger (independent of everything below) -------------------------
need       = ftol(OverHarvestDemand(r.SRoh)) + CivilianConsumption()
resAvail   = sys->Res + (PID->[0x138] ? sys->MRes + sys->ARes2 : 0)
out[2]     = min(resAvail, max(need, 0))
out[1]     = min(out[2], ftol(OverHarvestDemand(r.SRoh)))

// --- construction ---------------------------------------------------------------
queueNeed  = sys->BQ ? BuildQueue::TotalConstructionLeft(sys->BQ) : 0
out[7]     = ConstructionPoints(consPts)                  // ftol(c + stations*BONUS*c)
out[8]     = min(queueNeed, out[7])
rem        = max(out[7] - out[8], 0)
out[9]     = 0
if (rem > 0):
    left   = RepairShipsInOrbit(rem, /*estimateOnly=*/false)
    out[9] = rem - left
    rem    = left

// --- the leftover redistribution -------------------------------------------------
Ltrade = Lterra = Linfra = 0.0
if (rem > 0):
    P = (double) rem
    if (r.SRsc == 1.0):                                   // an exact ==
        wT = 1.0
        wF = (sys->Suit != IdealSuitability()) ? 1.0 : 0.0
        wI = (sys->Infra != 1.0)                ? 1.0 : 0.0
    else:
        wT = r.SRt ; wF = r.SRtf ; wI = r.SRi
    S      = wI + (wF + wT)                               // that association
    Ltrade = round( wT * P / S )
    Lterra = round( wF * P / S )
    Linfra = round( wI * P / S )

// --- infrastructure --------------------------------------------------------------
infraNeed  = ceil( (1.0 - sys->Infra) / 3.3e-5 )          // 0x00a1f930
poolI      = Linfra + infraPts
spendI     = min(poolI, infraNeed)
leftI      = max(poolI - spendI, 0)
out[10]    = (float) max( spendI / 500.0 * 0.01 * 1.65, 0 )   // three 80-bit steps

// --- terraforming ----------------------------------------------------------------
terraNeed  = ceil( TerraformPointsNeeded() )
poolF      = (Lterra + terraPts) + leftI                  // the infra cascade lands HERE
spendF     = min(poolF, terraNeed)
leftF      = max(poolF - spendF, 0)
sign       = (IdealSuitability() < sys->Suit) ? -1.0 : 1.0
out[11]    = (float) ( sign * (spendF * 1.5 * 1.2f * PID->TerraMod) / 20000.0 )

// --- money -----------------------------------------------------------------------
out[3]     = ftol( TradePointsToMoney( (Ltrade + tradePts) + leftF ) )
```

Two things this makes explicit that no earlier note stated:

1. **The infrastructure leftover cascades into the terraform pool, and the terraform
   leftover cascades into money.** There is no direct industry→money edge; it is two hops.
   `income-term.md` §2.4's "both cascade sources are zero" is right for the max-income rate
   vector (where `infraPts = terraPts = 0` *and* both needs are `>= 0`) but says nothing
   about the turn path.
2. **The construction leftover's trade share is added to the money channel.** On a colony
   whose build queue is empty, every construction point the system produced comes back as
   trade points. A system with `SRt = 0, SRsc = 1` and an empty queue therefore earns
   **exactly as much money** as one with `SRt = 1`. That is the single most consequential
   fact in this function and it is why the corpus's turn-path money is so close to its
   projected money (§4).

### 2.4 `RepairShipsInOrbit(points, estimateOnly)` — 0x00751590 (instruction-verified)

```
if (points == 0) return 0
need = 0 ; cand = vector<StarShip*>()
for i in 0 .. sys->vtbl[2]()-1:                     // fleets at the system
    f = sys->vtbl[4](i)
    if (f->[0x58] != sys->PID) continue
    if (!Fleet::TestFlags(f, 0, 8)) continue
    for sh in f->ships (+0xa4 .. +0xa8):
        if (!Ship::TestFlags(sh, 0, 8)) continue
        c = Ship::RepairCost(sh, 1)                 // 0x00815180
        if (c <= 0) continue
        need += c
        if (!estimateOnly) cand.push_back(sh)
if (estimateOnly) return max(points - need, 0)
// round robin
progress = true
while (progress && points > 0):
    share = max(points / cand.size(), 1)            // integer divide
    progress = false
    for sh in cand:
        if (points <= 0) return points
        take = min(Ship::RepairCost(sh, 1), share)
        if (take > 0) { Ship::ApplyRepair(sh, take); progress = true; points -= take }
return points
```

**The round robin is equivalent to `points - min(points, need)`** and this is a proof, not an
observation: `share >= 1` always, so every ship with a positive remaining cost takes at least
one point per pass; the loop can only stop early via `progress == false`, which requires every
remaining cost to be zero. So the pass ends with `points == 0` (need was the binding
constraint) or with every cost zero (points was). The engine models it as the `min` and pins
the equivalence in a test rather than reproducing the round robin.

`ComputeOutputFromRates` passes `estimateOnly = 0`, so **this is the B1 replace double-run
hazard**: calling the original to harvest a value repairs ships. The engine never does.

### 2.5 `TerraformPointsNeeded()` — 0x00746890 (instruction-verified)

```
if (PID == 0) return 0.0
sign = (IdealSuitability() < sys->Suit) ? -1.0 : 1.0     // 0x009e3348 = -1.0
rate = f32(PID->TerraMod /*+0x134*/) * 1.8000000715255737   // 0x00a1f928 = (double)1.8f
d    = fabs( f32(IdealSuitability() - sys->Suit) )
return d / fabs( rate * sign / 20000.0 )
```

The `fabs` is after the sign multiply, so the sign cancels and the result is always `>= 0`
(E1's §2.4 reading confirmed). Note `1.8f` here is the same number as `1.5 * 1.2f` in
`out[11]` — `1.5 * 1.2000000476837158 == 1.8000000715255737` exactly — so the point count and
the point value use one rate, folded differently.

`TerraMod == 0` makes this `+inf`, `ceil(+inf) = +inf`, and the terraform channel then absorbs
its whole pool with nothing cascading to money. No corpus player has `TerraMod == 0` (Human
and Tarkas carry 1.0, species 4 carries 3.7), so that branch is **unexercised**.

### 2.6 `IdealSuitability()` — 0x00745d60 (instruction-verified)

```
if (sys->PID == 0) return (double) sys->Suit          // an unowned system is "at its ideal"
v = PID->IdealSuit /*+0xb0*/
if (sys->indi /*+0x1c8*/) v = StrategyServer::IdealSuit(sys->server, sys->indi->indsp)
if (sys->dsu /*+0x118*/ != SENTINEL) v = sys->dsu     // SENTINEL is the float at 0x00aeca6c
return v
```

This is **not** the same source `CalcSuitMod` uses in the money cost (E1 §2.6 reads the
server's per-species array there). Here the owner's own `IdealSuit` field is the default and
the server array is only consulted for an independent colony. In the 11-save corpus the two
agree, so the difference is instruction-verified only.

`dsu` is `3.4028235e38` (`FLT_MAX`) on **every system of every corpus save**, so the override
never fires and the sentinel's identity is *inferred* from that (the value at 0x00aeca6c is a
data-file-loaded `GlobalConst` slot, not a `.rdata` literal, so it was not read directly).

### 2.7 `ConstructionPoints(cons)` — 0x00746830 (instruction-verified)

```
if (PID == 0) return ftol(cons)
k = StationCount(sys, PID, 1)                          // 1 = shipyard
b = (STATION_BONUS_SHIPCON > 0) ? STATION_BONUS_SHIPCON : 0
return ftol( k * (b * cons) + cons )
```

Note the association `((b * cons) * k) + cons`, and that the bonus is ignored unless strictly
positive — the same "unloaded tuning table reads as 1.0, not 0.0" guard the output term has.

---

## 3. What this needs that the max-income path did not

| input | source | held? |
|---|---|---|
| `Rts` (5 floats) | wire, `Sys/Rts` | yes |
| `IdealSuitability()` | `Player/IdealSuit`, `Sys/dsu`, `Sim/ISsu[]` | yes |
| `Infra`, `ibon` | wire | yes |
| shipyard station count | `Sys/NumSnF` | yes (0 on every corpus system) |
| build-queue demand Σ`conleft` | wire, `Sys/BQ/ords` | yes |
| **ship repair demand in orbit** | needs `Ship::RepairCost` 0x00815180 over the fleets at the system | **NO** |
| `TerraMod` | wire, `Player/TerraMod` | yes |
| the output total | lane N | yes |

**One input of nine is missing**, and it is the repair demand. It is zero whenever no ship in
orbit is damaged. On the two reference pairs the human's and the AI's colonies carry no fleet
at all in the input state except Ke'Dolarra (turn 2) and Koa'Vo, so the exposure is small but
not provably nil; the engine takes it as an explicit input defaulting to 0 and reports it.

---

## 4. PREDICTION — written before the build

The corpus turns out to make this function much simpler than it looks, and the predictions
below are the consequences.

Measured facts about the corpus, from the wire (`Sys/Rts`, `Sys/dsu`, `Sys/BQ`, `Sys/NumSnF`,
`Player/IdealSuit`, `Player/TerraMod`), before any model was written:

* every owned colony in all 11 saves has `Suit == IdealSuit` **exactly** and `Infra == 1.0`
  exactly, so `NormaliseOutputRates` zeroes both `SRtf` and `SRi` on every one of them;
* consequently `infraNeed = ceil(0/3.3e-5) = 0`, `terraNeed = ceil(0/rate) = 0`, and
  `infraPts = terraPts = 0`;
* no system carries a station, so the shipyard bonus is 1;
* `dsu` is `FLT_MAX` everywhere, so the ideal-suitability override never fires;
* the sliders that occur are `{t .5, sc .5}`, `{t 0, sc 1}`, `{t .04, sc .96}` and
  `{.25,.25,.25,.25}`; after suppression they normalise to `{t, 1-t, 0, 0}`.

### 4.1 What I expect

1. **The leftover redistribution collapses to "all of it to trade" on every corpus colony.**
   In the `SRsc == 1` branch the weights are `(1, 0, 0)` because suit is at the ideal and
   infra is exactly 1; in the other branch they are `(SRt, 0, 0)`. Either way
   `Ltrade = round(P) = P` and `Lterra = Linfra = 0`.
2. **Therefore `out[3] = ftol(TradePointsToMoney(round(T*SRt) + ftol(round(T*SRsc))))`**, and
   with an empty build queue and no repairs the argument is `2*round(T/2)` for a 50/50 colony
   and `T` for a pure-construction one — i.e. **within ±1 of `ComputeMaxIncome`'s `T`**.
3. **The turn path's money therefore equals the projected path's money to ±1 trade point on
   this corpus.** If that is right, the `BnkEl` oracle — which constrains only the projected
   path — becomes an *indirect* check on the turn path here, and only here.
4. Numerically, using the `BnkEl` the oracle saves already carry (inverted through
   `ftol(maxIncome / -0.15000000596046448)`):

   | player | pair | oracle's `Sav` move | decomposition |
   |---|---|---|---|
   | 576 Independent Colony | 1→2 | `0 → 98871` | `99871 − 1000 maint + 0 interest` |
   | 576 | 2→3 | `98871 → 198730` | `99871 + 988 interest − 1000 maint` |
   | 16 human | 1→2 | `50000 → 289688` | `239188 + 500 interest`, and `239189` is the max income of the **post-growth** turn-2 colony |
   | 16 human | 2→3 | `289688 → 532369` | `239785 + 2896 interest`, again post-growth |

   So `ComputeBudget` runs on the colony state **after** `S11 SystemTurn` — the strategic
   driver runs the system turn at index 11 and the player driver at index 13 — and the
   human's system income is the post-growth number.

5. **What will therefore close, and what will not:**
   * Player 576's income does **not** move with growth (Koa'Vo has no civilian population and
     its `BnkEl` is identical in all three saves), so its `Sav` should come out **exactly**
     right on both pairs. **+1 leaf per pair.**
   * Player 16's income **does** move with growth, and our `S11` does not commit civilian
     growth (it needs the carrying capacity). Our number will be short by **597** on pair 1
     and **596** on pair 2, so `Sav` stays wrong — but it was already wrong, so **0 regressed**.
   * Player 32 (the AI) picks a research target and changes `ResRate` during the turn; that is
     Rung B. Not closed.
   * The 24 `turnstats` leaves need the budget **and** ship construction (lane E2's finding).
     Not closed by this lane alone.
   * `PvSav` is `S00`'s snapshot, not `P02`'s write, and player 32's `PvSav` is not its
     pre-turn `Sav`, so it is left alone.

   **Predicted total: pair 1 closed 1 regressed 0; pair 2 closed 1 regressed 0.**
6. The two research RNG words stay out of the generator model, and for a **new** reason: the
   allocation is now computable, but no player in either input state carries a research
   target (`ResTNm` is empty on 16 and 32 in `turn1-state`), so `ProcessResearch` has nothing
   to fund. The blocker moves from "the money is unmodelled" to "the AI's target selection
   is unmodelled".

### 4.2 Falsification — how this could be wrong, and the symptom of each

| way it could be wrong | symptom |
|---|---|
| `OutputRates+4` is not construction but something else, so `SRsc == 1` is not what the leftover branch tests | player 576 (whose rates are `.25/.25/.25/.25`, the only four-way vector) would miss while the `{0,1}` colonies matched, or vice versa |
| the leftover weights are the **raw** sliders, not the normalised ones | 576 misses by a clean ratio (`.25` vs `.75` denominators); the `{t,1-t}` colonies are unaffected because the ratio is the same |
| `Ltrade` is *not* added to the money channel (i.e. I misread the slot reuse of `[ebp-0x28]`) | every colony's money collapses to `round(T*SRt)`, so the `{t 0, sc 1}` colonies earn **zero** and player 32's and the turn-2/3 colonies' income falls by 100 % — a very loud failure |
| the budget runs **before** `S11`, and the human's +597 has another source | player 576, whose income does not move with growth, would still match, so this is NOT separable on 576 — it is separable only on 16, where a pre-growth budget predicts `289092` and a post-growth one `289688` |
| the repair pass consumes points on a corpus colony | player 576 (Koa'Vo has one fleet in every save) misses low by the repair spend; 16's homeworld has no fleet in `turn1-state`, so a 576-only miss names this |
| the round robin is not equivalent to the `min` | only visible where `points < need`; unexercised here |
| `ConstructionPoints` truncates where I read a round | off-by-one on colonies whose `T*SRsc` is not integral — but `T` is already an integer and the sliders are exact binary fractions on most colonies, so this is nearly invisible; `{.04, .96}` (Downbelow) is the one colony that would show it, and it is not on either reference pair |
| `sys->[0x230]` gates something that feeds money | it cannot: `out[3]` is written before that test and never again |

A run that closes player 576 and nothing else is a **weak** result and will be reported as
one: it is one leaf per pair, and it is the leaf where the missing upstream input happens not
to matter.

---

## 5. The result

Engine: `sim::ComputeSystemOutput` (`src/game/sim/colony.{h,cpp}`) plus
`sim::IdealSuitability` and `sim::RepairShipsInOrbit`, wired into `P01`/`P02` through
`BuildBudgetFeeds` in `src/app/turn.cpp`. Host `ctest` 46/46, clean-room OK, both run as
separate commands.

```
reference pair  turn1-state -> turn2-state    209 -> 157   closed 52  regressed 0   (was 51 / 0)
second pair     turn2-state -> turn3-state    108 ->  86   closed 22  regressed 0   (was 21 / 0)
```

**Closed 1 per pair, regressed 0 per pair.** The leaf is
`/Sim/players/Player[576 "Independent Colony"]/Sav` on both.

### 5.1 Every prediction in §4.1, checked

| predicted | outcome | verdict |
|---|---|---|
| the leftover redistribution collapses to "all to trade" on every corpus colony | it does; `leftoverToTrade == leftover` on all of them | HELD |
| the turn path equals the projected path to within the trade-point rounding when the queue is empty | **exactly equal on 5 of the 11 saves** — every save whose build queues are all empty | HELD |
| player 576's `Sav` comes out exactly right on both pairs | `0 -> 98871` and `98871 -> 198730`, both exact | HELD |
| player 16's `Sav` is short by the uncommitted civilian growth | `289092` against the oracle's `289688` | HELD (the amount was predicted as 597 and is **596** — see §5.2) |
| player 32 is not closed | `297492` against `92651` | HELD |
| the `turnstats` leaves are not closed | not closed | HELD |
| pair 1 closed 1 regressed 0; pair 2 closed 1 regressed 0 | exactly that | HELD |
| the two research RNG words stay out of the generator model | they do, for the predicted reason | HELD (§5.5) |

Nothing in §4.2's falsification table fired. In particular the loudest one — "the construction
leftover does not reach money" — would have collapsed every `{SRt 0, SRsc 1}` colony's income
to zero, and those colonies price correctly.

### 5.2 The prediction that was off, and why

§4.1 said player 16 would be short by **597** on pair 1. It is short by **596**. The
arithmetic: our pre-growth output gives a max income of 238,592 and the post-growth one gives
239,189, a gap of 597 — but the oracle's own turn-path number is 239,188, one *below* its
projected 239,189, because `2 x round(T/2)` lost a point on the post-growth total and did not
on the pre-growth one. So the two errors partly cancel, and the residual is the growth gap
minus one trade point. The mechanism was predicted; the sign of its interaction was not.

### 5.3 The strongest check available without a VM

The engine now runs every owned system through **both** paths on the same colony state and
reports the difference, every run. The projected sum is the number the save's own `BnkEl`
states and that lane E1 scored 25/25 against, so a large delta is the new model failing and it
is visible on load.

| save | landed players agreeing exactly | worst \|delta\| | explanation |
|---|---|---|---|
| `turn1-state`, `turn2-state`, `turn3-state` | 3 of 3 | 0 | every build queue empty |
| `human-turn2-orders` | 2 of 2 | 0 | every build queue empty |
| `zuul-turn15-orders` | 2 of 2 | 0 | every build queue empty |
| `human-turn3-noderoute` | 1 of 2 | **37** | queues empty; one trade point crossed a five-point block: `5 money x 5 x IncMod 1.48 = 37` |
| `zuul-turn23-fleet23` | 1 of 2 | **2035** | Gallandro's queue holds 370 points: `370 x 5 x 1.1 = 2035` |
| `zuul-turn17-orders2`, `-rollpending` | 0 of 2 | **21010** | W'kanda's queue holds 3818: `3820 x 5 x 1.1 = 21010` (the block count moves by 3820, not 3818, because of the two `mod 5` offsets) |
| `zuul-turn16-noderoute` | 0 of 2 | **36438** | W'kanda's queue holds 6626: `6625 x 5 x 1.1 = 36437.5`, and two independent truncations put it at 36438 |
| `zuul-turn5-species5` | 1 of 2 | **39160** | W'kanda's queue holds 7120: `7120 x 5 x 1.1 = 39160` |

**Every delta decomposes, to the unit, into the build queue's construction points priced
through the money chain** — three of the four exactly, and the fourth within the one unit that
two independent truncations of a `.5` allow. That is the closest thing to an oracle this path
has, and it is a much stronger statement than "the two agree": it says the two paths differ
by *exactly the thing the disassembly says they differ by*.

### 5.4 What this run did NOT cover — read this before quoting the numbers

* **One leaf per pair is a weak result** and it is the one leaf where the missing upstream
  input does not bite. Player 576 owns one colony with no civilian population and an empty
  queue; it is the easy case.
* **The ship-repair demand is taken as 0 everywhere.** `Ship::RepairCost` (0x00815180) is
  unread, so no save can supply it. Every colony with a damaged fleet in orbit therefore reads
  **high**, and the corpus cannot tell us whether any does.
* **No corpus colony is off its ideal suitability, and none is below full infrastructure.** So
  the terraform channel, the infrastructure channel, `infraNeed`, `terraNeed`, the
  infra→terraform cascade, the terraform→money cascade and the non-trivial half of the
  `SRsc == 1` leftover branch are **all unexercised by the corpus**. They are covered by host
  tests written from the instruction stream, which is a much weaker claim.
* **No corpus system has a station**, so the shipyard bonus in `ConstructionPoints` — including
  the "strictly positive" guard and the association this lane corrected — is unexercised.
* **`SRoh` is 0 on every save**, so the over-harvest term is unexercised here too (lane N's
  finding, unchanged).
* **`dsu` is FLT_MAX everywhere**, so the ideal-suitability override is unexercised and the
  sentinel's identity is inferred from that fact rather than read.
* **The build queue is exercised only on Zuul saves that are not on either reference pair.**
  The two pairs the metric is measured on have empty queues throughout, so the queue edge is
  checked by the §5.3 self-check and not by the leaf count.
* The `[0x230]` gate, `out[4]`, `out[5]` and `out[6]` are read but **not modelled**; nothing
  downstream of `out[3]` needs them.
* **Neither `NormaliseOutputRates`' tail (past 0x007474d4) nor `CivilianConsumption`'s ratio
  was read this lane.** The first is B4's; the second feeds only the resource ledger.

### 5.5 The two budget-downstream RNG words

They still cannot enter the generator model, and the reason has changed again.

`income-term.md` §6.3 named them: `ProcessResearch`'s `RNG::Chance(odds)` on the funded node,
and the draw inside `OnTechResearched`'s effect callback. Both are downstream of the research
**allocation**, which is `ComputeBudget`'s research money — and that money is now computable,
because its only missing input was the per-system money this lane closed.

What blocks them now is one step further out: **the only corpus player that reaches
`ProcessResearch` with a research target is the AI**, and its research rate (`ResRate`
0.25 → 0.8) and its target (`ResTNm` '' → 'IND_Waldo') are *its own orders, generated during
the same turn*. Feeding our budget into `ProcessResearch` would allocate against the wrong
rate. On `turn1-state` no player has a target at all, so the phase has nothing to fund and
both words cost zero on the reference pair.

That last sentence is a claim about the **workload**, not about the phase, and rule 20 applies
to it: a word count cannot separate "`ProcessResearch` was not entered" from "it was entered
and drew nothing". An entry probe on `ProcessResearch` would settle it in minutes and is the
cheap next step. Until then the two words are best described as *unblocked in formula, blocked
in workload*, and the honest ledger entry is that the generator model is unchanged at 16 words
modelled.

### 5.6 What is now blocked on what

| phase | was blocked on | is blocked on |
|---|---|---|
| P01 `ComputeBudget` | the per-system money output | nothing here; `S11`'s uncommitted civilian growth upstream, and the unread ship-repair demand |
| P02 `ApplyNetToSavings` | P01 | committed; exact where the upstream is |
| P03 `RecordBudgetDerivedFields` | the budget | two player words that are still not identified on the wire — **unchanged, this lane does not help it** |
| P05 `ProcessResearch` | the allocation | the AI's own research rate and target (Rung B) |
| P06 `ResearchRefund` | P01 and P05 | P05 |
| T36 turn record | the budget **and** ship construction | ship construction (lane B6) plus the same growth gap; the money half is now available |

The single highest-value next item this lane can name is **committing `S11`'s civilian
growth**: it is what stands between player 16's `Sav` and the oracle on both pairs, it is also
what stands between `BnkEl`/`BnkPr` and the oracle (four more leaves), and it is the same
`Pop2/PopG/PopC` and `PvPop2/PopG/PopC` leaves that are already on the remaining list. One
input — the imperial carrying capacity — gates all of it.