Continuous futures

The strategy sees one logical adjusted series while the venue fills dated contracts at raw prices. Marketfeed elects every roll, serves the root’s roll schedule and serves the spliced, adjusted composite; the engine consumes the two as one pinned pair and translates orders (GLE-270, GLE-323).

A run names the root in one of two forms (GLE-325, owner Decision 4): the bare root fut:XCME:ES, adjusted with Panama, or the composite fut:XCME:ES:cont:adj=<panama|ratio|none> with the method on the symbol (bare :cont is panama). Both take the price grid from the adapter’s instrument metadata for the root and route through one dispatch (continuousPlan in engine/continuous_dispatch.go); the engine keeps no symbol registry. The grammar refuses, before any spawn and with its own text for each: :cont anywhere but directly after the root, a repeated adj=, an unknown adj= value (want adj=panama, adj=ratio or adj=none; a value in any case takes its lowercase spelling where the symbol enters the run, GLE-514), ofs=F, an ofs= value other than B1, B2 or B3, a repeated ofs= (a deferred rank runs since GLE-410), any other qualifier such as straddle=, and an @ suffix. An @ES-style alias, the retired registry’s symbol, is no continuous form since ER5 (GLE-327): the recognition that refused it with the replacement named for one release (ER3) is gone, so it takes the plain path and the adapter judges it like any other symbol. A run can hold several continuous series, each of a different root, beside any plain series (GLE-424); a run that names one root twice (two intervals, or the root beside one of its composites) is refused before any spawn, since both would trade one chain of contracts. A run with a continuous series takes the BARS schema, and each continuous series time bars. Every series runs through the same run phases (GLE-423, GLE-424): the data client, its gates and the fetch, where a continuous series’ gates are its served roll schedule and its clock’s session and its fetch builds its served composite; one strategy phase, which Inits the strategy with each continuous series’ logical symbol and the simulator with every series’ contracts beside the plain symbols (engine/contrun.go, engine/contmix.go, with the pieces shared with the composite driver in engine/contseries.go); the run report and BENCH line. A relative spec in the root (fut:XCME:ES+1), an intra-bar path request its composite serves no path for (a 1w session bar, or a bare include-path at 1d: continuous_path_unavailable, GLE-550 as reduced by GLE-1332, engine/contpathguard.go) and a session together with the epoch clock are refused, in that order, by the guard that follows (continuousGuard, engine/contguard.go); an intraday grid has been accepted since GLE-443. The run id is run-<slugified symbol>-<interval>: run-fut-xcme-es-1d, run-fut-xcme-es-cont-adj-ratio-1d.

The consumption pipeline is engine/continuous (ParseServedSchedule in compschedule.go, BuildComposite in composite.go) with engine/adjust for the manifest; engine/resolver translates orders, fills and roll legs by the served constants. continuous_composite.go fetches the schedule and the composite and builds the run, continuous_run.go orchestrates it, and continuous_servedloop.go executes it, rolling at each served cut. Panama, ratio and none methods, bracket retranslation, and partial-roll primitives are implemented. There is no other construction: ER5 (GLE-327) deleted the per-contract path (each held contract fetched on its own and adjusted locally by engine/contadjust over the served schedule), the former local election (continuous.Build, engine/roll, engine/symbols) and the registry’s roll block, so an adapter that serves no schedule or no composite fails the run and nothing re-elects locally. The parity gate that compared the two constructions before the deletion (ER4, GLE-326; E4) left its record in testdata/parity-composite/summary.txt.

At a roll the driver plans the fate of every order working on the outgoing contract (the roll plan, engine/rollplan.go), cancels or replaces each at equivalent adjusted levels and transfers the position at the served cut (see Roll execution at the cut). continuous_orderbook.go tracks orders and bracket generations so stale lifecycle events cannot clear a new bracket. RollPartialFailure records which of the roll’s checkpoints completed: order_status, position, cancel_from, open_legs, advance and resubmit, with resubmit_at_cut before advance under order lifetime v2. Under v2 every order the roll re-places is a new attempt that the strategy, its working view and the race guard follow (see Order lifetime v2 across a roll). Automatic recovery at the next live startup remains future work.

With --results-dir, continuous runs persist manifest.yaml and the dual raw/adjusted audit.jsonl; degradation produces degradation.json when applicable. Manifests reconstruct series adjustments and pin the schedule followed; the audit records fills and rolls. Invariant 5 checks active-contract mapping and invariant 6 checks manifest integrity. Live refuse-to-start gates exist. A live run on the emulated venue trades a continuous series under lifetime v1 since GLE-1385 8b: it follows the composite fetched at start, steps the emulator on the held contract, and rolls at the venue with two DAY market legs, which since GLE-1447 the venue fills at its own price for each contract at the cut (Continuous futures in live mode). Since GLE-1447 it runs against the desk too, on each of its clocks. Since GLE-1446 it runs under lifetime v2 and with a trade director too, with a ledger, on a venue fed from history, and since GLE-1503 on a real-time feed, where each roll re-adjusts the series. Before 8b every live continuous run was refused (owner decision 2026-10-04, GLE-228 Decision 7).

--symbol-registry and --served-roll-schedules are gone (ER3, GLE-325): algo run treats either as an unknown flag. The config keys symbol-registry and data.served-roll-schedules were refused for one release and are, since ER5 (GLE-327), unknown fields like any other: the config loads and a warning names the ignored key (unknown field global.symbol-registry ignored); delete them.

No run warns about roll knobs any more: there is no definition to carry one, and the intraday-roll flag is implicit in the served cut instants (GLE-228 Decision 9, done by GLE-270).

scripts/golden-roll-agreement.sh is the engine-side gate for this. On the live archive, a bare-root fut:XCME:ES run, a fut:XCME:ES:cont:adj=panama run (the bare root’s method, named) and a --cache off run of the bare root must pin the schedule the adapter serves, execute exactly its cuts inside the window (the audit ledger’s roll_dates against cmd/tools/rollsched’s dump of the schedule), and build manifests that differ only in the symbol’s name. (The manifest’s exdate is the incoming contract’s first bar, not the cut; the audit ledger records the cut.) make roll-agreement runs it.

Continuous run conventions

A continuous series runs through the same bar loop as every other series (GLE-421). Its frame (engine/contframe.go) owns the series’ contract mapping, adjustment and roll execution, and the loop calls it per bar in a fixed order: start the bar (the lifecycle trace marks it), fire the rolls due before it (the notice first, then both legs at the served cut), hand the simulator the bar’s original contract bar and deliver its events translated onto the logical symbol, push the account, record the adjusted bar and the raw mark, send the strategy the adjusted bar, and route the strategy’s orders: the logical symbol is translated onto the active contract, the active contract is taken as addressed, and any other symbol is rejected before it reaches the simulator. The end-of-data cancellation goes through the frame too.

The loop can carry several frames, and plain series beside them (GLE-422): every frame’s rolls fire on the loop’s clock, at the first bar of any series that closes after the cut, in the order of their cuts (series order on the same instant), so a roll is not held back until its own series’ next bar. Each venue event goes to the frame that owns it: a fill by its contract’s chain, a cancel by the order it came from, and anything else to the plain series’ delivery. The simulator’s clock never moves backwards (a roll’s synthetic bar sits at its cut, which can precede another series’ last bar), and a roll leg is exempt from the rule that admits an order submitted after another symbol’s bar only on a later bar of its own. With one series nothing of this changes the run.

A run plans any number of continuous roots beside plain series (GLE-424):

  • Orders route by their symbol. An order for a continuous series’ logical symbol, or for its active contract, goes to that series’ frame from any series’ bar, so a strategy can trade both legs of an ES/NQ spread on one bar. An order for a plain series’ symbol goes to the simulator as on a plain run. Any other symbol is refused by the series whose bar it was placed on.
  • A dated contract beside its own root is a second position. With fut:XCME:ES and fut:XCME:ES:M26 in one run, the continuous lot is held as ESM26 and rolls with the series, and the dated lot is held as fut:XCME:ES:M26 and never rolls. The strategy sees two symbols and the simulator two books.
  • A continuous series warms up and fills at bar resolution. Its warm-up (GLE-393) is the strategy’s lookback depth of adjusted bars before the start. They are read in the same served composite as the live bars: pinned to the first build’s snapshot token, generation and adjustment anchor, so warm-up and live bars share one adjusted frame. The rolls before the start fire silently: no roll notice, no roll legs and no audit record, since nothing is held yet. The run starts on the first live bar’s contract, and the simulator’s universe holds only the contracts the live part can trade. When the warm-up holds fewer bars than the lookback, the series records a warmup_shortfall degradation and runs with what it has, as a plain series does. When the feed refuses the earlier read, its build fails (a degraded or empty span there, say), or it does not reproduce the run’s own bars (adjusted bars and original contract bars alike, under the same snapshot), the series starts cold, and a warmup_shortfall record says why. A broken connection fails the run, as on a plain warm-up fetch. The run’s resolution is bar whatever --simulation-resolution asks, because a contract’s trade prints are not fetched.
  • Declarations work as on any run (GLE-392). Declared plain series (COT, FRED, dated contracts) reconcile as on a plain run. A declared continuous series, a bare root or a :cont composite, joins the run as a continuous series on any run, plain or continuous: it is gated on its served schedule, fetched as its served composite and driven by its own frame. It needs the pb data wire, and a root the run already holds at the same rank is refused; a deferred rank of it (ofs=B1..B3) joins (GLE-410). A declaration naming a configured series is that series. Aligned series work on a continuous run, a continuous grid or source included (On a continuous run, GLE-394). Declared market events are still refused on a run with a continuous series, except a root’s contract listing, which ctx.Curve reads (GLE-410, Contract listings as events).
  • A declared continuous series is reference-only unless tradeable. Its bars arrive and its rolls are kept, but the simulator’s universe holds only the contracts of the series the strategy may trade. An order on a reference-only series is refused (… is declared for reference only: the run takes no orders on it), and its bars match no order in the simulator, even on a contract another rank of its root trades (GLE-410). Naming it in TradeableSymbols, under universe-expansion=full, puts its contracts in the universe, beside another rank of its root that trades too (GLE-484).
  • Each continuous series has its own artefacts (GLE-425). With one continuous series, the run’s directory holds manifest.yaml, audit.jsonl and degradation.json as before. With several, each series writes its manifest and ledger in <run>/continuous/<series>/ (the series symbol slugified: continuous/fut-xcme-es/manifest.yaml). The run’s one degradation.json stays at <run>/, each record naming its series (fut:XCME:NQ@1d). The result header’s series entries carry Continuous, Method and HeldRank for each continuous series. The run report prints a held-rank line per series that holds a deferred rank.
  • Performance pairs fills by identity (GLE-425). The recorder pairs each translated fill with its simulator metadata (order type, slippage) by the fill’s identity: client id, side, quantity, time and execution id, first in first out within one identity. It no longer pops one queue in order, so series whose deliveries interleave cannot trade each other’s slippage.
  • Warm-up shortfall records name their series on a run of several series, like the continuous records; lead-in clamp and aligned-view records name it in their note.

