Aura/fieldtests/milestone-cost-model-graph/FINDINGS.md

Fieldtest — milestone #148 "Cost-model graph (in R)" — 2026-06-29

Status: Draft — awaiting orchestrator triage Author: fieldtester (dispatched by fieldtest skill, milestone-close gate)

Scope

Milestone #148 promises a composable cost-model graph in R: a strategy's gross-R signal is turned into a net-R curve by composing cost nodes, each a labelled stress parameter, on the stage1-r harness. The capability must span both charge modes — per-trade costs (deduct at close) and per-held-cycle costs (accrue over the hold) — so a research user can measure how much friction costs their edge and see whether a holding cost changes the shape of the equity curve. Shipped across cycles 0081–0085: ConstantCost, the net_r_equity tap + summarize_r cost fold, VolSlippageCost + CostSum, the CostNode trait, the cost_graph composite-builder, and per-held-cycle accrual (CarryCost + ChargeMode). Public surface exercised: the aura CLI (run --harness stage1-r with --cost-per-trade / --slip-vol-mult / --carry-per-cycle, --trace, chart --tap), against the design ledger C10 and the glossary. Binary exercised: target/debug/aura freshly built from HEAD (cargo build --workspace, commit 84ec2ab).

The milestone promise is delivered: all four end-to-end scenarios behave as the contract states, including the capstone holding-cost shape change and exact cost composition. No capability bug. The findings are doc/diagnostic friction at the public surface and one undefined-behaviour spec_gap; none blocks the close.

Examples

All under fieldtests/milestone-cost-model-graph/. run_scenarios.sh reproduces every command; captured_outputs.txt is its recorded output; traces/ holds the r_equity / net_r_equity series the runs persisted (the runs/ store is gitignored); chart_carry_net_r_equity.html is the charted capstone bleed.

run_scenarios.sh §1 — bare gross-R, no cost model

• aura run --harness stage1-r with no cost flag.
• Fits scope: the zero-cost floor — C10's "a bare gross-R run with no cost model attached is valid", the additive-on baseline every cost composes onto.
• Outcome: ran; expectancy_r = net_expectancy_r = 1.2710005136982836 exactly (net == gross when no cost is attached). Clean.

run_scenarios.sh §2 — flat per-trade cost (ConstantCost, deduct at close)

• aura run --harness stage1-r --cost-per-trade {0.0001,0.001,0.01}, plus a --trace pertrade_cost run.
• Fits scope: the per-trade charge mode (cycle 0081), "how much does friction cost my edge?".
• Outcome: ran; gross expectancy_r stays pinned at 1.2710005136982836 while net_expectancy_r drops strictly and monotonically with cost (1.2402 → 0.9632 → -1.8069); the net_r_equity tap persists under --trace. Matched expected.

run_scenarios.sh §3 — per-held-cycle carry (CarryCost, accrue over hold) — capstone

• aura run --harness stage1-r --carry-per-cycle 0.001 --trace carry_cost.
• Fits scope: the milestone capstone (cycle 0085) — the per-held-cycle charge mode; "does a holding cost change the SHAPE of the curve?".
• Outcome: ran; net_expectancy_r = -0.2679604926492904. The net_r_equity gap (gross − net) grows continuously over a single hold — ts4..ts7: 0.367 → 0.734 → 1.101 → 1.468 — versus the per-trade run's flat 0.367 over the same hold. The holding cost bleeds the curve continuously rather than stepping at close. Matched expected exactly.

run_scenarios.sh §4 — compose all three costs + chart

