# Release notes

Source: https://docs.tradefloor.dev/release-notes.html

> Every release and what it changed. An untraded run that names its preset replays exactly under later versions, and one that took the default does not.

An untraded run that names its preset replays exactly on every later release. A run that used the default preset replays only on releases with the same default, so each section below names the preset that moved. A traded run replays exactly on the release that recorded it, and one recorded before 0.8.5 matches only up to its first trade. The full history is in the library's [CHANGELOG.md](https://github.com/simoncoombes/tradefloor/blob/main/CHANGELOG.md).

## 0.11.0

2026-11-03

pt-v22 is the default model. It lists contracts beside the stocks: index futures with a night session, policy-rate, term-rate and oil futures, and American options on every name. An agent trades them by symbol in whole contracts, and exercises an option at a close with `tf.Exercise` ([Futures](https://docs.tradefloor.dev/futures.html), [Options](https://docs.tradefloor.dev/options.html)). Over 21 years pt-v22 passes 190 of the 190 long-run criteria that count toward its grade, and reports 41 more beside them, five of them outside their marks ([How it is measured](https://docs.tradefloor.dev/how-its-measured.html)).

Margin is set at every close ([Margin](https://docs.tradefloor.dev/margin.html)). A future is margined from a risk scan and pays its move to the day's settlement mark in cash. A name's options and its stock are margined together, as a broker's portfolio margin is: the worst loss over ten moves of the name up to 15% either way, and at least 0.375 dollars a share for each option. An order that would leave equity under the initial margin is refused with `MarginError`. A close under the maintenance level makes a call due by the next open. If equity isn't back at the initial margin then, or the close left the account below zero, the account's contracts and its options' stock are sold at the market.

`Scenario.load("recession_2008")` adds the 2007-09 recession, with the VIX following the shape of the real 2008-09 VIX. `tradefloor.contracts.explain_move` says why a contract's price moved, and a strategy spec can hold the front index future as a hedge. [What's new](https://docs.tradefloor.dev/whats-new.html) has the detail.

Some changes break code written for 0.10. A run that leaves `model` out now gives pt-v22's market, so any run that used the default gives a different one; `model="pt-v21"` keeps 0.10.2's, and every preset replays as it did. On the default an agent's observation carries the contracts, so the payload is now version 3. The Rust crate's API only grows.

## 0.10.2

2026-10-09

A patch release for programs that host the engine, with no coefficient, preset or default changes. pt-v21 stays the default, and every known-answer digest is 0.10.1's, so a run replays exactly as it did on 0.10.1.

A snapshot restored onto an engine rebuilt on a later day's companies now continues bit for bit. From pt-v19 the VIX's anchor is derived from the roster an engine is built on, and the snapshot did not carry it, so the rebuilt engine's VIX parted from the original's at its next close. Snapshots now carry `vix_anchor`, and ones written before still restore.

A host can write each company's share count, for buybacks and share issues, with `Engine.set_shares_outstanding`. Each market cap is reset at the price standing, and everything the engine weights by capitalisation reads the new counts.

A host can raise the VIX's target without writing the VIX. `Engine.set_vix_target_premium` adds a premium in VIX points that fades on a half-life the host chooses, and `Engine.set_vix_target_floor` holds the target at or above a level until it is cleared. The engine's own reversion carries the VIX to the raised target, where a one-off write of the VIX reverts within days ([Embedding the engine](https://docs.tradefloor.dev/embedding.html)).

The snapshot and the state hash carry each new input only once a host has used it, so saves and hashes from a host that never calls them are unchanged.

## 0.10.1

2026-10-06

A library and documentation release with no coefficient or default changes. pt-v21 stays the default, and every known-answer digest the Python package checks is 0.10.0's, so a run replays exactly as it did on 0.10.0.

Building the same pt-v21 market twice is now quick. The engine keeps the last 16 builds that played the market's two years of prehistory, and a later build from the same seed, roster and model is a copy of the first, the same engine to the bit, in about 0.2 milliseconds. `Engine.set_opening_cache_capacity` sizes the cache, and `Engine.opening_cache_info` reports what it holds.

Two realism readings changed. The one-year table now reads the index's return and its falls of 3% or more over 360 seeds, as the long-run criteria do, and pt-v21 has all 19 statistics inside their bands. The two-year panel grades all 15 of its statistics, with a new band for how long high correlation lasts ([How it is measured](https://docs.tradefloor.dev/how-its-measured.html)).

For Rust hosts that drive the engine themselves there's a new guide, [Embedding the engine](https://docs.tradefloor.dev/embedding.html), and a close that takes the host's economic shocks, `Engine::close_day_with_shocks`. `EngineRngState` saves its ten random streams by stream id, not in the order the struct declares its fields, so a host that packed the fields in declaration order has the `news` and `volume_idio` streams swapped in every state it saved. Swap the two five-word blocks once when loading such a state, or use the new `to_named_words` and `from_named_words`.

The browser build's `Sim` now numbers its days as `run_days` does. Before 0.10.1 every day of a `Sim` was day 0, so on pt-v21 its earnings and dividend calendars never moved. A negative `crisis_epicentre_extra` is now refused.

## 0.10.0

2026-10-05

pt-v21 is the default model. It's pt-v20 with 104 dials moved, and it passes all 40 long-run criteria ([How it is measured](https://docs.tradefloor.dev/how-its-measured.html)). Any run that used the default gives a different market, and the known-answer digests are re-based. pt-v20 and the older presets keep their values, and a run that names one replays exactly. [Default market model](https://docs.tradefloor.dev/default-model.html) covers what the new model adds.

This release adds populated mode. `tf.Population` puts background traders in the book alongside your strategy. Pass it as `population=` to `tf.evaluate`, `tf.World` or `tf.Engine` ([Populated mode](https://docs.tradefloor.dev/populated.html)). Isolated mode is still the default and hasn't changed.

The MCP server can run any shipped preset, keep a market open between calls as a session, and run a population on request. On pt-v21 each asset in the observation payload also has `dividend` and `next_earnings_in_sessions`, so the payload is now version 2. Recordings made on version 1 still replay.

Some changes break code written for 0.9. Import the ten engine internals deprecated in 0.9.0 from `tradefloor._core`, since they're gone from the top level. MCP results and run manifests no longer have the old `pretium_version` key, and `tradefloor_version` holds the same value. A checkpoint written by 0.9 won't resume on 0.10. Building a pt-v21 engine takes about 1.5 seconds for 20 names, because the market plays two years of history before day 0. From 0.10.0 the Rust crate follows semver, and its structs and enums are `#[non_exhaustive]`.

## 0.9.1

2026-10-03

A patch for the MCP server. The known-answer digests are 0.9.0's and pt-v20 is still the default, so runs replay exactly as before.

All thirteen tools have a title, annotations and a description. The description says when to use the tool over its nearest sibling, what it costs and what it returns. `run_stress_scenario` takes `fork_day`. Both markets run together up to that day and the scenario starts there, so the difference between them is the scenario's effect on one shared history ([LLM adapters and MCP](https://docs.tradefloor.dev/api-integrations.html#the-mcp-server)).

## 0.9.0

2026-10-03

This minor release changes the library and leaves the model alone. The known-answer digests are 0.8.8's and pt-v20 is still the default, so runs replay exactly as before. It adds API and refuses some input that 0.8.8 accepted. A patch on the 0.8 long-term support line may do neither, so the 0.8 line continues alongside it ([Support policy](https://docs.tradefloor.dev/support.html)).

`Engine.restore_state` refuses a snapshot with a missing field, an unknown field or a malformed value, and names the field. A refused restore leaves the engine as it was. Snapshots carry `state_schema`. Those written by 0.8.5 to 0.8.8 restore as before, and earlier ones are refused.

`tf.fair_value(..., model=)` matches the engine's valuation to the bit. The new `Engine.fair_values()` returns each name's fair value as the next tick starts from it. `Scenario.starting_at(day)` and `World.apply(scenario, at=day)` start a packaged scenario on a chosen day. The new switch `order_flow_depth_law`, 0 on every preset, divides order-flow impact by a name's depth once instead of twice ([Model parameters](https://docs.tradefloor.dev/parameters.html)).

Ten engine internals, such as `apply_mispricing` and `check_rate`, warn when you read them from the top level. Import them from `tradefloor._core`. They stay at the top level until 0.10.0 at the earliest, and `tradefloor._api` lists the tier of every top-level name ([API index](https://docs.tradefloor.dev/api.html#complete-index)).

## 0.8.8

2026-10-03

A patch on the 0.8 long-term support line. The known-answer digests are 0.8.7's and pt-v20 is still the default, so runs replay exactly as before.

tradefloor is now in the MCP Registry as `io.github.simoncoombes/tradefloor`. A client can start it with `uvx --with "tradefloor[mcp]" tradefloor mcp`, and the new `tradefloor mcp` command runs the same server as `tradefloor-mcp`. [Local MCP server](https://docs.tradefloor.dev/mcp-local.html) has the setup.

## 0.8.7

2026-10-03

A text-only patch on the 0.8 long-term support line. The known-answer digests are 0.8.6's and pt-v20 is still the default, so runs replay exactly as before.

The documentation inside the package was rewritten for users. Each entry in [Model parameters](https://docs.tradefloor.dev/parameters.html) now says what the coefficient does, its units and which presets carry which value. The gap descriptions in the published envelope, the reasons `score` gives for a row it can't read, and several docstrings were rewritten in plain terms too. A few stale claims were corrected along the way. A test now checks every value stated in a parameter's description against the preset table.

## 0.8.6

2026-10-01

A patch on the 0.8 long-term support line, with no coefficient, default or trajectory changes. The known-answer digests are 0.8.5's and pt-v20 is still the default, so runs replay exactly as they did under 0.8.5.

`tf.envelope.check()` now says why it refuses a sector-concentrated roster on pt-v20. The four-mix roster run was repeated on pt-v20 on seeds 101 to 130, at 252 and 504 days. At 252 days every mix held every shape row the bands can grade. At 504 days the S&P-like and technology-heavy mixes put the correlation of volume with the size of a move at 0.6367 and 0.6332, over the ceiling of 0.63, and the balanced roster reads 0.6266. The refusal and the `roster-concentration` gap in [How it is measured](https://docs.tradefloor.dev/how-its-measured.html#the-named-gaps) quote this run, which is in the library as `measurements/roster-shapes-pt-v20.json`. A question that passes `preset="pt-v19"` keeps the pt-v19 grant.

## 0.8.5

2026-10-01

### Long-term support

0.8.5 starts the first long-term support line. The 0.8 line gets bug and security fixes for 24 months, and a fix ships in a 0.8.x patch only if it leaves every known-answer digest unchanged. The policy is the library's [SUPPORT.md](https://github.com/simoncoombes/tradefloor/blob/main/docs/SUPPORT.md), and [Support policy](https://docs.tradefloor.dev/support.html#release-checks) lists the digests.

### pt-v20 as the default

A run that used the default won't replay against 0.8.1. Pass `model="pt-v19"` to keep that market. A run that names its preset replays exactly, and you can still select any shipped preset from pt-v1 on.

On pt-v20 the tape follows the model price. A stock's own news and the market's plain shocks move fair value for good, fear marks fair value down while the VIX is above 40, and agents trade in a book with depth. pt-v20 passed all 40 long-run rows registered for it on exam seeds it hadn't been run on, all 19 statistics of the one-year table, and 14 of 14 at two years ([How it is measured](https://docs.tradefloor.dev/how-its-measured.html) describes the grade). The rows closest to their limits are the two-year correlation of volume with the size of a move (0.627 against a ceiling of 0.63), a macro timing rule (92% of its tolerance), and the two-year yield, which moves 3.87 bp a day against a real 5.23.

### Economic data published late

On pt-v20 a turn in the business cycle reaches `macro_fields["cycle"]`, trace rows and the LLM adapters' payload 252 sessions after it happens. That mirrors the NBER, which dates a turn about a year late. GDP growth is a quarterly figure, released 21 sessions after the quarter ends. Prices follow the true state, and code that needs it can read `state_snapshot()["economy"]`, which a sandboxed agent can't.

### No capture ratio on pt-v20

On pt-v20 a shock moves fair value for good. Knowing fair value then gives little edge, and the Oracle's P&L follows the market's month. `capture_ratio` returns `{}` with a warning that says why. `versus_buy_and_hold` gives each agent's P&L minus buy-and-hold's, and `rank` sorts on `mean_excess_pnl`. pt-v19 and earlier still report capture.

### Orders from act

A number is a market order for that many shares. `tf.Limit(quantity, price)` and `tf.Cancel()` now work in `evaluate` and `rank` as they already did in `World`. In `evaluate` a bad entry is refused with a line in the scorecard's `errors`, and the rest of the dict trades. Quantities like `True` and `"100"` used to trade and are now refused. A falsy return such as `[]` or `0` used to pass as no trade and is now an error, so return `None` or `{}`. [Agents and evaluation](https://docs.tradefloor.dev/evaluate.html) has the rules.

### A read-only market for agents

`obs.engine` is a `MarketView` and `obs.portfolio` a `PortfolioView` in `evaluate`, `rank`, `World` and `tca.analyse`. Anything else raises `tf.SandboxError`. An agent that changes the market or copies the engine is scored `tampered`, and `rank` leaves it out. `privileged = True` gives an agent `obs.hidden`, and `trusted_agents=True` hands every agent the live engine. The scorecard marks both. The check only catches writes and copies. An agent can still read the seed and roster from the harness's frames, build a second engine and run it ahead, so run code you didn't write in a separate process.

### Warm-up history

`evaluate`, `rank` and `World` take `history_days=N`, which runs the market for N days with nobody trading before the scored days. `obs.history` holds a daily bar per name and the published macro figures for every closed day. A 20-day breakout rule can then trade on day 1, where without a warm-up it waits until day 21. The default, `history_days=0`, changes nothing, and `tca.analyse` takes `history_days` too.

### Margin interest

In `evaluate`, `rank` and `World`, a negative cash balance pays the policy rate before each close. A levered agent scores less than it did under 0.8.1. With `margin_interest=False` borrowing is free, and the scorecard says `free-borrowing`.

### Explanation accuracy and its baseline

Each day the scorer asks which of ten factors moved prices most and reads the attribution after the close. It no longer counts `fair_value_shift`, which moves no price. On pt-v20 `random_noise` wins almost every day, and naming it every day scores 0.95 to 1.0. The scorecard carries `explanation_baseline` and `explanation_edge` and prints all three, and the edge is the number to quote.

### New scorecard fields

The scorecard gains `equity_curve`, `max_drawdown_pct`, `ruined`, `leverage_refusals`, `partial_fills`, `history_days`, `margin_interest` and `exposure_curve`, the gross exposure after each step. Four read-only properties are computed from those curves. `sharpe` and `volatility_pct` are annualized from the daily returns with no risk-free rate subtracted, and the other two are `time_in_market` and `avg_gross_exposure`. The repr prints all four and counts errors. [Agents and evaluation](https://docs.tradefloor.dev/evaluate.html#scorecard) defines every field with its units.

### Refusals in rank

When an LLM adapter refuses a single action, such as a ticker the roster doesn't have, it counts in `Scorecard.rejected`. `AgentRecord.refused` holds the count per seed, and the report gives the agent a REFUSED line with the first refusal. A seed where an agent failed at every step has no score, so it no longer counts as ahead of a falling market. The report names the benchmark it read, and on pt-v20 it says the Oracle ran and has no row.

### Bar volume

`Engine.bars()` summed a running total, so a day bar read about two hundred times the day's volume. A bar's volume is now the shares traded in it, at every grain. A day's tick rows now add up to its five-minute bars and its day bar. If you read the tick column as a running total, take its cumulative sum per name and day. Prices and digests don't change. On pt-v20 `volume_abs_return_corr` moves from 0.508 to 0.596 at one year and from 0.561 to 0.627 at two, and `volume_change_acf1` from -0.254 to -0.268 at one year, all still in their bands.

### LLM decisions and payload

Decision schema 2 lets an action carry a `limit_price`, which becomes a `tf.Limit`, and `side: "CANCEL"`, which becomes a `tf.Cancel()`. A bad action is refused on its own and the rest of the decision trades. Observation payload 1 is frozen for the 0.8.x line. `portfolio.gross_exposure` is renamed `leverage`, `portfolio.open_orders` lists waiting limit orders, and `return_5d` covers five full days. A recording carries both schema versions and a replay refuses one made under different versions, so recordings made before 0.8.5 don't replay. [LLM adapters and MCP](https://docs.tradefloor.dev/api-integrations.html) has the contract.

### Fingerprint battery version 2

The battery is now seven 120-day markets, one per shipped scenario including `curve_shock`, so a shock on day 50 has 70 days after it. `tf.battery(1)` still builds the old six markets. A fingerprint only compares with one taken on the same version.

### A digest for a traded run

The known-answer script now hashes one run through `tf.evaluate` on pt-v20, with the five reference agents and an agent that sends and cancels limit orders. The hash covers every order, fill and scorecard field, and it's checked on all five platforms with the other digests.

### Fills reach the market once

Every harness passed an agent's fills to `run_session` as `order_flow`, and the session held that flow on every tick. That made one order count 65 times, and agents were marked to their own impact. Fills now arrive once, as `fills`, and every traded result moves. On pt-v19 the spec mean-reversion rule had beaten buy-and-hold on all 20 suite markets by a median 42 points in 60 days. With fills applied once it reads +0.5 points, ahead in 10 of 20. `run_session(order_flow=...)` now raises. Pass `fills=`, or `flow_per_tick=` for a standing rate. Logs, checkpoints and manifests from 0.8.x replay as they ran. [Engine and data](https://docs.tradefloor.dev/core-types.html#run-session-fills) has the change.

### A book with depth

Seven `ModelParams` variables give the book depth priced by size, consumption and refill, resting limit orders and a permanent impact per agent. All seven are 0 on every earlier preset, and pt-v20 turns them on. [Engine and data](https://docs.tradefloor.dev/core-types.html#agent-book) says what each does to an order. A resting order fills against the model's flow only at a price inside the maker's quote for that tick. If the maker's re-quote crosses a resting order, the order trades at the maker's price and is recorded as `liquidity="taker"`. `tf.Limit` and `tf.Cancel` compare by value, so `agree` no longer reports two forks that sent identical limit orders as different.

### Rate indices

`Universe.random(40, seed=1, bonds=True)` adds `UST2Y`, `UST10Y` and `IGCORP`, priced off the engine's yield curve. None of them is a real security, and adding them leaves every equity price unchanged. The `curve_shock` scenario moves the whole curve 200 bp in one day, `baselines.Balanced` holds a 60/40 book, and `cash_interest=True` pays idle cash the policy rate. [Engine and data](https://docs.tradefloor.dev/core-types.html#rate-indices) has the pricing.

### 64-bit seeds

A seed can be any 64-bit integer, and every seed below 2**32 gives the market it gave before. Draw a sealed seed with `secrets.randbits(64)`.

### Recalibrated crisis scenarios

On pt-v20 `recession` takes the index down 44.7% at 120 sessions (2008 fell 45%) and now ends, with the cycle at trough on day 365. `liquidity_crisis` falls 33.9% at worst, as March 2020 did, though more slowly. [Scenarios](https://docs.tradefloor.dev/api-scenario.html) says why.

### Gym resets

The gym environment draws a new market on each `reset()`. A reset without a seed used to replay the constructor's market. `info["seed"]` names the episode's seed. An action over the leverage cap is scaled down to 1.96x gross, with `info["scaled"]` set.

### Speed

`evaluate` of five momentum strategies on 40 names over 20 days fell from 11.0 to 3.95 seconds of CPU, and building a pt-v20 engine from 0.70 to about 0.01 seconds.

### Python 3.12 and 3.13

Python 3.12 changed `sum()` over floats, which could move an agent's orders away from 3.11's in the last digit. tradefloor now adds floats left to right on every version, so 3.12 and 3.13 match 3.11.

### Short-lag clustering

Volatility clustering reads about a quarter of real at lag 1, so the decay-shape gap now covers `abs_return_acf1` and `abs_return_acf5` as well as `abs_return_acf20`, and `tf.envelope.check()` refuses a question that relies on any of them. [How it is measured](https://docs.tradefloor.dev/how-its-measured.html#the-named-gaps) lists the gaps.

### Examples and the MCP server

`examples/08-claude-agent.py` replays a committed Claude run by default and needs no key or network. With a key and `TRADEFLOOR_LIVE_EXAMPLES=1` it calls Claude once per simulated day. The MCP server refuses a stress run that ends before its scenario's first event (it used to return a difference of 0.0), and it refuses strategies named after a baseline. `list_scenarios` gives each scenario's first and last event day, the constructors are `rate_ramp` and `vix_shock`, and `pip install "tradefloor[mcp]"` now installs pyarrow, which `explain` needs.

### The model written down

The [model specification](https://github.com/simoncoombes/tradefloor/blob/main/docs/MODEL.md) states pt-v20 as equations, each with its source line, and gives every coefficient its value and how it was set. [STATISTICS.md](https://github.com/simoncoombes/tradefloor/blob/main/docs/STATISTICS.md) names the statistic sets behind every count the site quotes.

### Rust crate API changes

The crate takes the package's version number. Cargo treats 0.8.5 as a compatible update to 0.8.1, but it isn't one. Seeds are `u64`, several public structs have new fields and are `#[non_exhaustive]`, and `Engine::new` builds a pt-v20 market. Pin `tradefloor = "=0.8.1"` to stay on the old API. The CHANGELOG lists every changed signature.

### Smaller fixes

An agent no longer trades with itself in the settlement book. A resting fill can sit outside the day's high and low, because a bar keeps only each tick's last print. The `Scorecard` repr prints `sharpe=n/a (short run)` for a run of fewer than 20 scored days. An `act()` that returns something other than a mapping is reported on an UNUSABLE line and held in `AgentRecord.unusable`. The scripts and output that graded pt-v20 are in the library's [validation/pt-v20/](https://github.com/simoncoombes/tradefloor/tree/main/validation/pt-v20).

### Known gaps

The worst month of the 2020 replay is about 19% milder than the real one. With the VIX held at 65 the market is 5.1 times as volatile as with it held at 5, against 6.2 times in real markets.

## 0.8.1

2026-09-23

A text-only release, with no coefficient, default or trajectory changes. The README, the messages `tf.envelope.check()` prints, the scenario target notes and the parameter descriptions now describe pt-v19. Some of them had still quoted older presets. Re-measured on pt-v19, the decay slope of volatility clustering reads -0.515 against a real -0.436, and the memory holds to lag 20. A driven 2020-21 scenario moves prices at about a fifth of the real size, and `qe_pe_boost` moves nothing on pt-v16 and later.

## 0.8.0

2026-09-23

pt-v19 became the default. A run that used the default won't replay against 0.7.x. Pass `model="pt-v18"` to keep the 0.7.x market. pt-v19 meets all fifteen criteria of a long-run check (thirty 21-year histories, and 2008 and 2020 replayed with the real VIX forced in), and pt-v18 meets eight. `tf.preset_record("pt-v19")["long_run"]` holds every row. Over 21 years it has 1.35 bear markets a decade against a real 1.12, index volatility of 16.6% against 18.1%, and the VIX above 30 on 8.1% of sessions against 8.2%. The 2008 replay falls 41% against the real 57%.

`ModelParams.from_preset` refuses an override that breaks one of pt-v19's three identities, such as `garch_alpha=0.07` alone, because `garch_beta` follows from it. `ModelParams.from_preset_unchecked` builds it anyway, and `ModelParams.identity_breaks` lists what broke.

A recorded transcript names its preset under `meta["model_preset"]`, and replaying it against a different preset raises `ReplayMiss`. A manifest or checkpoint written under 0.7.x is refused, because its probe simulation runs the default preset. `state_hash` covers thirteen more fields, and a custom parameter set's fingerprint changes between releases.

Realism is graded on the ruled bands, each read from the longest real record for its row. `envelope.certified()`, `envelope.score()` and `facts.report()` take `basis="shipped"` for the old table. New calls: `Engine.session_news()`, `Engine.session_tick`, `Scenario(vix_sets_variance=True)` and `hold(epicentre=...)`.

## 0.7.1

2026-09-08

Documentation only. No behavior changes, and every published digest holds.

## 0.7.0

2026-09-08

pt-v18 became the default. It's the first default to hold every certified row, and its index returns +5.80 percent a year where pt-v16 lost 13.64. The steady-state crisis lever reads 6.53x against real markets' 6.16x. `tf.preset_names()` lists the presets the engine resolves, and `tf.preset_record` reads pt-v1 through pt-v18 from JSON in the wheel.

Every `Universe.random` roster re-rolls, so pin 0.6.2 for the old draws. EDGAR rosters and rosters you build yourself don't change. A supplied `macro_state` now survives construction, the first central-bank meeting and OPEC decision fall inside a 252-day year, and `to_instruments` reads the discount rate from the model. `Engine.explain` decomposes a name's day down to the draws that seeded it.

## 0.6.2

2026-09-01

A scenario's liquidity shock now reaches the agent's volume and order cap. `World(on_refusal="skip")` records an unusable response and carries on. Every adapter takes `prior=`, a recording consulted before the provider. `resample()` measures an agent's own noise floor. `fetch(ciks=)` returns exactly those EDGAR filers, and saved files are the same bytes on Windows.

## 0.6.1

2026-08-31

`tradefloor.integrations` gains adapters for the OpenAI Agents SDK, PydanticAI and LangGraph, and one for any plain Python function. A `Transcript` keys each exchange by a digest of the exact input, so a recorded run replays with no framework installed and no network. The examples in `examples/integrations/` run offline. [LLM adapters and MCP](https://docs.tradefloor.dev/api-integrations.html) has the contract.

## 0.6.0

2026-08-30

pt-v16 became the default. It ties the VIX to the market's realized volatility. `tf.Scenario` and six packaged scenarios arrived, with the `tradefloor scenario` command. `tradefloor.counterfactual` runs one agent in two worlds that differ by one variable, with `World`, `agree()` and `compare()`.

## 0.5.0

2026-08-28

The library was renamed from pretium, which published through 0.4.3 and stays on PyPI and crates.io. A result computed under one of those versions is cited as `pretium` at that exact version. The rename changes no behavior, and preset names stay `pt-v1` through `pt-v15`. pt-v15 is selectable by name, and pt-v14 remains the default.

## 0.4.3

2026-08-28

Restores pt-v13 and pt-v14 exactly as they were in 0.4.0 and 0.4.1, after 0.4.2 moved their dollar safe-haven gate. The gate is its own variable now, `usd_crisis_vix_threshold`.

## 0.4.2

2026-08-28

Three fixes with no trajectory change: `crisis_vix_threshold` now gates the dollar's safe-haven drift as well as gold, `DayAdvanceOutcome` carries a meeting's decision, and `daily_credit_floor_gain` ships at 0.0.

## 0.4.1

2026-08-28

No trajectory moves in this release. pt-v13 and pt-v14 now report the 60-day mispricing half-life they run, where `tf.model_preset()` said 68.26.

## 0.4.0

2026-08-28

pt-v14 became the default. Over 13 seed blocks it holds the two-year panel fully in band on 11, where pt-v12 held 3, and puts 137 of 138 roster shapes in band.

## 0.3.0

2026-08-27

pt-v12 became the default, the first preset in band on all 14 statistics over two years as well as one. Results recorded without naming a preset differ from here on, and `model="pt-v10"` gives the old market.