TestGLE424TwoRootsRollAtOneInstant, TestGLE424TwoRootsRollAtTheirOwnCuts and TestGLE424ContinuousBesideItsDatedContract (engine/gle424_several_roots_e2e_test.go) run each case through a subprocess adapter serving ES and NQ composites and a probe strategy.

These are the engine’s conventions since GLE-270 and GLE-323. They describe how the engine consumes marketfeed’s served roll schedule and :cont composite (wire reference: ROLL_SCHEDULE, the request pins and the composite Bar fields in the Protocol reference). How marketfeed elects, measures and adjusts is marketfeed’s documentation: the sections “How a roll works, end to end”, “The roll schedule (grammar v2)”, “The :cont composite product” and “Adjustment: panama, ratio, none” of docs/marketfeed.md in the marketfeed repository (GLE-274). Until ER5 (GLE-327) this section was “Continuous construction conventions”; the construction it once described left the engine with the local election, and what stays here is the engine’s side: what it checks, refuses, executes and records.

Who decides what

FactOwnerEngine behaviour
Which contract is held when (spans, cut instants)marketfeedfollows it; elects nothing
The seam pair at each cut (out_at_cut, in_at_cut)marketfeedfills the roll legs at it and stamps RawGap/RawRatio from it; does not re-measure it
The adjusted bars and each span’s cumulative constantmarketfeedtakes them as served; checks each bar’s constant against its span’s, and the holder’s against the identity; translates orders by them
Held rank (front or deferred)marketfeedfollows the served contracts at any disclosed rank and reports it (GLE-387); refuses an undisclosed rank
Price grid, adjustment methodthe adapter’s instrument metadata for the root; the method is the symbol’s adj= (panama when it names none)applies the grid; the method selects the composite requested (adj=)
Order translation, roll execution, roll costengineexecutes at the cut, pays slippage + commission

The instant law

A held span is the half-open interval [Start, End). A bar belongs to the span whose interval holds its close: Start < ts_close <= End. The cut instant T of a roll is the incoming span’s Start (the outgoing span’s End). So the outgoing contract’s last bar is the last one closing at or before T, and the incoming contract’s first bar is the first closing after T.

A bar straddles the cut when its bucket crosses T. An epoch composite (an intraday run, or any run under --continuous-clock epoch) is requested with straddle=incoming, so the feed rebuilds such a bucket from the incoming contract’s own tape, tags it with the incoming contract and names the outgoing one in seam_prior_contract; the engine notes the straddle when the incoming span’s first bar carries that field. A bucket whose outgoing side has no constituent (ES’s Sunday 22:00Z cut inside a UTC-day bucket, the outgoing contract’s Sunday session opening at the cut) is served as one bar tagged with the incoming contract, opening at the bucket’s nominal start, before the incoming span’s Start, with no prior contract. The engine therefore judges membership on the close alone and treats the open as a bucket label; stamping the fragment’s first constituent’s start as ts_open (MR2’s split-fragment law) is a marketfeed follow-up that would let a consumer judge both instants. Under GLE-274’s schedule the cut is the roll date’s first trading instant (ES: Sunday 22:00Z for a Monday roll date), so a trade-date session bar does not straddle: a daily continuous run reads session bars (GLE-324, D5 = E), the incoming contract’s first bar opens at the cut and closes after it, the outgoing contract’s last bar closes before it, and no straddle note or record arises. An epoch daily bar (--continuous-clock epoch) straddles only when the prior trade day’s session shares its UTC day.

An intraday grid follows its own law. eth, rth and session grids never straddle a v2 cut; a utc-day grid parent across one is served merged, and the simulator executes only its remainder from the cut, in the incoming contract (GLE-444; see Intraday grids). The rest of this section is about epoch buckets.

At bar resolution with no path, a bucket that crosses the cut is routed by bar, not by instant (GLE-286). The roll executes at T before the bar reaches the simulator, so every fill on that bar is in the incoming contract at the incoming contract’s prices, including a resting order that fills at the bar’s open. A bar-resolution fill is stamped at the bar’s close, so the ledger stays in time order: the roll legs at T, then the bar’s fills. An OHLC bar cannot order its intra-bar events against the cut, and the simulator does not split a bar at the cut. A path run routes it by instant (GLE-1332): the roll executes at T and the simulator walks the bar’s path from T, in the incoming contract, so the pieces before the cut are not walked (Path resolution). Daily and weekly continuous runs read session bars, which never cross a cut, so this reaches intraday epoch runs and the --continuous-clock epoch option only. It takes two shapes:

  • One-sided. The outgoing contract does not trade in the bucket before the cut, so the bar holds only the incoming contract’s market from T on. Its open is the incoming contract’s first trade at T, and only the bucket’s ts_open label precedes the cut. Livestock on a 1h grid is served this way. LE’s J26→M26 cut at 2026-03-17T13:30Z (08:30 CDT) falls inside the 13:00Z bucket, which comes whole from M26. No straddle note or record arises, because the bar names no prior contract.
  • Two-sided. Both contracts trade in the bucket, which happens on a grid that crosses a cut inside trading hours. CL’s G26→H26 cut at 2026-01-14T23:00Z falls inside the 20:00Z bucket of a 4h grid. The feed rebuilds the bucket from the incoming contract’s own tape, so its open is the incoming contract’s price from before the cut, when the strategy still held the outgoing one. The engine notes the bar, and degradation.json records it, as bar straddles the cut CLG26->CLH26 at …: its bucket crosses the cut and the feed assigned it to the incoming contract CLH26 (straddle=incoming); routed by bar: the roll executes first, so every fill on the bar, even at its open, is in CLH26. On a path run the note reads routed by instant on its path: the roll executes at the cut and the simulator walks the bar's path from it, in CLH26; the <n> piece(s) before the cut are not walked, with <n> the count of pieces before the cut.

engine/gle286_intraday_straddle_test.go pins both shapes on a 1h grid with a cut at :30: the roll legs at the cut at the served pair, and an exit resting across the cut that fills in the incoming contract at the crossing bar’s open. engine/gle1332_contpath_test.go pins them on a path run: a market order resting into the crossing bar fills at the first price after the cut, and a stop that only the pieces before the cut reach does not fill there. Where the two-sided case matters, choose a grid whose buckets start at the roots’ cuts. On a 1h grid, every served cut since 2016 starts a bucket except livestock’s, which are one-sided. The 2026-10-03 census found that all 224 cuts off the whole hour are LE, HE and GF.

Served seams

The feed removes each seam from older history and serves the result: panama_snapshot_forward bars carry cumulative_adjustment (the additive offset, accumulated from in_at_cut - out_at_cut toward the anchor’s holder), ratio_snapshot_forward bars carry cumulative_price_ratio, and unadjusted bars carry the venue prices with both constants zero. The schedule discloses the same constant per span up to the anchor’s holder, which carries the identity (offset 0, factor 1); spans after the holder are served undisclosed. The engine takes the adjusted and raw prices as served and recomputes nothing. It refuses a bar whose constant differs from its span’s (CONSTANT_MISMATCH), a traded span with no constant (CONSTANTS_UNDISCLOSED), a holder not at the identity (HOLDER_NOT_IDENTITY), a constant that is not finite or a ratio that is not positive (CONSTANT_INVALID), and bars whose adjustment state does not match the run’s method (BAR_NOT_ADJUSTED, BAR_ADJUSTED_UNDER_NONE). Every boundary’s RawGap (and RawRatio under ratio) is stamped from the served pair under every method, so a needs_rolls strategy’s RollNotice reports the real raw seam even when the series is unadjusted. A seam pair that is not finite or is zero on both sides fails the run, as does a ratio seam whose pair has no finite positive quotient (RATIO_SEAM_INVALID).

A seam the feed built from a fallback price (degraded, with degraded_reason settle_window, last_common or temporal) refuses the run by default when it lies between two traded spans: its pair is a substitute, and one substituted seam moves every adjusted bar on the far side of it.

continuous: fut:XCME:CHF: SEAM_DEGRADED: the served seam CHFM14->CHFU14 at 2014-06-12T22:00:00Z is degraded (reason: temporal, cadence: 1m); its pair is a fallback, and one substituted seam moves every adjusted bar on the far side of it: pass --accept-degraded-seams to trade it anyway

Before it stops, a refused run with --results-dir writes degradation.json with one record of kind degraded_roll_seam_refused (GLE-228’s close-out), naming the root and the seam. Its contract is the incoming contract, its earliest and latest are the cut, and its note is:

fut:XCME:CHF: served seam CHFM14->CHFU14 at 2014-06-12T22:00:00Z: reason temporal, cadence 1m; refused (SEAM_DEGRADED): pass --accept-degraded-seams to trade it

The run writes no manifest. A failure to write the file is joined to the refusal, which stays the run’s error.

--accept-degraded-seams (config key accept-degraded-seams) trades every such seam in the run as served: each is flagged in the manifest (SeamDegraded), noted (served seam CHFM14->CHFU14 at 2014-06-12T22:00:00Z is degraded (reason: temporal, cadence: 1m); accepted on request, a degraded seams line of the run’s data notes), recorded in degradation.json as degraded_roll_seam, and the manifest pin carries ;degraded-seams=accepted. A degraded seam into a span the window does not trade is not examined, and an adapter that serves no reason reads reason: unstated. A per-seam allowlist (--accept-degraded-seam <root>:<from>-><to>) is a follow-up to the run-wide flag. The run manifest’s underlyingsources carry the served state sched:<recipe>@g<N>@snap:<token>;rank=<F|B1|B2>[;seam=<policy>][;degraded-seams=accepted]: the snapshot token is part of the pin, so the pin moves on every nightly re-derive even when the constants do not, and any manifest diff tooling masks @snap: (as the retired parity gate did, ER4).

Roll execution at the cut

A roll fires on the first bar closing after T (the incoming contract’s first bar). The driver (rollAtCut, engine/continuous_servedloop.go) decides what becomes of every order working on the outgoing contract before it touches the simulator, in a roll plan, and then executes the plan. In order, it:

  1. sends the strategy its RollNotice (when it observes rolls), before anything the roll executes reaches it;
  2. under --gtc-expiry ibkr-quarter, applies the venue’s deadline first (Simulator.ExpireGTC): every working GTC order, of any symbol, whose deadline is before the roll’s trade date is cancelled GTC_EXPIRED, its OCO group settled, and the cancels are delivered before anything else of the roll, so an order the venue has already ended is not in the book the roll reads; under lifetime v2 the contract expiry pass follows it in the same slot when the cut comes after the outgoing contract’s expiration (a late roll), cancelling the contract’s orders CONTRACT_EXPIRED and settling its position (the GTC rule at a roll, Contract expiry (lifetime v2)); then, under lifetime v2, the race guard’s held attempts pinned to the outgoing contract are refused hold_rolled, stamped at the cut and delivered at once, before the book is read (GLE-491, held attempts at a roll);
  3. reads the orders working on the outgoing contract from the simulator’s working-order index, classifies them, reads the net position and builds the roll plan (below); under order lifetime v2 it also numbers each order the plan re-places as a new attempt (Order lifetime v2 across a roll);
  4. cancels every working order on the outgoing contract, in book order, before any replacement exists, so a fault mid-roll cannot leave exposure in both contracts; each cancel is hidden from the strategy unless the plan delivers it;
  5. when the position is not flat, submits two market legs: one closing the outgoing position, and one opening it in the incoming contract carrying the position’s bracket children re-translated to the incoming contract;
  6. under order lifetime v2 only, re-submits in the incoming contract the standalone orders that rest across windows and that the cut price would not fill (below), each anchored at the roll’s trade date; a re-submission the simulator denies is lost protection under the run’s lifetime driver, not the roll’s failure; it then tells the race guard and the strategy of every order re-placed or lost so far, the lost orders’ rejection cancels after the updates;
  7. advances the simulator through two synthetic bars at T: an outgoing bar flat at out_at_cut, where the close leg fills and the cancels of step 4 drain, then an incoming bar flat at in_at_cut, where the open leg fills and the re-established bracket children are first evaluated (their fills and OCO cancels there reach the strategy); under v2 the orders of step 6 are evaluated there too, and none of them fills there;
  8. re-translates the remaining standalone working orders into the incoming contract: every one under lifetime v1; under v2 the Day, IOC and FOK orders and every order the cut price would fill (since GLE-575 those that reach the incoming contract as market orders, since GLE-627 every one), with the other members of their OCO groups. Their guard and strategy are then told of them; under v2 a denial here is lost protection as in step 6;
  9. with --lifecycle-json, writes the roll’s roll_account record: the trade date, the orders the deadline ended, every order the plan found with its fate and, when there were any, the held attempts step 2 refused (The lifecycle trace schema).

Both legs therefore fill at the cut instant at the served pair, each moved adversely by the run’s per-leg --slippage-ticks and charged commission: those are the modelled roll cost, and there is no separate roll-cost setting. Under Panama the two legs’ adjusted prices are equal, so the roll itself books no adjusted-frame P&L beyond its costs. The resolver translates each adjusted-frame order onto the active contract by that contract’s served constant, the one the build checked against the served bars; the engine holds no arithmetic of its own.

The working-order index. Step 3 reads the simulator’s book (Simulator.WorkingOrders, engine/sim/working.go): the status report of every order neither filled nor cancelled, an activated bracket child included, in the order the orders entered the book. It replaced (GLE-452) a scan of the simulator’s append-only record log (GenerateOrderStatusReports), which keeps a record of every order the run has submitted. Under explicit order lifetime that log grows with every cancelled attempt, so each roll cost time and memory in proportion to the run’s whole history; the index costs the working book. Behind 100,000 denial records a roll now allocates under 4 MiB, where the log scan allocated about 17 MiB (TestTr15RollCostIsTheWorkingBook). The index and the log’s working reports agree report for report, because an order’s record and its book entry are created in one step. The log’s other readers (the lifecycle trace’s end-of-run snapshot, the emulator’s open-orders handler, the live path) are unchanged.

The roll plan. Two pure functions in engine/rollplan.go, over the types in engine/rollplan_types.go, decide the plan. rplanClassify gives each working order on the outgoing contract a class, read from the continuous order book’s record of the order rather than from the simulator’s report:

  • pinned: the order’s own symbol is the outgoing dated contract (the strategy addressed the contract, or the order is a child of such a bracket); this class is checked first;
  • child: an activated bracket child of a filled entry, the protection of the position the roll moves;
  • standalone: a top-level order on the logical symbol, a lone limit or stop or an unfilled entry with its pending children.

A working order on the outgoing contract that the order book does not track fails the roll at its first checkpoint (working order "<id>" on <contract> is untracked (cannot re-translate)) instead of vanishing in a silent cancel. rplanBuild then gives each order one of four fates:

  • cancel: the cancel is delivered to the strategy, with reason explicit under lifetime v1 and roll under v2, and nothing replaces the order;
  • drop: the cancel is hidden, and nothing replaces the order;
  • reattach: the cancel is hidden, and the order, re-translated, rides the open leg as an attached order, so the simulator re-establishes it with its siblings as an OCO group when the open leg fills;
  • resubmit: the cancel is hidden, and the order, re-translated, is submitted on the incoming contract under its client id as a new physical submission, with a new broker id. An unfilled entry goes whole, and the parent-cancelled notices of its pending children are hidden with its own cancel.

Under v2 a reattached or re-submitted order, and each labelled pending child a re-submitted entry carries, also takes a new attempt under its label (Order lifetime v2 across a roll).

Classv1, not flatv1, flatv2, not flatv2, flat
pinnedcancelcancelcancelcancel
childreattachdropreattachcancel
standaloneresubmit after the barsresubmit after the barsresubmit at the cut (Day, IOC and FOK orders, orders the cut price would fill and their OCO groups after the bars)resubmit at the cut (Day, IOC and FOK orders, orders the cut price would fill and their OCO groups after the bars)

“After the bars” is step 8, after the synthetic cut bars; “at the cut” is step 6. A pinned entry’s pending children are not hidden: when an unfilled pinned bracket is cancelled, its children’s parent-cancelled notices reach the strategy with the entry’s cancel.

Under lifetime v1 the plan reproduces the roll as it was before the plan existed: the same cancels in the same order, the same hidden cancels, the same re-attached children, the same re-submissions after the synthetic bars, the same conversions and the same checkpoints (order_status, position, cancel_from, open_legs when not flat, advance, resubmit). Every golden is byte-identical. That includes a flat roll’s bracket child, cancelled with its cancel hidden and not replaced, so the strategy’s view keeps an order the simulator no longer has: a v1 defect that the frozen legacy profile keeps.

The asymmetry under v1 between a bracket child and a standalone order is deliberate. A bracket child activates on the open leg’s fill and is evaluated at the cut, so a child whose level the cut price has crossed fills there, and the strategy sees it. A standalone order is re-translated after the synthetic bars, so a Day order keeps its one-bar life for the first real incoming bar instead of spending it on a synthetic one. The cost: a standalone stop the cut price is already through fills at the first real bar’s open, not at the cut. Since GLE-627 lifetime v2 has the same asymmetry: no order the roll re-submits fills at the cut price under either profile, while the roll legs and a re-established bracket child fill there under both.