• aura run --harness stage1-r --cost-per-trade 0.001 --slip-vol-mult 0.5 --carry-per-cycle 0.001 --trace composed_cost, each single cost alone for contrast, then aura chart composed/carry --tap net_r_equity.
• Fits scope: the cost graph composes (cycles 0082/0084) — N cost nodes sum into one net-R curve via CostSum/cost_graph.
• Outcome: ran; composed net_expectancy_r = -1.2927895081922123, strictly below every single cost alone (0.5540 slip, 0.9632 per-trade, -0.2680 carry). The composed net-R drag (gross − composed = 2.5637900218904959) equals the exact sum of the three single-cost drags (0.30779220 + 0.71703681 + 1.53896101 = 2.56379002, agreeing to the last ULP). The chart HTML bakes the real net_r_equity points array in (uPlot), so the bleed renders — not a shell. Matched expected.

Findings

[working] Gross-only run is clean: net == gross with no cost

• run_scenarios.sh §1.
• net_expectancy_r is byte-equal to expectancy_r (1.2710005136982836) and no net_r_equity is forced; the cost layer is genuinely optional and additive (C10 "the zero-cost baseline is the default-simple floor").
• Why working: the optional-cost contract holds exactly; the win to protect is that attaching no cost changes nothing.
• Recommended action: carry-on.

[working] Per-trade cost: gross pinned, net drops monotonically, tap persists

• run_scenarios.sh §2.
• Across three magnitudes gross expectancy_r never moves; net_expectancy_r is strictly below it and monotone decreasing; runs/traces/pertrade_cost/ contains a net_r_equity.json sibling of r_equity.json.
• Why working: the per-trade charge mode + the gross/net split + the named tap all behave as C10 / the glossary describe, first try.
• Recommended action: carry-on.

[working] Capstone — holding cost bleeds the curve continuously over the hold

• run_scenarios.sh §3 (+ traces/carry_cost_net_r_equity.json).
• The gross−net gap during the cycles-4..7 hold grows linearly (0.367, 0.734, 1.101, 1.468), where the per-trade run's gap over the same hold is flat (0.367, 0.367, 0.367, 0.367). The per-held-cycle accrual makes the net-R equity curve bleed continuously across a hold instead of stepping at close — the milestone's headline "shape change", directly observable in the persisted series.
• Why working: this is the milestone capstone (cycle 0085, approach B) and it is empirically true end-to-end from the CLI, not merely asserted in a unit test.
• Recommended action: carry-on.

[working] Composition is exact-additive and the chart renders the bleed

• run_scenarios.sh §4 (+ chart_carry_net_r_equity.html, traces/composed_cost_*.json).
• Three heterogeneous cost factors (per-trade + state-dependent slippage + per-held-cycle carry) sum into one net-R curve; the composed drag equals the exact sum of the single-cost drags (to the last ULP) and composed net is strictly below every single. aura chart emits a self-contained HTML page with the actual net_r_equity points array embedded.
• Why working: CostSum / cost_graph "one home for cost, no double-count" (C10) is exact, the flags compose as the usage string implies, and the headline artifact charts as a real result render (matching the "render results, not a shell" rule).
• Recommended action: carry-on.

[friction] Negative cost-rate guard prints the bare usage string, names no cause

• aura run --harness stage1-r --carry-per-cycle -0.001 (and --cost-per-trade -0.5).
• Verbatim: aura: usage: aura run [--harness <sma|macd|stage1-r>] ... then exit=2. The guard correctly refuses a negative rate (capability-safe, per the commit-noted "negative-rate guard"), but the diagnostic is the entire 1-line usage dump — it never says why (e.g. "cost rate must be ≥ 0"), and the usage string itself never states the non-negativity constraint, so a user who fat-fingers a sign cannot tell a rejected value from a mistyped flag name.
• Why friction: the task is refused correctly but the surface gives an uninformative diagnostic that names no cause.
• Recommended action: plan (a tidy iteration: emit cost rate must be non-negative, got <v> instead of the generic usage dump).

[friction] Cost flags silently no-op on a non-R harness (sma / macd)

