Raw and adjusted prices
For continuous futures and split/dividend-adjusted equities the engine delivers an adjusted price series — and bar.Close, series.Close(i), indicators.Closes(series), and fill.Price all are that adjusted view, so indicators compute in one continuous price regime across a roll or split and your strategy needs no special-casing. For unadjusted data the adjusted view simply equals the raw value, so nothing changes. For an equity the adjusted view is the one marketfeed serves under eq:V:T:adj=split or adj=splitdiv (GLE-328): the strategy receives the served bar, the simulator fills on its raw prices, and fill.RawPrice() is the price the venue filled at.
If you also need the venue-real, on-the-day price — for real-dollar accounting, risk reporting, or placing an order anchored to an actual price rather than the adjusted level — a small set of opt-in accessors exposes it:
bar.AdjustedPrice(algolang.FieldClose) // == bar.Close (the default view)
bar.RawPrice(algolang.FieldClose) // the broker-real close (== adjusted when unadjusted)
bar.IsAdjusted() // does this bar carry a distinct raw view?
fill.AdjustedPrice() // == fill.Price
fill.RawPrice() // the broker-real fill price
ctx.CurrentAdjustment("ES") // additive offset in effect (Panama/futures; 0 = none)
ctx.CurrentAdjustmentRatio("AAPL") // multiplicative factor in effect (equity/split; 1.0 = none)
ctx.Position("AAPL").AvgPrice // adjusted-frame avg cost (the default view)
ctx.Position("AAPL").AvgPriceRaw // venue-real (on-the-day) avg cost; AvgPriceAdjusted is the adjusted one
A strategy that never references these is fully isolated from the raw-versus-adjusted distinction.
The strategy’s view of continuous futures
The engine hides dated-contract changes behind one logical root. A strategy receives adjusted bars under that root, submits orders for that root, and keeps one logical position while the engine translates venue-real contracts and roll orders underneath it. Most strategies need no roll-specific code. The adjusted bar is the feed’s: marketfeed builds the adjusted series and the per-contract constants, and the engine passes them on as served, using the constants only to translate orders (GLE-323). Nothing changes for the strategy.
On a daily continuous run (--bar-interval 1d or 1w) the bars are the feed’s trade-date session bars (GLE-324), so Bar.Session is set as it is on a dated contract’s session run: the trade date, the session kind actually served (eth unless the run named rth or session), the settlement with HasSettle and CloseIsSettlement, and EarlyClose. The settle is in the served, adjusted frame, beside the adjusted close. The settle is the exchange’s official settlement, which marketfeed writes onto its session bars from the settlement statistics (GLE-415). It arrives on a bar only when it had been published by the bar’s close: a strategy decides on a session bar at its close, and a settlement published after it (the 2010 sessions closed at 15:15 CT, before any; a deferred contract’s bar closes at its last trade, which can come before the settlement) is not on that bar. A strategy that wants every settlement at its own publication instant declares STATISTICS (Statistics and definitions as events). Intraday continuous bars are UTC epoch buckets and carry no session block, and neither does any bar under --continuous-clock epoch.
Each continuous bar carries the dated contract it was served from in Bar.ActiveContract (for example ESM26), and ctx.ActiveContract(symbol) returns the one a continuous series currently holds (GLE-420). A strategy may address an order to that contract instead of the logical root, priced in raw terms (Bar.RawClose); ctx.Flat(root) and ctx.Exposure(root) count a resting order on the root’s held contract against the root, so a contract-addressed order is not mistaken for a flat book. Each continuous series keeps its own held contract, keyed by its logical symbol:
func (s *Strategy) OnBar(ctx *algolang.Context, bar algolang.Bar) ([]algolang.Order, error) {
contract, ok := ctx.ActiveContract(bar.Symbol)
if !ok || !ctx.Flat(bar.Symbol) {
return nil, nil // not continuous yet, or already exposed (either form)
}
o := algolang.LimitBuy(contract, 1, bar.RawClose-0.25) // a raw-priced bid on the held contract
o.ClientID = "bid_" + contract
return []algolang.Order{o}, nil
}A strategy that wants an informational callback implements RollObserver:
func (s *Strategy) OnRoll(symbol, from, to string, at time.Time,
rawGap, priceRatio float64) {
// Observe or log the engine's decision; the callback cannot change it.
}The marketfeed chapter explains how dated bars become this logical series, including bare roots and named :cont composites, the served roll schedule and price adjustment.
Re-adjusting at each roll
marketfeed serves a continuous series adjusted from its end: the served history is on the basis of the newest contract the run reads. So a served bar’s price depends on where the data ends, and a backtest that ends later sees different prices. The roll rebase (GLE-1458) takes that away. The strategy calculates on prices adjusted only by the rolls that have happened, and the bar it decides on is at the held contract’s own prices. At each roll the engine re-adjusts the series’ history onto the incoming contract’s basis and sends it to the strategy, straight after the roll’s OnRoll. The run’s report stays on the served basis.
The roll rebase is on by default since GLE-1502, in backtests and live runs alike. --roll-rebase=false turns it off (Turning the roll rebase off). It applies to a series whose adjustment is panama or ratio; an unadjusted series (:adj=none) has one basis and is never re-adjusted. A run with no continuous series is unchanged by it.
The SDK moves the strategy’s own state onto the new basis before the strategy sees it:
ctx.Series(id)holds the re-adjusted history, at the series’ declared lookback. ASeriesthe strategy kept stays valid.ctx.CurrentAdjustmentandctx.CurrentAdjustmentRatiofollow the newest bar.- An open position’s
AvgPriceandAvgPriceAdjustedmove.AvgPriceRawandRealizeddo not: a roll realises nothing in the strategy’s view. - Every working order on the logical symbol moves: its limit and stop prices, its trailing amount and its attached orders. The engine moves its own copy with the same arithmetic, so the two agree to the bit. An order addressed to a dated contract does not move; the roll cancels it.
- Under order lifetime v2 (GLE-1503) that is every attempt in
ctx.WorkingOrders()on the logical symbol, held or working, a bracket child’s own entry included. A child that names no symbol works on its parent’s, and moves with it even after its parent has filled. Each attempt moves in place: its label, attempt number, status and quantities stay, and noOnOrderUpdatereports the move, since the rebase is the report. The roll then re-places each order on the incoming contract as a new attempt, at the moved level, and that update goes out as before. An attempt pinned to a dated contract does not move. ctx.TradeState’s entry price, entry high and low, peak and trough move.
A price level moves by the seam. Under panama it adds the gap, the incoming contract’s price less the outgoing one’s at the cut. Under ratio it is multiplied by the ratio, the incoming price over the outgoing one. A price distance, such as a trailing amount or an ATR, is multiplied by the ratio and ignores the gap. An unadjusted series is never re-adjusted.
Anything else the strategy keeps, such as a remembered level or an indicator’s running state, is its own to move. It implements RebaseObserver, which runs after the SDK’s restatement and places no orders. The kit’s Tracker, StopSuite and LotBook each have a Rebase(gap, ratio):
func (s *Strategy) OnRebase(ctx *algolang.Context, r algolang.Rebase) {
s.entryLevel = r.Level(s.entryLevel) // a price level
s.atr = r.Distance(s.atr) // a price distance
s.track.Rebase(r.Gap, r.Ratio) // kit.Tracker
s.stops = s.stops.Rebase(r.Gap, r.Ratio) // kit.StopSuite
s.book.Rebase(r.Gap, r.Ratio) // kit.LotBook
}Rebase carries the logical Symbol, the SeriesID when it differs from the symbol, the outgoing and incoming contracts (From, To), the cut (At), Gap, Ratio and the re-adjusted Bars, oldest first. Under panama Ratio is 1; under ratio Gap is 0. An indicator with running state, such as an EMA, can rebuild it from r.Bars. Rebase.RestateOrder moves an order exactly as the engine does.
The rebase rides the roll-rebase capability on stdio-pb-v1 and on stdio-csv-v2 (GLE-1505; Capability negotiation). The Go SDK accepts it by itself on either wire. On stdio-csv-v2 the notice is a rebase block: a rebase line and the series’ bars on the incoming basis (Rebase blocks). A strategy written without the SDK accepts the capability in its init_ack and restates what it keeps from each block; the nine language ports of the demo smacross do (The ports under both grammars). A strategy that does not accept it runs without the rebase, and the run’s Data notes say so (When the default gives way). stdio-csv-v1 has no grammar for it, and cannot name a futures symbol either, so a continuous series never runs on it.
bin/algo run --strategy bin/smacross --symbol fut:XCME:ES --bar-interval 1dThe demo smacross makes the same trades with the rebase as without it. It compares two moving averages of the same bars, and a roll’s rebase moves both alike. A strategy that compares a price with a fixed level, or keeps a level across a roll, can trade differently.
What the engine does when the run rebases:
- The bars. Each bar is at its contract’s raw prices plus the seams between that contract and the held one: the gaps added newest first under panama, the ratios multiplied under ratio. The held contract’s own bars are its raw prices, with
CurrentAdjustment0 (or ratio 1). These constants depend only on the rolls up to the held contract, never on where the data ends. So two runs from one start see the same bars and the same history, bar for bar, up to the earlier run’s end. - The warm-up is on the basis of the contract held at the first live bar.
- A session bar’s settlement comes from the feed on the served basis. When the close is the settlement, the settlement is the held close. Otherwise the engine takes it back to raw by the span’s served constant and moves it like the prices, so it can differ from a raw settlement in the last bit.
- Fills reach the strategy at the held contract’s raw price.
- Orders reach the venue at the levels the strategy sent. At each roll the engine restates its own copy of each working order on the logical symbol, then re-places it on the incoming contract. Under order lifetime v2 it restates the rest of its v2 book with the same arithmetic first: each attempt the race guard tracks on the logical symbol, held or sent, children included; a pending or queued in-place modification and its held successor; and a submission the transport scheduler queues. An attempt named by a dated contract stays as it is, a restart’s adopted attempt included, as the strategy’s own view leaves it.
- A trade director values an order in the held frame. A level on the logical symbol is on the held contract’s basis: on the held contract it is that contract’s raw price, and on an older contract it is the level less that contract’s constant (divided by it under ratio). At a roll the director sees the restated levels before it judges the roll’s reopen, so its decisions on a rolled order agree with the strategy’s view.
- The order of events at a roll:
OnRoll(for aRollObserver), then the rebase andOnRebase, then the roll’s own events, such as a carried stop that fills on the incoming contract. - The report stays on the served basis: equity, P&L and trade prices are comparable with a run without the rebase.
result.jsonrecordsRollRebasewith itsRollRebaseSource,defaultorexplicit, andreport.htmllists it among the settings, asRoll rebase: on (default). A run that rebased nothing records neither (Turning the roll rebase off).
The rebase runs under either order lifetime, v2 being the backtest default, with a trade director (GLE-1503), and with aligned views and the portfolio view (GLE-1504), described in the subsections below, and on the stdio-csv-v2 strategy wire (GLE-1505).
A live run on history behaves as its backtest: on the IBKR emulator, on the desk’s broker port and on its SIM clock. The same strategy makes the same trades on the same bars. A restart puts the strategy on the basis of the contract held at its first live bar:
- its warm-up is on that basis, as a backtest started there would be;
- the adopted average cost and working orders are moved onto that basis by their contract’s constant;
- a catch-up roll, for a book on the contract the series rolled out of while the engine was down, sends
OnRollbut no rebase, since the history is already on the new basis.
On a real-time feed (--feed stream) a continuous series needs the rebase. A stream cannot restate the bars it has sent, so only the held frame can carry a series across a roll. The strategy sees the bars, rebases and fills of its backtest, and each roll fires at the later of its cut and the ETH open (Running live on a real-time feed). Such a run is refused when the rebase is turned off, or when its strategy can’t take it.
In a deployment file, "roll_rebase" sets it for every member whose portfolio run does not set its own (Running a deployment against the desk).
Contract rolls in a live strategy shows the rebase on a real ES roll, with the demo rolltrend, which keeps an EMA and a remembered high of its own and moves them in OnRebase.
Turning the roll rebase off
The setting has three states. Left alone it is the default: the run rebases when its strategy takes the roll-rebase capability, and otherwise runs without it and says why. Set on, it insists: a strategy that can’t take it is refused. Set off, the strategy sees the served, end-adjusted series, as before GLE-1502.
| Where | On | Off |
|---|---|---|
algo run | --roll-rebase | --roll-rebase=false |
| A run-config file | "data": {"roll-rebase": true} | "data": {"roll-rebase": false} |
| A deployment file | "roll_rebase": true | "roll_rebase": false |
In a run-config file the innermost level that sets the key wins: a run’s data over its strategy’s, and a strategy’s over global. So false at any level turns it off for the runs within it, and true further in turns it back on (GLE-1502, owner ruling Q2). A deployment’s roll_rebase is the outermost level: it applies to each member whose portfolio run sets nothing, and a run’s own data.roll-rebase wins over it either way. --roll-rebase is a single-run flag and does not combine with --config.
To reproduce a result from before GLE-1502, run it with --roll-rebase=false. The repository’s own runs that must keep their served prices do (Golden masters under the roll rebase).
The run decides once it knows its continuous series, after the strategy’s InitAck, because a strategy may declare a continuous series there (DataRequirements). Before Init the engine only offers the capability: on stdio-pb-v1 and stdio-csv-v2, unless the rebase is off. Then:
| The run | Default | On | Off |
|---|---|---|---|
| has no panama or ratio continuous series | nothing to rebase | nothing to rebase | nothing to rebase |
the strategy accepted roll-rebase | rebases | rebases | does not rebase |
| the strategy did not accept it | runs without it, with a Data note | refused | does not rebase |
on --feed stream, the strategy did not accept it | refused | refused | refused |
result.json records RollRebase only when the run rebased a series, with RollRebaseSource saying how the setting was made (owner ruling Q3): "RollRebase": true, "RollRebaseSource": "default". A run with no adjusted continuous series, one that turned the rebase off and one whose strategy did not take the default record neither, so their result.json is as it was before the default changed.
When the default gives way
A strategy that leaves roll-rebase unaccepted, such as one written without the SDK against a wire grammar from before GLE-1505, still runs under the default. Its series stay on the served basis, the run makes the trades it made before GLE-1502, and the Data notes say so under roll rebase:
Data notes 1 note; the run's degradation.json has the data notes in full
roll rebase off for this run (the strategy did not accept roll-rebase); the strategy sees the served end-adjusted prices of fut:XCME:ES@1d
The same note goes to stderr on a live run. To make the run rebase, accept the capability in the strategy’s InitAck and restate what the strategy keeps at each rebase; to silence the note, turn the rebase off.
An explicit --roll-rebase refuses that strategy instead, after its InitAck, naming the series:
engine: wire: the run re-adjusts continuous futures at each roll (--roll-rebase) but the strategy did not accept roll-rebase; a strategy on stdio-pb-v1 or stdio-csv-v2 must accept it when offered, and restate its own prices at each rebase (GLE-1458, GLE-1505); the run's adjusted continuous series: fut:XCME:ES@1d (turn roll rebase off with --roll-rebase=false)
The error wraps wire.ErrRollRebaseNotAccepted. On --feed stream the default can’t give way, because a stream cannot restate what it has sent:
engine: --feed stream runs a continuous futures series (fut:XCME:ES@1d) only with roll rebase, and the strategy did not accept roll-rebase: a stream cannot restate the history it has sent (GLE-1458, GLE-1502)
A stream run that turns the rebase off is refused before its strategy starts, with a message that ends drop --roll-rebase=false (a run-config's "roll-rebase": false, a deployment's "roll_rebase": false), or run it with --feed history.
Golden masters under the roll rebase
Every golden test runs bin/algo, so since GLE-1502 each continuous golden runs under the default roll rebase. All but one stayed byte for byte as they were. Most strategies make the same trades, because they compare indicators over the same bars, and a rebase moves those alike; and the report, the fills and the blotter stay in the served frame whichever way the strategy calculates. A strategy that keeps a price across a roll can trade differently, so give it an OnRebase that moves what it keeps (Re-adjusting at each roll).
The one test that moved is roundnumbers’ adjusted-series line: under the rebase its bars carry no adjustment, so it no longer logs that its levels are not the contract’s round numbers, and the test checks both settings. The runs that document the served frame pass --roll-rebase=false.
Aligned views across a roll
An aligned view (Aligned series: one row per grid bar) whose source is a continuous series holds samples of that source’s bars. On a run that does not rebase the samples are served prices, and a roll changes nothing in them. On one that rebases (the default since GLE-1502) the source’s history moves onto the incoming contract’s basis at each roll, so each view on it is rebuilt from the rebased source (GLE-1504):
- Every sample the view holds is rebuilt from the rebased source bar with the same close time. Its grid times and its update count stay as they were; only the prices move. A
Seriesthe strategy kept for the view stays valid and reads the new prices. - The bars waiting for the next grid bar (the newest source bar, and any delivered since the last grid bar) are replaced by their rebased bars, so the first sample after the roll is on the new basis too.
- The rebase carries enough history. For a source that a view samples, the engine’s
Rebase.Barsreaches back to the oldest source bar any of its views still holds a sample of, or the source’s own depth, whichever is further. The source’s own series still keeps only its own depth, butOnRebase’sr.Barscan then hold more bars than that. A bar older than the frame’s first comes from the series’ history, which the run fetched for the warm-up; it is tagged with the view’s id, rebuilds the view, and is kept out of the source’s series and ofr.Bars. - The warm-up is on the held basis, as the source’s own warm-up is, so a view and its source agree from the first decision.
- A rebase of the view’s grid series changes nothing in the view: a sample takes only the grid’s times.
- If a sample’s source bar is missing from the rebase, the run stops with an error naming the view, rather than keep a sample on the old basis.
OnRebase runs after the views are rebuilt, so it reads them on the new basis. A strategy needs no code of its own for its views. The rebuilt samples are bit for bit the samples a run started after the roll would build from the same bars.
The portfolio view across a roll
The portfolio view (Reading the portfolio) follows the run (GLE-1504). On a run that does not rebase a continuous series’ row is in the served frame, the prices the strategy’s bars have. On one that rebases (the default since GLE-1502) the strategy calculates in the held contract’s own prices, and so does its row:
Markis the series’ latest close as the strategy sees it: the held contract’s own close, stamped with that bar’s close time inMarkTime.AveragePriceis the entry moved onto the held contract by each roll since entry. It equalsctx.Position(symbol).AvgPriceto the bit: the engine keeps its own copy of the strategy’s average, from the fills it sends it and each rebase, with the arithmetic the SDK uses.Notionalis quantity ×Mark× point value, at the FX rate in force atMarkTime.Contractis the contract the series holds.OpenPnLandRealizedPnLare money, and stay as the report states them, on the served basis. Under ratio adjustment a row’sOpenPnLtherefore need not equal (Mark−AveragePrice) × quantity × point value: the prices move by the ratio, the money does not.- Working orders are at the prices the venue holds, the held contract’s, as they are without the rebase.
For example, a strategy buys 2 ES at 1002 and 1 more at 1003, then holds across a roll whose gap is 3 (panama). Its row of the view reads:
| When | Quantity | AveragePrice | Mark | Contract |
|---|---|---|---|---|
| after the first buy | 2 | 1002 | the H contract’s close | ESH26 |
| after the second buy | 3 | 1002.3333333333334 | the H contract’s close | ESH26 |
| after the roll | 3 | 1005.3333333333334 | the M contract’s close | ESM26 |
At every decision the row’s average price is what the strategy’s own position says, so code that compares the two needs no tolerance:
for _, row := range ctx.Portfolio().Positions() {
if row.Member != ctx.Portfolio().Reader() {
continue
}
pos := ctx.Position(row.Symbol)
// On a run that rebases: row.AveragePrice == pos.AvgPrice, and
// row.Mark is the close of the bar the strategy is deciding on.
_ = pos
}A view the strategy reads at a timer that a roll fired ahead of (Scheduled decision points (timers)) is pushed again after the roll, so it is on the new basis too.
The engine checks the two copies as it builds each view. A row whose quantity differs from the strategy’s position, or that has no close in the held frame, stops the run with an error naming the series. With --report off the rows come from the simulator, and a held series’ row is re-priced the same way: the latest close and its time, the strategy’s average price, and the notional at that close’s FX rate. Its OpenPnL stays the simulator’s.
At the desk on its SIM clock the view comes from the desk, which prices every member’s positions at its broker port, in contract prices. A member that reads the view and holds an adjusted continuous series must rebase, or its view and its own position would be on different bases. A member that does not, because its deployment turns the rebase off or its strategy leaves roll-rebase unaccepted, is refused as soon as it has connected to the desk (after the desk’s Init), before any bar:
engine: the portfolio view at the desk's SIM clock needs roll rebase for the adjusted continuous series fut:XCME:ES@1d: it is on by default, so drop "roll_rebase": false from the deployment and run a strategy that accepts roll-rebase (GLE-1504, GLE-1502)A member that does not read the view, or whose continuous series are unadjusted, is not refused.
Several continuous series in one run
A run can hold several continuous series, each of a different root, beside any plain series (GLE-424): --symbols fut:XCME:ES,fut:XCME:NQ, or a series list in a config. A strategy may also declare a deferred composite of a configured root, such as fut:XCME:ES:cont:ofs=B1 beside fut:XCME:ES, for reference or to trade it as well (Contract curves). Each root is stitched and rolled by its own served schedule, and the strategy sees every series under its own logical symbol. Four things follow:
- Bars come one series at a time. The two legs of one trade date are two bars. Their order is not fixed, and they can close a second or two apart: a session bar closes on its last trade. Pair them by
Bar.Session.TradeDate, not by the close time. - An order reaches its series from any bar. An order for a logical symbol, or for its active contract, goes to that series whatever bar it was placed on. A spread places both legs on the second leg’s bar. A reference-only series takes no orders: an order for its logical symbol is refused, and its active contract is not routed to it.
- Positions are per logical symbol.
ctx.Position("fut:XCME:NQ")is the NQ series’ lots, rolled with it. A dated contract of the same root configured beside it (fut:XCME:ES:M26besidefut:XCME:ES) is a second position that never rolls. - Each series keeps its own artefacts. Each series’ manifest and audit ledger go to
continuous/<series>/under the run’s results directory (GLE-425).
strategies/demo/go/esnqspread is the worked example: an E-mini S&P 500 / E-mini Nasdaq-100 relative-value strategy. On each trade date with both legs it takes the log ratio of the adjusted closes and standardises it over 20 trade dates (spread.go). It sells the spread (ES short, NQ long, NQ sized to ES’s notional) at a z-score of +2, buys it at -2, and flattens within 0.5 of zero. The pairing is the only multi-series code it needs:
date := bar.Session.TradeDate
es, nq, ok := s.pair.Add(leg, date, bar.Close) // the trade date's second leg completes it
if !ok {
return nil, nil
}
z, ok := s.model.Observe(es, nq)
...
case EnterShort:
add(algolang.MarketSell(s.ES, s.params.ESLots).Named("Spread SE"), "short-es")
add(algolang.MarketBuy(s.NQ, s.params.NQLots(es, nq)).Named("Spread SE"), "short-nq")Since the order-lifetime programme’s I21 (GLE-467) the demo declares optional lifetime-v2 support, and cf21_conform_test.go beside it runs it under both profiles over a crafted two-symbol fixture (the legs named by its inputs), the spread bought and flattened then sold and flattened, eight fills equal under each (Conformance under both lifetimes).
make run-esnqspread runs it over the archive from 2022 through 2024 (ESNQ_START, ESNQ_END). The decisions log to stderr, and the report shows the one instance over both series (excerpt):
[esnqspread] 2022-02-21 z=+2.08 sell the spread: sell 1 ES, buy 1 NQ
[esnqspread] 2022-02-24 z=-0.16 flatten the spread
[esnqspread] 2022-03-07 z=+2.31 sell the spread: sell 1 ES, buy 1 NQ
[esnqspread] 2022-03-09 z=+0.38 flatten the spread
...
Algolang run run-fut-xcme-es+fut-xcme-nq-1d
instance: 1 (fut:XCME:ES@1d + fut:XCME:NQ@1d), 128 orders
bars: 1,550 main after replicate (+ 0 warmup), 1,550 loop, 128 orders
simulator: resolution=bar bracket_ambiguity=conservative limit_fill=conservative slippage_ticks=0
148 fills, commission 0.00, realized PnL 57437.50
equity 157437.50 (capital 100000.00, return +57.4375%)
performance: net profit +57437.50 (+57.44%) | closed equity 157437.50
max drawdown 44530.00 (36.93%) peak 2022-08-09 trough 2023-05-26 | sharpe 0.82 | cagr +16.38%
trades 64 closed | win rate 57.81% (37W/27L/0E gross) | profit factor 1.31The 148 fills are the 128 strategy orders plus 20 roll legs: the rolls that fell while a spread was open, each executed by the engine at its root’s served cut. This is an example of the mechanics, not a tested edge: the spread is not cointegration-tested, and the run charges no commission or slippage. TestGoldenEsnqspreadDecisionsMatchTheServedComposites, under make test-golden, checks the run. It dumps the served bars of both series with printbars, replays the model over them, and requires every decided order, and no other, among the run’s fills.