Order lifetime v2 at a roll. Since I15 unit 2a (GLE-453) a backtest under lifetime v2 runs on a continuous series, and two plan rules differ there from v1’s; lifetime v1 is byte-identical. What the strategy, its working view and the race guard see of the orders a v2 roll re-places is in Order lifetime v2 across a roll.

  • A flat roll’s bracket child is cancelled and the cancel delivered (reason roll), not dropped in silence. No position is left for it to protect, re-establishing it alone could open one, and the strategy’s working view must not keep an order the venue no longer has.

  • A resting standalone order is re-submitted at the cut, and no order the roll re-submits fills there. v1 defers every standalone order past the synthetic bars for the sake of the Day order’s one bar. Under v2 an order keeps the deferral when either holds:

    • it has a single evaluation window: a Day order (its one bar), or an IOC or FOK order (its first window; one submitted at the outgoing contract’s last close is still working at the cut);
    • the cut price would fill it: since GLE-575 (the owner’s ruling of 2026-10-21) an order that reaches the incoming contract as a market order, a market order of any time in force and a stop the cut price is through, which the plan converts (below); and since GLE-627 (the owner’s ruling of 2026-10-29) every other order the synthetic incoming bar would fill: a limit the cut price makes marketable, a converted stop-limit whose limit is marketable there, and a first-touch stop at or through the cut price.

    An OCO group goes whole: when any member keeps the deferral, every member does, so a group never straddles the two windows, and the first real incoming bar settles it, its members in plan order, as under v1. The deferred orders’ window lands on the first real incoming bar, as under v1, so a market-form order fills at that bar’s open and a marketable limit at the open or its level. rplanAtCut in engine/rollplan.go holds the time-in-force and market rules. rplanDefer, run on the plan right after it, holds the rest: it asks the simulator (Simulator.FillsFlatBar, engine/sim/rollcut.go) whether the synthetic incoming bar would fill each order the plan places at the cut, by the simulator’s own rule for that bar under the run’s resolution and limit rule (at tick resolution only a market order), and then keeps each OCO group whole. Every other standalone order, GTC or with no time in force (which rests across every boundary), is re-submitted at the cut, at the checkpoint resubmit_at_cut (step 6): with the legs and before the synthetic bars, through the simulator’s roll entry (SubmitRolled, a roll leg’s submission with the GTC anchor given), which exempts it from the cross-symbol rule, so it is evaluated on the synthetic incoming bar even when another series’ bar has moved the simulator’s clock past the cut, and anchors its GTC deadline at the roll’s trade date rather than the clock’s. It is first evaluated there, as a re-established child is, and cannot fill there. The checkpoint is present on every v2 roll, between open_legs and advance, even when no order goes at the cut. A deferred order keeps everything else the roll gives a re-placed order: its outgoing attempt’s hidden cancel, its new attempt, numbered before any cancel, its record rebased, the race guard’s re-key and its update (after the synthetic bars, stamped at the cut), lost protection on a denial, and its GTC anchor at the roll’s trade date, through the clock. Under the opt-in enforce margin model it is margin-checked, as every re-submission after the bars is (Parity with the legacy profile at a roll, GLE-575, GLE-627).

Stops through the cut. A stop that the incoming contract’s cut price is already through (a buy stop at or under it, a sell stop at or over it) cannot rest as a stop: the simulator refuses a stop on its triggering side, as the exchange would. Under both lifetimes the plan sends it to the venue as the order it has become (triggeredAtCut), which is what IBKR does with such a stop once its “will trigger immediately” warning is confirmed: a stop becomes a market order, and a stop-limit its limit order. A converted stop goes after the synthetic bars under both lifetimes (under v2 since GLE-575, as a market-form order) and fills at the first real incoming bar’s open. A converted stop-limit rests from that bar under v1. Under v2, since GLE-627, one whose limit the cut price makes marketable goes after the synthetic bars too, and one whose limit is not marketable there is re-submitted at the cut, unless it is a Day, IOC or FOK order, and rests there unfilled, so either way its first chance to fill is the first real bar, as under v1. The engine reports each conversion on stderr, and the strategy sees the fill under the stop’s client id:

algo: roll ESH26->ESM26: stop "thru" at 1010 is through the incoming contract's cut price 1005.75; re-sent as a market order, as the venue would trigger it

A first-touch stop (StopTouch) may rest through and is re-sent unchanged. Under v2, since GLE-627, one at or through the cut price goes after the synthetic bars, so it fills on the first real incoming bar, as under v1. A re-attached bracket child is not converted: it is evaluated on the synthetic incoming bar, where such a stop fills at the cut, under both profiles. Under v2 the re-placed stop’s OrderUpdate names the conversion in its reason (the converted stop’s reason).

A replacement the simulator denies. Under lifetime v1, and in a direct rollAtCut call without the run’s lifetime driver, a re-submission the simulator denies fails the roll with a RollPartialFailure, which ends the run; under v2 with the driver it is lost protection, told to the strategy and the operator (Order lifetime v2 across a roll). A denied roll leg and a submit error fail the roll under either lifetime. Since I15 unit 2b (GLE-459) the failure names, in Unreplaced and in its text after the completed prefix, the labels in plan order of the orders the roll had cancelled on the outgoing contract and not re-placed on the incoming one when it stopped (an order lost earlier in the same roll included; an unlabelled order as an empty label): the protection the run leaves behind without telling the strategy. The list is nil when the roll stopped before its cancels, and when every order it was to re-place is on the incoming contract:

continuous: roll ESH26->ESM26 partial failure at step advance (completed: order_status, position, cancel_from, open_legs, resubmit_at_cut; unreplaced: day): <cause>

Known limits. The recorded limits of a roll under lifetime v2 are listed at the end of Order lifetime v2 across a roll (I15 unit 2b) and, for a roll a timer fires (unit 2c), among the known limits of Scheduled decision points. Beyond them:

  • Suppression under v1. Under lifetime v1 every attempt is 0, so the hidden cancels are keyed by client id alone. A strategy that cancels label X on the outgoing contract’s last bar and submits a replacement under the same label has both cancels hidden on the synthetic outgoing bar: the genuine cancel of the old order and the roll’s own. The goldens depend on it and the legacy profile is frozen, so it stays; v2 keys the set by label and attempt.
  • A cancel scans the book. The simulator finds the order a cancel names by scanning the working book for its broker id, so a roll’s cancels take time quadratic in the book’s size (milliseconds for a book of a few thousand orders). A performance follow-up may index the book by broker id.

Order lifetime v2 across a roll

Since increment I15 unit 2a of the order-lifetime programme (GLE-453, 2026-10-08; engine/rollown.go, engine/contlifetime.go, the executor in engine/continuous_servedloop.go and sdk/strategy/working_replace.go) a backtest under lifetime v2 runs on a continuous series, a bare root or a :cont composite, on the pb wire or stdio-csv-v2; before it such a run was refused. A v2 order goes through the series’ frame as a v1 order does: one for the logical symbol is translated onto the active contract and booked in the series’ order book, so a roll carries it; one addressed to the active contract goes as it is; any other symbol is denied with the frame’s reason (a continuous run accepts only the logical symbol "<symbol>" or the active contract "<contract>"), and its rejection cancel, stamped with the attempt, follows before the next bar. At a roll each order the engine re-places on the incoming contract becomes a new attempt, and the strategy, its working view, the race guard and kit.Controller follow the change. Unit 2b (GLE-459, 2026-10-09; engine/rollaccount.go, engine/rollaccount_types.go, Simulator.ExpireGTC and Simulator.SubmitRolled in engine/sim) made a replacement the simulator denies lost protection rather than the end of the run, settled the GTC rule at a roll, froze the order of a roll’s coincidences, gave the lifecycle trace the roll’s account and named a converted stop’s conversion in its update (below). Unit 2c (GLE-474, 2026-10-09; engine/conttimers.go, engine/contbook.go) gave the run’s timers their instants and booked an order pinned to a dated contract on its series’ logical symbol (below), completing I15. Live continuous futures stayed refused before any spawn, under either lifetime, until GLE-1385 8b let them run under v1.

A new attempt for every re-placed order. Every order the roll places on the incoming contract on the strategy’s behalf takes a new attempt under its own label: a bracket child re-established on the open leg, a standalone order re-submitted (at the cut, or after the synthetic bars for Day, IOC and FOK orders, orders the cut price would fill and their OCO groups), and each labelled, stamped pending child that an unfilled entry carries with it. The number is one past every attempt the label has used in the run and past the attempt it replaces. The engine keeps, per label, the highest attempt it has seen on any order or labelled attached order the strategy sent (a denied one, or one sent at a timer’s decision, included) and on any number a roll assigned. Numbers go in plan order, a re-submitted entry’s children right after it, so a label met twice in one roll (a strategy defect) takes two consecutive numbers. An unlabelled order, or one whose attempt is 0, has no attempt identity to replace: it is re-placed as under unit 1, with no new number and no update, and so are its children. The roll legs are the engine’s own and carry no attempt.

What the strategy receives. One OrderUpdate per re-placed order, which grants no lifecycle turn (it reports what the engine did, and there is nothing to answer):

FieldA re-placed orderA pending child it carries
ClientID, Attemptits label and new attemptthe child’s label and new attempt
ReplacesAttemptthe attempt the roll endedthe child’s attempt the roll ended
StatusWorkingInactive: it still waits on its parent’s fill
OrderRefthe re-submission’s broker reference; empty for a re-established child, which has none until the open leg fillsempty
Symbolthe logical symbol, not the contractthe logical symbol
Quantity, RemainingQuantitythe order’s quantitythe child’s quantity
ParentClientIDthe parent’s label on a re-established child, else emptythe entry’s label
Timestampthe cut instantthe cut instant
Reasonroll <from>-><to>, for example roll ESH26->ESM26; a stop converted at the cut appends the conversion (below)roll <from>-><to>

FilledQuantity, BrokerCode and OwnerID are zero. An update carries no levels, and none change: the back-adjusted frame is continuous across the roll, so the logical order the strategy sent still stands.

The converted stop’s reason. A stop the plan converted at the cut (Stops through the cut) is reported like any other re-placed order, and its update’s reason names what it went to the venue as: roll ESH26->ESM26: stop re-sent as market for a stop, and roll ESH26->ESM26: stop_limit re-sent as limit for a stop-limit, the types in the lifecycle trace’s labels. The reason is the only place the conversion is told: the update carries no type field, the working view keeps the logical stop, and the fill arrives under the stop’s client id. A pending child is not converted, so its update keeps the plain reason; the trace’s roll_account entry carries the type as converted_to.