• aura run --harness sma --cost-per-trade 0.001 → exit=0, output byte-identical to the no-cost sma run ("total_pips":-0.13000000000001358, no r block, no net_*, no warning).
• Why friction: a cost flag attached to a harness that has no R-evaluator / executor chain is silently swallowed; a user who believes they measured a cost-adjusted result got an unmodified one with no signal that the flag did nothing. (Distinct from the spec_gap below: this entry is the missing-feedback foot-gun, regardless of which behaviour is chosen.)
• Recommended action: plan (warn-on-ignored-cost-flag, or reject the combination).

[spec_gap] Cost-flag-on-non-R-harness behaviour is undefined by the ledger

• Same repro as the friction above (--cost-per-trade on --harness sma).
• C10 / the glossary define cost only against the R chain (gross R → net R) and say a bare gross-R run with no cost is valid; neither constrains what a cost flag should do on a harness (sma / macd) that produces no R at all. The project picked the "silently accept and ignore" reading; "reject: cost requires an R-evaluator harness" was equally plausible. I did not have to guess to complete the milestone scenarios (they all use stage1-r), but a downstream user mixing flags hits an unspecified corner.
• Why spec_gap: the ledger is silent on the case and the project chose one of two equally-plausible readings.
• Recommended action: ratify (pick error-vs-noop and add a one-line C10 note; pairs with the friction fix above).

[friction] Cost-flag units / scale are undiscoverable at the CLI

• All scenarios. The usage string offers only [--cost-per-trade <f64>] [--slip-vol-mult <f64>] [--carry-per-cycle <f64>] — no unit, no per-close-vs-per-held-cycle note, no scale guidance. I had to trial 0.0001 / 0.001 / 0.01 to find a magnitude that moved net-R sensibly, because the R-normalizer (the stop distance |entry − stop|, the denominator of cost-in-R = cost_per_trade / |entry − stop|) is not surfaced anywhere a CLI user can see, and --carry-per-cycle's unit (price units, per engine cycle — not per day / not an overnight swap) is invisible. The semantics are in C10 and the glossary "cost model" entry, so the capability is discoverable in the ledger — just not at the point of use.
• Why friction: the surface forced a trial-and-error dance to choose a sensible stress-parameter value that a one-line units hint would have removed.
• Recommended action: plan / docwriter (a per-flag units note in the usage string: "price units, charged in R as cost/|entry−stop|; --carry-per-cycle is per engine cycle").

[friction] The public "how aura is used" doc describes the retired pre-reframe path

• docs/project-layout.md (the only public usage doc) — its "day in the life" still says aura backtest … --broker pepperstone yields a "realistic currency curve" alongside an "exposure stream" from a "realistic broker". All three — aura backtest, the --broker realistic broker, the exposure framing — are retired by the 2026-06-28 C10 reframe; the actual surface is aura run --harness stage1-r --cost-per-trade … producing net-R, which the doc never mentions. A downstream user reading it to learn how to charge cost is pointed at a path that no longer exists and never told about the cost flags.
• Why friction: a public-surface document that actively misleads about the shipped capability (doc rot, not a ledger gap — C10 itself is current).
• Recommended action: plan / docwriter (refresh project-layout.md to the post-reframe aura run + cost-flag surface).

Recommendation summary

Finding	Class	Action
Gross-only run clean (net == gross)	working	carry-on
Per-trade: gross pinned, net monotone, tap persists	working	carry-on
Capstone: holding cost bleeds over the hold	working	carry-on
Composition exact-additive + chart renders	working	carry-on
Negative-rate guard prints bare usage, no cause	friction	plan
Cost flags silently no-op on sma/macd	friction	plan
Cost-flag-on-non-R-harness undefined by ledger	spec_gap	ratify
Cost-flag units/scale undiscoverable at CLI	friction	plan / docwriter
project-layout.md describes the retired path	friction	plan / docwriter

Milestone-close roll-up: friction_found. The capability is delivered end-to-end (both charge modes, composition, the holding-cost shape change); no capability bug blocks the close. All findings are doc / diagnostic friction or an undefined-corner spec_gap — non-gating for the milestone close.