Every stage consumes only completed upstream output.

The rule

Completed output only — no partial reads, no provisional inputs.

Each stage of the loop consumes the finished output of the stage above it and nothing else. Journal entry requires reconciled capture sheets. The Weekly Summary requires a complete journal for the period. The EV Scorecard requires the summary's hit rates. Gate and brake review requires a graded week. The cycle and throttle stage requires the gate state. Structural diagnostics require settled EV. At no point does a stage begin on a partial upstream result and revise itself later, which sounds obvious and is exactly what informal workflows do constantly.

The failure shape

A skipped stage doesn't degrade the loop. It stops it.

This is the consequence operators consistently underestimate. Skipping Saturday's journal entry does not produce a week with slightly worse data — it produces a week with no graded evidence at all, which means the EV Scorecard has nothing new to compute, the gate review is reading a stale state, and the structural diagnostics are interpreting a period that ended two weeks ago. The system continues to display numbers throughout. They are simply last week's numbers, presented with exactly the same authority as current ones, because nothing in the display distinguishes fresh output from unchanged output.

Why this framing helps

Procrastination becomes structural rather than moral.

The reframing is the practical point. An operator who has skipped Saturday is not facing a discipline problem requiring more willpower — they are facing a broken dependency chain with a specific repair, which is to complete the missing stage before anything downstream is trusted. That is a considerably more tractable situation than a character judgment, and it produces a clear instruction: do not read this week's gate state, because it is not this week's. The system's demand is not that the operator be conscientious. It is that they know which outputs are currently meaningless.

The nine stages

The modern loop, in the order dependency requires.

The loop runs pre-trade verification, execution, post-trade capture, CP3 journal entry, weekly summary, EV scorecard, gate and brake review, cycle command and throttle control, volatility intelligence, structural diagnostics, regime classification, and sandboxed R&D testing. Note that the sequence spans four cadences — the first three are per-trade, the middle group is weekly, regime classification is monthly, and R&D runs on its own review schedule. The dependency chain crosses cadence boundaries, which is why a missed weekly stage can leave a monthly diagnostic interpreting a period that was never properly closed.

The self-check

One question establishes whether the loop is intact.

Before acting on any output, the check is short: what is the most recent stage that actually completed, and is the number in front of me downstream of it? If it is, the number is current. If it isn't, the number is a survivor from an earlier revolution and carries no information about the present state. This single question resolves most of the confusion operators experience about why the system's dashboard disagrees with their sense of the account — usually the dashboard is right about a week that has already ended.

• Displays do not distinguish fresh output from unchanged output. That distinction is the operator's to maintain.
• Reconciliation is the most commonly skipped stage and the one with the largest downstream cost.
• A stale gate state is the most dangerous stale value, because the throttle will deploy against it.

Why not automate the block

The system could refuse to compute, and deliberately doesn't.

It would be technically possible to have downstream tabs blank themselves when upstream inputs are incomplete, and MARS mostly does not do this. The reason is the three-outcome honesty doctrine applied at a different level: a blanked dashboard tells the operator nothing about why it blanked, and a workbook that refuses to compute under ambiguous conditions becomes something the operator works around rather than with. What the system does instead is make the dependency chain explicit and documented, so that the operator carries the check as knowledge rather than encountering it as an obstruction.