The replaced attempt ends without a cancel of its own. The roll cancels it on the outgoing contract and hides that cancel, and with a re-submitted entry’s cancel the parent-cancelled notices of its pending children. The hidden set is keyed by label and outgoing attempt, so only the roll’s own cancels are hidden: a genuine cancel of an earlier attempt under a rolled label, from a strategy that cancels X on the outgoing contract’s last bar and submits a successor under X, still reaches the strategy. A pending child’s key is found by its label, not by its place among the entry’s attached orders.

The roll’s own cancels. A cancel the roll delivers carries its own reason, CANCEL_REASON_ROLL (11; the SDK’s CancelReasonRoll, token roll on stdio-csv-v2 and in the lifecycle trace): an order pinned to the outgoing contract, and each bracket child at a flat roll, which has no position left to protect. The pending children of a cancelled pinned entry keep PARENT_CANCELLED. The cancels the roll hides carry the reason too, so the lifecycle trace records them as roll with delivered: false, and it counts a delivered one among the unsolicited_cancels. Under v1 the delivered cancels keep explicit.

The SDK working view. An update whose ReplacesAttempt is not 0 re-keys the replaced attempt’s entry in place (applyReplacement), in this order:

  • the label’s counter passes the new attempt, so the strategy’s next submission under the label is stamped past it, whether or not the view holds the entry;
  • the Inactive children bound to the replaced generation of the parent are re-bound to the new attempt, so its fill activates them and its cancel retires them; each child’s own update, which follows its parent’s, then re-keys the child;
  • the entry takes the new attempt, the update’s ReplacesAttempt and its OrderRef, an empty one included (the old reference named the ended order), and keeps its place in the view, its SubmittedAt, a pending cancellation and the rest of its Order;
  • the update’s status and quantities apply as any update’s do: under a pending cancellation the new status is recorded underneath, as what a refusal restores.

An update naming an attempt the view does not hold creates no entry. Afterwards an event of the replaced attempt addresses nothing and an event of the new attempt addresses the entry. OnOrderUpdate runs after the view has moved, as for any update: a strategy that keys state of its own by attempt follows ReplacesAttempt there, and one that keys by label needs nothing.

The race guard. On a continuous run the guard observes every bar’s events, a roll’s included, in the strategy’s frame: a fill translated onto the logical symbol (a roll leg left out), so its positions and the admission policy’s caps read the symbol the strategy trades, and the roll’s hidden cancels left out. It re-keys each re-placed attempt in place, a re-submitted entry’s re-attempted pending children included, to the new attempt and to the broker id its events will carry (the re-submission’s own, or the open leg’s for a re-established child). The tracked attempt stays the same, with its executions, its cancellation state, the orders held behind it and its place in the admission policy’s counts, and the guard remembers the old broker id as ended, so a late event of the old physical order addresses nothing. Each re-key stands alone: a child is re-keyed even when its parent’s lookup finds nothing, and an attempt 0 is not looked up, since a lookup with attempt 0 would match any attempt under the label.

kit.Controller. The controller carries the replaced attempt’s memory (its counted windows, its activation and its cancel requests) to the new number when it meets an entry whose ReplacesAttempt names an attempt it remembers, so MaxWindows counts across the roll (The desired-order controller). The view keeps only the latest replaced attempt, so the carry needs the controller to see the view between two replacements of one order. Calling Observe at every OnBar does that, because a continuous series rolls at most once between two of its bars; otherwise the count starts afresh.

The order at the cut. At the bar on which a roll fires, in order:

  1. the outcomes deferred at the previous instant (its turn budget spent) are delivered, since they are older than the roll;
  2. the strategy’s RollNotice (when it observes rolls);
  3. the venue’s own terminations, delivered at once: under lifetime v2 with exchange calendars, the cancels of every order whose calendar instant is at or before the cut (Simulator.ExpireCalendar, inclusive; I13b, GLE-468), each TIF_EXPIRED or GTC_EXPIRED at its own instant with its basis, with the OCO_TRIGGERED siblings and PARENT_CANCELLED children its end settles; then, under --gtc-expiry ibkr-quarter, the cancels of the venue’s deadline: each unstamped order due at the roll’s trade date GTC_EXPIRED, with the siblings and children its expiry settles, in submission order (the GTC rule at a roll, below); then, under lifetime v2 when the cut comes after the outgoing contract’s expiration, the contract expiry: the contract’s remaining orders cancelled CONTRACT_EXPIRED and its position settled by a fill, delivered at once (Contract expiry (lifetime v2)); then, under lifetime v2, the race guard’s refusal of every held attempt pinned to the outgoing contract, hold_rolled, each a Denied update stamped at the cut, delivered at once in hold order and granting no turn (GLE-491, held attempts at a roll, below);
  4. the roll’s cancels on the outgoing contract, queued at the venue;
  5. the legs, when the position is not flat, the open leg carrying the re-established children under their new attempts;
  6. the re-submissions at the cut;
  7. the race guard’s re-keys (and, for a lost order, its end), then the updates of every order re-placed or lost so far, in plan order, delivered at once, then the rejection cancels of the orders lost at the cut, in plan order;
  8. the synthetic bars: on the outgoing one the queued cancels drain (the delivered ones reach the strategy, the hidden ones do not), and on the incoming one a re-established child the cut price crosses fills under its new number (since GLE-627 no order re-submitted at the cut fills there);
  9. the Day, IOC and FOK re-submissions and those of the orders the cut price would fill (since GLE-575 the market-form ones, since GLE-627 every one) with the other members of their OCO groups, in plan order; then their re-keys and updates, and the rejection cancels of those lost.

The updates precede the synthetic bars because a fill there already carries the new attempt, and the view must know it first. One quirk follows by design: the updates are stamped at the cut, while the roll’s delivered cancels, and the deadline’s, are stamped at the simulator’s clock when they were made, the outgoing contract’s last close (a calendar instant’s cancel at its instant, at or before the cut), so in delivery order the timestamps step back.

Attempt exhaustion. An attempt is a uint32, and nothing bounds the numbers a strategy stamps or the label’s high-water mark, which counts denied attempts too. When a label’s next number would pass 4294967295 the roll fails its position step before anything is cancelled, with the plan and the high-water marks unchanged, so no order is re-placed under a number that wrapped to 0, which would carry no update, no hidden cancel and no re-key. The run ends with the roll’s partial failure, and nothing reaches the strategy:

continuous: roll ESH26->ESM26 partial failure at step position (completed: order_status): continuous: roll ESH26->ESM26: order lifetime v2: the attempts of label "<label>" are exhausted: the roll cannot re-place it past attempt 4294967295

Lost protection. Since I15 unit 2b (GLE-459) a re-submission the simulator denies at a roll (a resting order at the cut, or after the synthetic bars a Day, IOC or FOK order, an order the cut price would fill or a member of its OCO group) does not end a run under lifetime v2. The order the roll cancelled on the outgoing contract is lost, and the strategy is told on the protocol it already speaks for a denied submission, with no new wire value. It receives one Denied update under the attempt the replacement was to work under, naming in ReplacesAttempt the attempt the roll ended, on the logical symbol, for the order’s quantity with RemainingQuantity 0 (nothing is working), stamped at the cut, with the parent’s label in ParentClientID and the reason roll <from>-><to>: replacement denied: <the simulator's reason>, for example roll ESH26->ESM26: replacement denied: no tick size. A re-submitted entry’s labelled, stamped pending children each follow with a Denied update of their own, under the attempt they were to take, naming their own, bound to the entry’s label. After the group’s updates comes one cancel with reason REJECTED (CancelReasonRejected) under the new attempt, stamped at the cut, as the rejection of any denied submission is delivered; the pending children get no cancel of their own, the entry’s update having retired them. An unlabelled order has no label to address, so the strategy gets no update and no cancel for it; the operator’s line and the count below still report it. No lifecycle turn is granted, nothing of the replaced attempt reaches the strategy, and the lost attempt’s number stays used, so the label’s next attempt is past it.

The SDK working view retires the entry and its inactive children on the Denied update, through the replacement path above, and the label’s counter passes the new attempt, so the strategy’s next submission under the label is stamped past it; kit.Controller sees its desired order gone and may re-submit it. The race guard ends the attempt, with its tracked children, rather than re-keying it, since nothing was placed, and remembers its venue id as ended under the label. The engine does not retry the replacement: re-placing the protection is the strategy’s decision. The lost order’s record and its pending children’s are retired from the series’ order book at the loss, so the frame tracks nothing of it. The updates are delivered in the group’s batch, in plan order with the Working updates of the orders the roll did re-place (step 7 and step 9 of the order at the cut, above), each group’s rejection cancels after its updates.

What the operator sees is one stderr line per lost order, in plan order, naming the strategy’s order type (a stop, even when the plan converted it), the attempt the roll ended and the one its replacement was to work under:

algo: roll ESH26->ESM26: lost protection: stop "sl" (attempt 1) was cancelled on ESH26 and its replacement on ESM26 (attempt 2) was denied: no tick size

and the report’s simulator: line gains roll_lost=N, only when N is above zero, as corporate_action_cancels=N and spinoffs_unmodelled=N are printed, so every other run’s line is unchanged. The lifecycle trace records the denied submit (source roll_resubmit, status denied, with the record id the simulator assigned), the rejected cancel (delivered, with an empty origin, counted among the rejection_cancels), the order’s fate lost with the reason in the roll’s roll_account record, and the loss in the summary’s roll_lost.

What still fails the roll. A denied roll leg (the position cannot leave the outgoing contract, and the bracket children ride the open leg, so a child is not lost on its own), a submit error (not a denial), and every denial under lifetime v1 or in a direct rollAtCut call without the run’s lifetime driver fail the roll with a RollPartialFailure as before, which ends the run. The failure names the orders cancelled and not re-placed in Unreplaced (A replacement the simulator denies).

The GTC rule at a roll. Under --gtc-expiry ibkr-quarter, under either lifetime, the venue’s deadline is applied before the roll reads the book, by the simulator’s own quarter-end pass run at the roll’s trade date (Simulator.ExpireGTC): every working GTC order, of any symbol, whose deadline is strictly before the roll’s trade date is cancelled GTC_EXPIRED at the simulator’s clock, the outgoing contract’s last close, where every quarter-end cancel is stamped; its OCO group settles as a fill would settle it; and the cancels are delivered before anything else of the roll, in submission order, the race guard observing them under v2. An expired order is not in the book the roll reads, so it is not rolled and not re-anchored: a roll that carried it onto the incoming contract would keep protection a live account does not have and admit a post-deadline fill, which the model forbids. An order whose deadline is the roll’s trade date is not due, since the venue cancels at that day’s close, after the cut: it is rolled and re-anchored. The pass counts each expiry (gtc_expired), none as coarse, and sweeps a date once, so the synthetic cut bars that follow, which carry the same date, sweep nothing.

The roll’s trade date is the synthetic incoming bar’s: the date on the incoming contract’s exchange clock of the instant one nanosecond before its close, which is the cut instant when the cut lies after the outgoing contract’s last close, and else that close plus one nanosecond (on ES, a cut at 00:00 CDT on 1 October, 2026-10-01T05:00:00Z, the 09-30 bar’s close, has the roll date 2026-10-01, so an order due after 09-30 expires at the roll). Every order the roll places on the incoming contract anchors its deadline there. A re-submission at the cut is anchored explicitly (Simulator.SubmitRolled), because the simulation clock still stands at the outgoing contract’s last bar when the roll places it, and at a quarter edge that anchor was one quarter early, unit 1’s recorded gap; a re-submission after the synthetic bars anchors through the clock, which the bars have moved to the roll’s date on a run of one series; a re-established bracket child anchors at its activation on the synthetic incoming bar. The rule is uniform, so the deadline of a GTC order rolled every quarter restarts at every roll and the order does not expire in a :cont backtest (What resets the anchor). Carrying the original anchor across the roll was rejected: the engine’s roll is a cancel and a new order, which IBKR anchors afresh. So an order whose deadline is the roll’s date, 2026-09-30, is rolled, anchored 2026-09-30 again, and expires under its new attempt before the first bar of 2027; one re-placed at a roll dated 2026-10-01 is due after 2027-03-31.

Since I13b (GLE-468) an order the exchange calendar stamped with its instant, a GTC order with the quarter’s final trading close or a Day order with its session’s close, is not this pass’s: the roll’s calendar sweep, which runs first (Simulator.ExpireCalendar at the cut, inclusive), ends it when its instant is at or before the cut, GTC_EXPIRED or TIF_EXPIRED at that instant with its basis, listed among the roll account’s expired and not re-placed, and leaves it to be rolled and re-anchored when its instant is after the cut: the cut itself decides, where the date rule reads the roll’s trade date (Calendar cancellation instants (lifetime v2)).

The coincidence order. When a GTC quarter-end, a contract expiry and a roll fall on one date they go in that order: the venue’s quarter-end pass (since I13b the calendar sweep at the cut, then the trade-date pass); then contract expiry, in the slot I15 unit 2b froze and I14 unit 2a (GLE-479) filled, after the GTC pass and before the book is read, its cancels delivered after the GTC ones, so an order due under both reasons is GTC_EXPIRED (the venue’s clock event precedes the contract’s own end); then, since GLE-491, the roll’s pass over the race guard’s held attempts, so an attempt both the expiry and the roll would refuse is hold_contract_expired and the roll’s pass finds nothing pinned; then the roll, which does not see an expired order or position. The trace of the coincidence is deterministic: two runs of one input marshal to the same bytes, and the roll’s bar records the GTC cancels, the expiry record and the expiry’s cancels and closing fill, the roll record, the cancel requests, the re-submissions, the synthetic bars’ cancels (a hidden one recorded with delivered: false) and the roll_account record, in that order. What the strategy hears when a GTC order due at the roll’s date coincides with the roll of a resting order and a pinned one: the due order’s GTC_EXPIRED cancel, then the resting order’s Working update under its new attempt, then the pinned order’s ROLL cancel. When the outgoing contract has also expired before the cut (a late roll), the strategy hears instead, after the GTC cancel and its OCO sibling’s OCO_TRIGGERED one, the resting order’s and the pinned order’s CONTRACT_EXPIRED cancels; the roll then re-places nothing, and the account’s expired list carries all four (Contract expiry (lifetime v2)).

The roll account. After its last step, under both lifetimes when the trace is on, a roll writes a roll_account record: its trade date, the position rolled, expired (the cancels of the deadline’s pass and, at a late roll under v2, of the outgoing contract’s expiry, with the reason label and the OCO trigger) and orders (every order the plan found, in plan order, with its class, its fate, the attempt its replacement works under, the broker id its events carry, whether it went at the cut, the type a converted stop was re-sent as and a lost order’s reason), and, since GLE-491, held_refused when the roll refused a held attempt (its client id, attempt and the outgoing contract it was pinned to, in hold order; omitted otherwise); and the summary counts the orders re-placed, lost and expired at the rolls and, as roll_held_refused, the held attempts they refused (The lifecycle trace schema). Unit 2a’s roll record, written before the cancels with the plan’s classes, stays. A v1 roll’s record accounts for its dropped children, with every attempt 0 and nothing at the cut.

Parity with the legacy profile at a roll (GLE-575, ruled 2026-10-21; GLE-627, ruled 2026-10-29). Under GLE-453’s rule a GTC or untimed market order still working at the cut, and a stop the cut price is through, filled at the cut under v2: on the synthetic incoming bar, at the served in_at_cut, stamped at the cut. Under v1 they fill at the first real incoming bar’s open. The synthetic bar is priced at the served pair, the contemporaneous price at the cut, whatever the run’s session. On an rth or custom-window run the cut is a Globex instant outside the regular session: Sunday’s 17:00 CT open for the recent ES and ZN cuts, and the 15:30 CT re-open for the 2011 ES cuts. So the v2 fill was at a price no bar of the run carries. One measured ES market exit across the H20 to M20 roll sold at 2683.75 at the cut on 15 March 2020. Under v1 it sold at 2501.25 at the regular-session open of the 16th: 9,125 USD on one contract.

Strategies whose legacy Day orders became GTC intents under v2 therefore departed from their legacy fills at such rolls. The owner ruled that an order reaching the incoming contract as a market order waits for the first real incoming bar under v2 too (Roll execution at the cut, the single-window orders). Over the archive’s continuous runs measured for the ticket, v2’s fills now equal v1’s at every roll where they had parted.

The owner widened the ruling on 2026-10-29 (GLE-627): under v2 no order the roll re-submits fills at the cut price. The ruling rested on one reason, a fill at a price no bar of the run carries, and three more cases share it, so they wait for the first real incoming bar under v2 too:

  • a GTC or untimed limit the cut price makes marketable;
  • a converted stop-limit whose limit the cut price makes marketable;
  • a first-touch stop at or through the cut price.

An OCO group goes whole, so it cannot fill twice across the two windows (a sibling at the cut and a member after the bars, which before GLE-627 happened for a Day member with a GTC sibling and for a market-form member with a marketable sibling), nor pick a different member from v1’s on a same-bar tie on the first real bar. Re-measured over GLE-575’s archive runs, no fill moved and every v1 output is unchanged: none of the three cases occurs there, and the one split group found, a stop entry pair whose member at the cut could not fill there, now moves whole after the bars with the same fills (its lifecycle trace records the member’s re-submission after the bars). Constructed fixtures of each case, on a regular-session run and on one whose first incoming bar holds the cut, give v2 the same fills as v1 under every time in force.

On an eth run the first incoming bar contains the cut instant, so a deferred order’s first chance is that bar, at that bar’s rule (a market order at its open, a limit or a first-touch stop at the open or its level); the served cut price is a fill price under neither profile. The difference from the former v2 fill is small there (GLE-575 measured 12.50 and 46.875 USD) and large on an rth run, where the cut lies outside every bar; one rule covers both. The roll legs fill, and a re-established bracket child is first evaluated, at the cut price under both profiles.

Known limits.

  • An order resting at the cut is submitted before v1 submits it. Under v2 a re-submission the cut price would not fill goes at the cut, so it is submitted before the roll’s re-established children activate and before the orders after the bars. When it and one of those fill on the first real bar, the simulator, which emits a bar’s fills in submission order, may report them in another order than under v1; the fills themselves are the same. An OCO group is not affected, since it moves whole.
  • A trailing stop resting at the cut. Under v1 a trailing stop is submitted after the synthetic bars, so it is anchored at the cut price. Under v2 it is re-sent at the cut, where the synthetic incoming bar cannot fill it, and two runs anchor it elsewhere: on a tick-resolution run, where the bar’s empty trade window evaluates only market orders, it is anchored at the first real print; and on a run of several series where the incoming contract’s last price was already known, it is anchored at that price and ratcheted at the cut. At bar resolution on a run of one series both profiles anchor it at the cut price.
  • A lost order’s events carry no OrderRef. The re-submission returns no broker id on a denial, so the lost order’s Denied update and its REJECTED cancel carry none, and a strategy or a reviewer reconciling by reference cannot match the loss to its venue record. The trace’s submit record, written before the denial returns, keeps the record id the simulator assigned. A recorded cost of reusing the plain denial protocol.
  • The roll’s trade date is a calendar date. The synthetic incoming bar carries no session block, so the roll’s date is the date on the exchange’s clock of the instant before its close (GLE-1342; it was the UTC date), while a session-keyed real bar anchors on its session.trade_date. The two agree at a weekday settlement cut, where the served schedules cut; the engine’s fixtures’ Sunday cut (2026-03-08T22:00Z, Sunday 17:00 Chicago) shows the gap, a roll date of 2026-03-08 against the CME trade date 2026-03-09. A cut on a quarter-ending Sunday (2029-09-30 is one) would anchor a re-placed order’s deadline a quarter early. Moot for the served schedules; recorded.

Timers at a roll (I15 unit 2c, GLE-474, 2026-10-09). A continuous run’s timers fire at their instants (Scheduled decision points). Under v2 the series’ loop bars carry their original contract bars’ ts_open, through one builder (ct15LoopBars) for the served loop and the production fetch, and the coarse check’s venue universe holds each series’ logical symbol, which the loop bars carry, so the check reads them at all: a production venue lists the series’ contracts, under which it found no bar to check. A v1 run’s loop bars stay close-only, so the KBD masters are unchanged. Instants happen in order. Before a timer’s TimerFired the loop’s hook fires every frame’s rolls whose cut is strictly before the instant, in cut order across the series, with the simulator’s clock still at the outgoing contract’s last close, exactly as the loop fires them ahead of a bar, so the roll’s synthetic bars, re-submissions and GTC anchor see the clock they see before a bar, and the decision sees the incoming contract as the active one; the roll’s delivered cancels are stamped at that clock, the timer’s own orders at the instant. A timer at the cut exactly decides first, since a roll is due on the first clock strictly after its cut: its order goes on the outgoing contract, and the next bar’s roll re-places it as a new attempt (update X/2 working replaces 1). A roll that fails in the hook returns its error as is, before the clock moves and before any TimerFired. Under v2 a continuous run’s Init window starts at its first loop bar’s open, as a plain run’s does, where under v1 it starts at the first close, and the calendar’s window widens to it (Engine side).

Pinned-order exposure (I15 unit 2c). The race guard and the admission policy book an attempt on the logical symbol of the series whose chain holds its contract, the chain and not the active contract (The engine race guard). A pinned order’s reservation therefore counts in the logical symbol’s exposure, its working-order count and its blockers from its admission until the roll’s CANCEL_REASON_ROLL cancel, delivered and observed by the guard through the roll’s delivery, ends the attempt: under --max-position 3, with a buy of 2 pinned to ESH26, a logical buy of 2 is refused cap_exposure: the position on fut:XCME:ES could reach 4 with this order, beyond the limit of 3 and a buy of 1 admitted; after the roll cancels the pinned order, a buy of 2 is admitted beside the re-placed buy of 1, and a further buy of 1 refused with the same text. A guard reason and a policy reason name the booked symbol, the logical one, for a pinned order too; the updates and denials the strategy receives keep the order’s own symbol. An unlabelled pinned order is tracked until the run ends, as any unlabelled order is.

Contract expiry at a roll. Since I14 unit 2a (GLE-479, 2026-10-09) the slot frozen above is filled. A series’ contract is left to its roll: the served schedule rolls before expiry, so on a plain bar the expiry pass does not touch a contract a continuous series holds. When a roll’s cut comes strictly after the outgoing contract’s expiration (the schedule rolled late), the outgoing contract expires in that slot, after the roll’s GTC pass and before it reads the book: its working orders, the logical ones translated onto it included, are cancelled CONTRACT_EXPIRED and listed in the roll account’s expired, its position is settled by one identity-less fill the strategy hears on the logical symbol, and the roll finds a flat book and re-places nothing (the strategy re-places what it wants after the notice). A series’ active contract still unrolled at the run’s end expires there. Both are reported as the schedule anomalies they are: an operator line, late: true on the trace’s expiry record and expiry_unrolled=N on the report’s simulator line (Contract expiry (lifetime v2)). A cut exactly at the expiration is in time, and a contract the series rolled out of in time is left alone.

Held attempts at a roll (GLE-491, 2026-10-11). A roll cancels every working order pinned to the contract it leaves (the plan’s pinned class, reason roll). An attempt the race guard holds (admitted but not sent, waiting behind a pending cancellation; The engine race guard) is not at the venue, so that cancel does not reach it, and before this pass it was released after the cut: on a run whose ranks share the contract, routed to the rank whose active contract the outgoing contract had become while its exposure stayed booked on the rank that placed it, so the guard’s book and the fill’s attribution parted ways; on a lone rank, through the plain path onto the outgoing contract, which the series had left for good. The roll now gives held attempts the law its working orders have (engine/rollhold.go): in the order_status step, after the venue’s terminations and the contract-expiry pass and before the book is read, every held attempt whose order names the outgoing contract is refused with its own reason, hold_rolled (the SDK’s GuardRolled; the reasons), one Denied update per attempt carrying the order’s own symbol and quantity, no OrderRef and nothing remaining, stamped at the cut as the roll’s other updates are, delivered at once in hold order, each granting no turn, before the roll’s own cancels reach the guard, which would otherwise release the attempt onto the contract the series left. The attempt ends with its children and reserves nothing more on any book, so after the cut no rank’s exposure, working-order count or blockers count it, and it fills nowhere. The pin is the held order’s symbol, not the attempt’s book: after a cut the book the contract maps to has moved while the attempt kept the book it was admitted with. An attempt held on the series’ logical symbol is not pinned and stays held behind its blocker, which the roll re-places under a new attempt; so does one pinned to the incoming contract, or to any other live contract. The pass runs on every roll, a lone rank’s included, since the lone-rank escape is the same defect; the owner may narrow it to shared frames with a one-line guard at the roll’s call site, which would reopen that escape. At a late roll the expiry pass refuses first, so an attempt pinned to a contract that has also expired is hold_contract_expired (Contract expiry (lifetime v2)), and on a shared chain that pass too refuses by pin, naming the contract. The operator sees the guard’s denial line, algo: order "<client id>" (<contract>) from instance <label> denied: hold_rolled: ...; the roll’s roll_account record lists each refused attempt under held_refused and the summary counts them under roll_held_refused, both omitted when empty, still algolang.lifecycle/1; a guard denial is not a submit record, so denied stays 0. A backtest holds no attempt today (the simulator confirms cancels at once), so every existing run, single-rank runs and every golden included, is byte-identical: the pass acts where a venue leaves a cancellation pending, as a live one does. v1 has no driver and no pass: a two-rank v1 roll cancels its pinned working orders as before and delivers no update.

Unchanged. Lifetime v1’s strategy-facing events are byte-identical: no attempt is assigned, no update is sent, a denied replacement fails the roll, the roll’s delivered cancels carry explicit and the hidden cancels are the client ids v1 always hid. With --gtc-expiry ibkr-quarter, which the default never leaves off, the deadline’s pass at a roll and the roll’s anchor apply under v1 too, since the model’s contract is the same under both lifetimes; with --lifecycle-json a v1 roll writes its roll_account record. A v1 run’s loop bars carry only their close, so its Init window and the calendar’s are as they were. The KBD masters and every golden are unchanged. Live continuous futures stayed refused before any spawn under either lifetime until GLE-1385 8b (Continuous futures in live mode).

Held rank

marketfeed elects every roll on the front (the nearest-expiring contract) but may hold a contract behind it, and the served schedule discloses which: held_rank 0 is the front (F), 1 the contract after it (B1), 2 the one after that (B2). Eight roots hold a deferred rank by design, because their front month is illiquid or settles inside the month: SR1, SR3, ZQ, ALI, HRC, DA and CSC hold B1, and CB holds B2.

The engine follows the served contract identities whatever rank they hold (GLE-387): the composite’s bars are the held contract’s, bar.ActiveContract names it, orders on the logical symbol go to it, and each roll moves the position from the outgoing held contract to the incoming one at the served seam pair. Under B1 the outgoing contract at a roll is not expiring: it becomes the new front. On fut:XCME:SR3 the March 2019 roll moved the position from SR3H19 to SR3M19 at the two contracts’ 15 March settlements (97.57 and 97.595), while SR3Z18 was the front. A schedule from a producer that predates held_rank is refused (HELD_RANK_UNDISCLOSED: the composite consumer needs a schedule-v2 lineage).

A deferred run says so: the run report prints continuous: fut:XCME:SR3 holds B1 by its served schedule (the contract after the front), result.json carries HeldRank (F, B1, B2) for every continuous run, the HTML report’s header table shows it, and the manifest pin records ;rank=B1. make roll-agreement ROOT=fut:XCME:SR3 (or any root) checks that a run executes exactly the served schedule’s cuts and pins its rank; it passes on ES (F), SR3 and ZQ (B1) and CB (B2).

Each held contract on its own grid (GLE-412). A deferred holding may hold a contract whose tick differs from the root’s. In the GLBX definitions of 16 March 2026: - ZQ ticks 0.0025 only in its nearest contract and 0.005 beyond. - SR3 ticks 0.0025 only in its five nearest contracts, serial months included. Its B1 quarterly (SR3M26, held behind SR3H26) therefore ticks 0.005.

So ZQ and SR3 B1 runs both hold every contract on twice the root’s 0.0025, and before GLE-412 their slippage was half the real tick.

On a deferred schedule the engine asks the adapter for each held contract as of its span’s start (InstrumentInfoAt, served from the definitions by marketfeed since GLE-405) and uses the answer in three places: - The simulator fills and slips the contract on its own tick. - The strategy sees it through ctx.Instrument(ctx.ActiveContract(sym)): tick and its source, margin, expiration. kit.Tick on the logical symbol still answers the root’s tick. - The run report names the contracts off the root’s tick: continuous: fut:XCBT:ZQ holds contracts on their own tick (the root's is 0.0025): ZQJ26 0.005, ...

A front holding keeps the root’s grid and asks nothing. A held contract the adapter gives no answer for stays on the root’s grid, and the report says so rather than letting it pass for a contract on the root’s tick: continuous: fut:XCBT:ZQ has no instrument answer for held contracts ZQH19, ZQJ19, filled on the root's grid (tick 0.0025).

The simulator keeps one grid per contract. Two series can hold the same contract on different grids: a front series and a B1 series of ZQ both hold ZQH26, the first on the root’s 0.0025 while it is the front, the second on its own 0.005 while it is deferred. The run then fills, slips and describes the contract on the coarser tick, whose prices lie on the finer grid too, and the report names it: continuous: ZQH26 is held on different grids by different series; the run fills, slips and describes it on tick 0.005, point value 4167.

TestGoldenRatetrendHeldContractsSlipOnTheirOwnTick, under make test-golden, checks the grid on the archive. It runs ratetrend on ZQ over the first half of 2019, once without slippage and once with one tick of it, and requires the same 16 fills (12 of them roll legs), each exactly 0.005 worse in the second run.

The front a deferred contract is held behind (GLE-412). Each deferred span names its front (RollScheduleSpan.front, disclosed by marketfeed since GLE-405). It appears in four places: - The strategy: ctx.HeldFront(sym) returns the front of the latest roll notice, so it is known from the run’s first roll. Roll notices go only to a strategy that implements OnRoll. - The roll notice: RollNotice.front, an engine code like from and to. - The continuous audit: the roll record’s front. - The manifest: each forward adjustment’s front, checked by the manifest’s self-check.

A front holding has no front, so the audit and the manifest stay byte-identical to before.

The ratetrend example logs both facts at each change of the held contract. With make run-ratetrend on SR3, 2019 to 2026, against the archive:

[ratetrend] INFO: ratetrend: 2026-03-16T21:00:00Z holds SR3M26 (was SR3H26)
[ratetrend] INFO: ratetrend: 2026-03-16T21:00:00Z SR3M26 is held behind the front SR3H26, tick 0.005
...
  continuous: fut:XCME:SR3 holds B1 by its served schedule (the contract after the front)
  continuous: fut:XCME:SR3 holds contracts on their own tick (the root's is 0.0025): 0.005 on 31 contracts, SR3H19 to SR3U26

With make run-ratetrend RATETREND_SYMBOL=fut:XCBT:ZQ, every month’s roll holds the next month behind the front:

[ratetrend] INFO: ratetrend: 2019-01-16T21:59:31Z ZQH19 is held behind the front ZQG19, tick 0.005
...
  continuous: fut:XCBT:ZQ holds contracts on their own tick (the root's is 0.0025): 0.005 on 93 contracts, ZQG19 to ZQV26

Past four contracts the report line counts them per tick, from the first to the last in schedule order. Four or fewer are listed by name.

Known limit: the strategy does not receive the rank on OnRoll; the run report, result.json and the manifest pin carry it.

Asking for a held offset. The served rank is the feed’s choice for a root. A request can also name an offset: fut:XCME:ES:cont:ofs=B1 asks for the composite that holds the contract after the front, whatever the root holds by default. The engine’s request grammar (GLE-399) reads ofs=F, B1, B2 or B3, case-insensitive in the value, at most once, under the lower-case key ofs, and renders a rank back onto a composite symbol the same way (F, the default, is rendered as no qualifier). Any other value is refused with invalid ofs= "B4" (valid: F, B1, B2, B3), the text marketfeed’s symbol parser uses. algo run runs such a series, and a strategy may declare one beside the front, since GLE-410: see Contract curves. The run grammar takes B1, B2 and B3 and refuses F, which renders as the plain composite.

strategies/demo/go/ratetrend is a worked example: a moving-average trend on continuous SR3 that logs the contract it holds, each roll into the next one, and the held contract’s implied rate from its raw close (the back-adjusted close is shifted by the roll gaps, so 100 - close would not be a rate any contract traded at). Since the order-lifetime programme’s I21 (GLE-467) it declares optional lifetime-v2 support, and cf21_conform_test.go beside it runs it under both profiles over the conformance suite’s sine on a plain symbol with short averages, nine fills equal under each (Conformance under both lifetimes). make run-ratetrend:

[ratetrend] INFO: ratetrend: 2019-03-18T20:15:44Z holds SR3M19 (was SR3H19)
[ratetrend] INFO: ratetrend: 2019-05-23T20:18:40Z SR3M19 raw=97.5950 rate=2.4050 fast=97.8131 slow=97.8041 pos=0 target=1
[ratetrend] INFO: ratetrend: fill ratetrend_1558642720000000000 buy 1 fut:XCME:SR3 @ 97.7975
[ratetrend] INFO: ratetrend: 2019-06-17T19:20:58Z holds SR3U19 (was SR3M19)

The fill is reported on the logical symbol at the adjusted price; the engine executed it in SR3M19, the contract after the front (SR3H19 had become the front at the March roll).

Where the schedule ends

The feed closes a schedule’s last span when it cannot continue the chain (an unmeasurable seam, or a lapsed front without a listed successor); only the true current front stays open. The composite carries no bar past a closed span, and a bar whose tagged span does not hold its close is refused (BAR_OUTSIDE_SPAN), as is one tagged with a span after the anchor’s holder (BAR_AFTER_HOLDER); the engine invents no roll. A run end beyond the feed’s newest bar is clamped to that bar plus one bar of the run interval and recorded (run_end_clamped); a start not before the clamped end is EMPTY_WINDOW.

The served constants are relative to the holder of the anchor, and the anchor is the (clamped) run end. When the end falls in a span whose contract has no bar yet (past a cut), that holder would be an untraded contract, so the bars are fetched again anchored one nanosecond after the last served bar’s close, and the last traded contract carries the identity (noted as adjustment anchor moved ...). One boundary stays (ER1 panel): when the last traded bar closes exactly at its span’s end and the next contract has no bars, the moved anchor, one nanosecond after that close, lies in the next span, so the untraded incoming contract stays the holder and the identity contract. An explicit anchor cannot sit before the request end, and the end must lie after a bar’s close for that bar to be served, so no anchor at the close itself can be asked for. The run is still consistent: the last traded contract carries the constant of the seam into the untraded span, the manifest anchors on the untraded contract, and every bar’s constant equals its span’s relative to that holder.

A span the feed marks provisional (unsealed) is served and noted. A held contract with no bars inside its in-window span fails the run (SPAN_WITHOUT_BARS).

Fetch plan and caching

A continuous run makes two wire reads in the common case: a schedule probe anchored at the run end (the generation, the feed’s newest bar and the snapshot token of that state under that anchor), and one composite BARS fetch over the series’ window on the run’s clock (the session composite at 1d/1w, epoch buckets otherwise), pinned to the probe’s generation and token. The feed folds the method and the explicit anchor into the token, not the window, the cadence or the session, so bars and schedule anchored alike carry one token and the probe is the build’s schedule. A clamped or re-anchored end moves the anchor: the bars are then fetched without a token pin (a re-anchor adds a second BARS fetch) and the schedule is read once more, pinned to the bars’ token under that anchor. No dated contract is fetched on its own, there is no seven-day tail past a span and no pre-start roll decision to prime. The strategy’s warm-up (GLE-393) is one more read of the same composite from the warm-up start, under the first build’s snapshot pins; see “Continuous run conventions”.

A token-pinned composite fetch is served through the Level-1 series cache under the snapshot token and the explicit anchor (GLE-324): the token names the served state, so an entry serves one state’s bars only into a run pinned to that state, and an answer that comes back under another token than the one pinned is returned as served and not written. A clamped or re-anchored fetch pins no token and is read live, as is every schedule read (a few kilobytes; the generation and the token are its freshness signal). There is no Level-2 continuous cache: the build takes the served bars as they are, and the former cost of re-applying an adjustment to prove a cached build went with the adjustment.

degradation.json for schedule records

On a run of several series each record names its series in series (the series label, fut:XCME:NQ@1d); a single-series run’s records carry no series. A composite run’s degradation.json holds, in this order: served_roll_schedule notes (an adjustment anchor moved by a re-anchor, a bar straddling a cut, a served degradation flag restated, unsealed in-window spans); run_end_clamped (earliest the clamp limit, latest the configured end); degraded_roll_seam for each traded degraded seam, present only under --accept-degraded-seams since the run is refused otherwise (a refused run’s file holds the one degraded_roll_seam_refused record instead, naming the root and the seam, written before the run stops; see Served seams); and the feed’s own degradation flags, filtered to the traded contracts and the run window, with their kinds verbatim (interior_gap, seam_session_gap, dead_month, missing_head_sessions, coverage_incomplete, seam_fallback, expiry_conflict, missing_expiration, and whatever else the feed serves), contract as the engine code (ESM26; empty for a root-wide flag), the flag’s detail as the note, and its interval as earliest/latest (plus one gap_spans entry when both bounds are set). The engine-side scans of the per-contract path (the adapter coverage record, interior_gap_engine, the engine’s own seam_session_gap and missing_head_sessions) were deleted with that path in ER5: the served flags replace them. These records use the same fields as coverage records; their complete is always false and means nothing for them: it is a coverage claim, and only coverage records make one.

The retired local election

The engine’s own roll election (continuous.Build, engine/roll) and local adjuster (engine/contadjust), which elected rolls and adjusted bars inside the engine until GLE-270 and GLE-323, were deleted in ER5 (GLE-327) together with engine/symbols, the registry’s roll block and the per-contract orchestration. The reference text that described them (session identity, warmup replay, the calendar backstop, roll placement within the day, seam measurement, the positions not adopted from mf-view and the open engine considerations of the July 2026 parity investigation) is in this file’s history at commit b209cc0.