Developer / Trade execution

Changelog

Contents

v0.1.0 on 23rd of February, 2026

  • Add Binance Spot testnet connectivity verification tests in tests/testnet/
  • Add conftest.py with constants, auth helpers, skip markers, and dotenv support
  • Add test_safety.py for URL sanity checks
  • Add test_rest_public.py for unauthenticated REST endpoint tests
  • Add test_rest_auth.py for authenticated REST endpoint tests
  • Add test_websocket.py for WebSocket connectivity and E2E fill tests
  • Add aiohttp, websockets, pytest-asyncio, and python-dotenv as dev dependencies
  • Add .env support for testnet credential loading
  • Add CI pipeline with Ruff, Mypy strict, pytest, and CodeQL workflows
  • Configure strict Ruff linting rules in pyproject.toml
  • Configure strict Mypy in pyproject.toml
  • Exclude testnet tests from default pytest collection via addopts
  • Update README with setup instructions, testnet verification guide, and integrations
  • Remove template docs/Developer/ placeholder

v0.2.0 on 24th of February, 2026

  • Add structlog>=24.1 and orjson>=3.10 as runtime dependencies
  • Add observability.py with configure_logging, bind_context, clear_context, get_logger
  • Add praxis/infrastructure/ package
  • Add stdlib logging integration through structlog ProcessorFormatter
  • Add asyncio-safe context variable binding for epoch_id, account_id, command_id, client_order_id, event_seq
  • Add test_observability.py with 10 tests covering JSON output, context binding, level filtering, and stdlib integration
  • Add praxis-journals/ to .gitignore
  • Remove placeholder test file tests/test_placeholder.py

v0.3.0 on 24th of February, 2026

  • Add praxis/core/domain/ package with Position, Order, Fill dataclasses
  • Add OrderSide, OrderType, OrderStatus enums in enums.py
  • Add frozen Fill dataclass with dedup_key property per RFC fill deduplication spec
  • Add mutable Order dataclass with is_terminal and remaining_qty properties
  • Add mutable Position dataclass with is_closed property
  • Add domain package re-exports in praxis/core/domain/__init__.py
  • Add test_domain_core.py with 36 tests covering enums, dataclass creation, immutability, properties, Decimal precision, and construction-time validation

v0.4.0 on 25th of February, 2026

  • Add ExecutionMode, MakerPreference, STPMode enums in enums.py
  • Add frozen SingleShotParams dataclass with positive price validation in single_shot_params.py
  • Add frozen TradeCommand dataclass with qty, timeout, price, and timezone validation in trade_command.py
  • Add frozen TradeAbort dataclass with timezone-aware validation in trade_abort.py
  • Add domain package re-exports for all 12 domain types in praxis/core/domain/__init__.py
  • Add test_domain_commands.py with 28 tests covering enums, dataclass creation, immutability, Decimal precision, and construction-time validation
  • Refactor zero/negative validation tests into parametrized functions across both test files

v0.5.0 on 25th of February, 2026

  • Add TradeStatus enum with terminal and non-terminal execution states in enums.py
  • Add frozen TradeOutcome dataclass with is_terminal and fill_ratio properties in trade_outcome.py
  • Add construction-time validation for target_qty, filled_qty, avg_fill_price, slices, missed_iterations, and timezone-aware created_at
  • Add domain package re-exports for all 14 domain types in praxis/core/domain/__init__.py
  • Add test_domain_outcome.py with 29 tests covering enum membership, dataclass creation, immutability, properties, Decimal precision, and construction-time validation

v0.6.0 on 25th of February, 2026

  • Add 10 frozen event dataclasses (CommandAccepted, OrderSubmitIntent, OrderSubmitted, OrderSubmitFailed, OrderAcked, FillReceived, OrderRejected, OrderCanceled, OrderExpired, TradeClosed) with Event type alias in events.py
  • Add _EventBase base class with shared account_id and timezone-aware timestamp validation
  • Add non-empty string validation via _require_str helper on all event identifier fields
  • Add TradingState projection class with apply() dispatch, VWAP position tracking, and order lifecycle management in trading_state.py
  • Add TradingState re-export from praxis.core package
  • Add domain package re-exports for all 25 domain types in praxis/core/domain/__init__.py
  • Add test_trading_state.py with 27 tests covering construction validation, apply dispatch, order lifecycle, position VWAP, exit fills, warning logs, and full lifecycle

v0.6.1 on 26th of February, 2026

  • Add non-empty string validation to Position (account_id, trade_id, symbol), Order (client_order_id, account_id, command_id, symbol), Fill (venue_order_id, client_order_id, account_id, trade_id, command_id, symbol, fee_asset), TradeCommand (command_id, trade_id, account_id, symbol), TradeAbort (command_id, account_id, reason), and TradeOutcome (command_id, trade_id, account_id)
  • Add parametrized empty-string validation tests to test_domain_core.py, test_domain_commands.py, and test_domain_outcome.py
  • Add __post_init__ docstrings to TradeCommand and TradeOutcome for consistency with other domain dataclasses
  • Add .claude/ to .gitignore
  • Refactor events.py to import _require_str from shared module instead of defining it locally

v0.7.0 on 26th of February, 2026

  • Add aiosqlite>=0.20 as runtime dependency
  • Add EventSpine class in event_spine.py with append-only SQLite event log, epoch-scoped reads, and event type registry hydration
  • Add append() method serializing domain events via orjson with Decimal, datetime, and enum support
  • Add read() method hydrating stored payloads back into domain Event dataclasses via get_type_hints-based coercion
  • Add last_event_seq() method returning highest sequence number per epoch
  • Add test_event_spine.py with 19 tests covering round-trip for all 10 event types, epoch isolation, ordering, Decimal precision, datetime timezone, enum preservation, and after_seq filtering

v0.8.0 on 26th of February, 2026

  • Add fill_dedup table with UNIQUE(epoch_id, account_id, dedup_key) constraint for epoch-scoped fill deduplication in event_spine.py
  • Add fill deduplication to EventSpine.append() — duplicate FillReceived events silently dropped per RFC, scoped by (account_id, venue_trade_id) per epoch
  • Add PLR2004 to test file ruff ignores in pyproject.toml
  • Add 7 fill deduplication tests to test_event_spine.py covering duplicate detection, cross-account correctness, epoch scoping, and non-fill event passthrough
  • Harden _hydrate forward-compatibility by filtering payload keys against declared type hints, silently ignoring extra fields from older event schemas
  • Add docs/TechnicalDebt.md tracking 5 known debt items (TD-001 through TD-005) mined from PR review history

v0.9.0 on 27th of February, 2026

  • Add VenueAdapter runtime-checkable Protocol with 8 async methods (submit_order, cancel_order, query_order, query_open_orders, query_balance, query_trades, get_exchange_info, get_server_time) in venue_adapter.py
  • Add 7 frozen response dataclasses (ImmediateFill, SubmitResult, CancelResult, VenueOrder, VenueTrade, BalanceEntry, SymbolFilters) in venue_adapter.py
  • Add VenueError base exception with 5 typed subclasses (OrderRejectedError, RateLimitError, AuthenticationError, TransientError, NotFoundError) in venue_adapter.py
  • Add VenueTrade.__post_init__ timezone validation matching codebase pattern (Fill, _EventBase, TradeCommand)
  • Add account_id parameter to all authenticated Protocol methods for multi-account API key routing
  • Add docstring notes for cancel_order and query_order requiring at least one order identifier
  • Rename SubmitResult.fills to immediate_fills with corrected docstring
  • Add test_venue_adapter.py with 24 tests covering dataclass immutability, timestamp validation, error hierarchy, pickle safety, and Protocol conformance

v0.10.0 on 28th of February, 2026

  • Add BinanceAdapter class in binance_adapter.py implementing VenueAdapter.submit_order() via Binance POST /api/v3/order with newOrderRespType=FULL
  • Add HMAC-SHA256 request signing and X-MBX-APIKEY header authentication
  • Add order parameter building for OrderType.MARKET, OrderType.LIMIT, and OrderType.LIMIT_IOC with automatic timeInForce handling and Decimal serialization
  • Add response normalization mapping Binance statuses to OrderStatus and fills to ImmediateFill tuple
  • Add HTTP error mapping: 400 → OrderRejectedError, 401 → AuthenticationError, 403/418/429 → RateLimitError, 5xx → TransientError
  • Add credential management via constructor injection with runtime register_account/unregister_account
  • Add async context manager session lifecycle with explicit close()
  • Move aiohttp>=3.10 from dev to runtime dependencies in pyproject.toml
  • Add test_binance_adapter.py with 47 unit tests covering credentials, signing, param building, status mapping, response parsing, error handling, session lifecycle, and end-to-end submit flow
  • Add tests/testnet/test_binance_adapter.py with 3 testnet integration tests for market buy (filled), limit resting (open), and limit IOC (expired)

v0.11.0 on 1st of March, 2026

  • Add _signed_request helper extracting auth and dispatch from submit_order in binance_adapter.py
  • Add _map_order_type mapping Binance type/timeInForce strings to OrderType and _parse_venue_order response-to-VenueOrder helper in binance_adapter.py
  • Add cancel_order via DELETE /api/v3/order in binance_adapter.py
  • Add query_order via GET /api/v3/order in binance_adapter.py
  • Add query_open_orders via GET /api/v3/openOrders in binance_adapter.py
  • Add query_balance via GET /api/v3/account with asset filtering in binance_adapter.py
  • Add assets: frozenset[str] parameter to VenueAdapter.query_balance Protocol in venue_adapter.py
  • Add NotFoundError mapping for Binance error codes -2013 and -2011 in binance_adapter.py
  • Refactor _signed_request return type from dict[str, Any] to Any to support array responses
  • Add 25 unit tests for _signed_request, cancel_order, query_order, query_open_orders, and query_balance in test_binance_adapter.py
  • Add 4 testnet integration tests for cancel, query order, query open orders, and query balance in tests/testnet/test_binance_adapter.py

v0.12.0 on 2nd of March, 2026

  • Add STOP_LOSS, STOP_LOSS_LIMIT, TAKE_PROFIT, TAKE_PROFIT_LIMIT, LIMIT_MAKER, and OCO mappings to _map_order_type via _BINANCE_TYPE_MAP lookup in binance_adapter.py
  • Add LIMIT+FOK handling mapping to OrderType.LIMIT_IOC in _map_order_type in binance_adapter.py
  • Add transient HTTP retry with exponential backoff and full jitter in _signed_request in binance_adapter.py
  • Add _parse_venue_trade helper mapping Binance myTrades entries to VenueTrade with Decimal precision, UTC timestamps, and isMaker in binance_adapter.py
  • Add query_trades via GET /api/v3/myTrades with optional timezone-aware start_time filter in binance_adapter.py
  • Refactor _map_order_type from chained if-statements to dict lookup to satisfy PLR0911 in binance_adapter.py
  • Fix testnet test_query_balance_returns_requested_assets assertions to run inside context manager in tests/testnet/test_binance_adapter.py
  • Add 8 unit tests for new _map_order_type mappings in test_binance_adapter.py
  • Add test_empty_assets_skips_api_call verifying query_balance short-circuits without API call in test_binance_adapter.py
  • Add 7 unit tests for retry success, exhaustion, non-retryable errors, sleep delay, and log output in test_binance_adapter.py
  • Add 9 unit tests for _parse_venue_trade and query_trades covering field mapping, Decimal precision, UTC timestamps, isMaker, startTime conversion, and naive datetime rejection in test_binance_adapter.py

v0.13.0 on 4th of March, 2026

  • Add get_exchange_info method parsing PRICE_FILTER, LOT_SIZE, and NOTIONAL from unauthenticated GET /api/v3/exchangeInfo in binance_adapter.py
  • Add load_filters startup method for explicit per-symbol filter caching in binance_adapter.py
  • Add _validate_order helper checking lot step, lot range, tick size, and min notional with graceful degradation when filters not cached in binance_adapter.py
  • Add pre-submission validation in submit_order before _build_order_params in binance_adapter.py
  • Add 13 unit tests for get_exchange_info, load_filters, and _validate_order in test_binance_adapter.py

v0.14.0 on 5th of March, 2026

  • Add retry_after field to RateLimitError and parse Retry-After header in venue_adapter.py
  • Add _DEFAULT_WEIGHT_LIMIT, _DEFAULT_ORDER_COUNT_LIMIT, and _RATE_LIMIT_WARN_THRESHOLD constants in binance_adapter.py
  • Add _update_weight_from_headers parsing X-MBX-USED-WEIGHT-1M and X-MBX-ORDER-COUNT-10S with per-account order count tracking in binance_adapter.py
  • Add _parse_rate_limits extracting REQUEST_WEIGHT and ORDERS limits from exchangeInfo response in binance_adapter.py
  • Add RateLimitError retry with Retry-After support in _signed_request in binance_adapter.py
  • Add weight_headroom property and order_count_headroom method returning normalized 0.0–1.0 headroom in binance_adapter.py
  • Add unit tests for rate limit state tracking, header parsing, retry, and headroom in test_binance_adapter.py
  • Add unit tests for RateLimitError fields in test_venue_adapter.py

v0.15.0 on 6th of March, 2026

  • Add OrderBookLevel and OrderBookSnapshot frozen dataclasses to venue_adapter.py
  • Add query_order_book to VenueAdapter protocol with default limit=20 in venue_adapter.py
  • Implement query_order_book in BinanceAdapter via unauthenticated GET /api/v3/depth with response parsing and weight tracking in binance_adapter.py
  • Add unit tests for order book parsing, error handling, weight tracking, and immutability in test_binance_adapter.py

v0.16.0 on 6th of March, 2026

  • Add _api_key_request helper for API-key-only REST calls without HMAC signing in binance_adapter.py
  • Add _create_listen_key, _keepalive_listen_key, and _close_listen_key methods for user data stream lifecycle in binance_adapter.py
  • Add BinanceUserStream class with connect, close, keepalive loop, _listen dispatch, and async context manager in binance_ws.py
  • Add on_message callback dispatch in _listen() with JSON parsing, non-JSON skip, callback error resilience, and CLOSED/ERROR break in binance_ws.py
  • Add 9 unit tests for _api_key_request and listen key methods in test_binance_adapter.py
  • Add 18 unit tests for BinanceUserStream covering URL building, connect/close lifecycle, keepalive, context manager, and _listen dispatch in test_binance_ws.py
  • Add TD-007 tracking duplicated retry loop between _signed_request and _api_key_request in TechnicalDebt.md

v0.17.0 on 8th of March, 2026

  • Add ExecutionType enum (NEW, TRADE, CANCELED, REPLACED, REJECTED, EXPIRED, TRADE_PREVENTION) to enums.py
  • Add ExecutionReport frozen dataclass with 19 typed fields and timezone-aware validation to venue_adapter.py
  • Add _BINANCE_EXECUTION_TYPE_MAP constant and _parse_execution_report method mapping single-letter Binance keys to domain types in binance_adapter.py
  • Add 14 unit tests for execution report parsing covering trade fill, NEW/CANCELED/REJECTED/EXPIRED/TRADE_PREVENTION, market order, unknown value errors, decimal precision, and UTC timestamps in test_binance_adapter.py

v0.18.0 on 9th of March, 2026

  • Add reconnect_base_delay and reconnect_max_delay config params to BinanceUserStream.__init__ in binance_ws.py
  • Add _clean_setup_connection method extracting teardown + connect logic from initiate_connection in binance_ws.py
  • Add _auto_reconnect method with exponential backoff, jitter, and infinite retry on disconnect in binance_ws.py
  • Wire initiate_connection to start _reconnect_task running _auto_reconnect, close to cancel it in binance_ws.py
  • Rename _listen to _receive_loop and connect to initiate_connection for clearer client/server nomenclature in binance_ws.py
  • Add 4 unit tests for auto-reconnect, exponential backoff, attempt reset, and cancel-during-backoff in test_binance_ws.py

v0.19.0 on 9th of March, 2026

v0.20.0 on 9th of March, 2026

  • Add ExecutionManager class with per-account unbounded command and priority queues in execution_manager.py
  • Add _AccountRuntime internal class holding per-account queue pair, TradingState projection, and asyncio task in execution_manager.py
  • Add register_account and unregister_account methods with coroutine lifecycle management in execution_manager.py
  • Add submit_command method with UUID generation, CommandAccepted event persistence, and queue routing in execution_manager.py
  • Add submit_abort method enqueuing TradeAbort to per-account priority queue in execution_manager.py
  • Add _account_loop coroutine draining priority queue before command queue on each iteration in execution_manager.py
  • Add AccountNotRegisteredError exception for unregistered account_id targeting in execution_manager.py
  • Add _QUEUE_POLL_INTERVAL constant for account loop poll timeout in execution_manager.py
  • Add ExecutionManager and AccountNotRegisteredError re-exports from praxis.core package in __init__.py
  • Add test_execution_manager.py with 13 tests covering registration, unregistration, command submission, abort submission, priority drain ordering, and account isolation

v0.21.0 on 9th of March, 2026

  • Add generate_client_order_id pure function producing deterministic {prefix}-{hex16}-{seq}[rN] client order IDs for venue submission in generate_client_order_id.py
  • Add _MODE_PREFIX mapping all 7 ExecutionMode variants to 2-character prefixes (SS, BK, TW, SV, IC, TD, LD) in generate_client_order_id.py
  • Add UUID4 truncation to first 16 hex characters (64-bit entropy) for Binance 36-character newClientOrderId limit in generate_client_order_id.py
  • Add generate_client_order_id re-export from praxis.core package in __init__.py
  • Add test_generate_client_order_id.py with 27 tests covering all mode prefixes, format, sequence padding, retry suffix, length validation, and error cases

v0.22.0 on 10th of March, 2026

  • Add validate_trade_command inbound validator with mode/order-type gating, SingleShot parameter coherence checks, maker-only compatibility checks, and optional venue filter checks in validate_trade_command.py
  • Add validate_trade_abort inbound validator with unknown-command rejection, account ownership checks, and terminal-command no-op behavior in validate_trade_abort.py
  • Add validate_trade_command and validate_trade_abort re-exports from the core package in __init__.py
  • Update ExecutionManager.submit_command and ExecutionManager.submit_abort with inbound validation and accepted/terminal command ID tracking in execution_manager.py
  • Add test_validate_trade_abort.py with 8 tests covering valid abort, unknown command_id, terminal no-op, and account_id mismatch
  • Add test_validate_trade_command.py with 83 tests covering allowed/disallowed mode-order pairs, SingleShot param requirements, maker preference rules, and venue filter boundaries
  • Add integration tests to test_execution_manager.py for inbound validation rejection/no-op behavior and accepted command tracking

v0.22.1 on 10th of March, 2026

v0.23.0 on 10th of March, 2026

  • Add venue_adapter: VenueAdapter parameter to ExecutionManager.__init__ for venue order submission in execution_manager.py
  • Add _process_command method with deterministic client order ID generation, OrderSubmitIntent persistence for crash durability, venue submission via VenueAdapter.submit_order, OrderSubmitted and FillReceived event persistence with fill deduplication, and OrderSubmitFailed on VenueError in execution_manager.py
  • Add _process_command call in _account_loop after command dequeue in execution_manager.py
  • Add 9 TestProcessCommand tests covering market fill, limit no-fill, venue rejection, transient failure, multiple fills, fill deduplication, client order ID determinism, trading state projection, and loop resilience in test_execution_manager.py

v0.24.0 on 11th of March, 2026

  • Add TradeOutcomeProduced frozen event dataclass with command_id, trade_id, status, and reason fields in events.py
  • Add TradeOutcomeProduced to Event type alias and __all__ in events.py
  • Add TradeOutcomeProduced handler with debug logging in TradingState.apply() in trading_state.py
  • Add TradeOutcomeProduced to _EVENT_REGISTRY for hydration in event_spine.py
  • Add on_trade_outcome: Callable[[TradeOutcome], Awaitable[None]] | None parameter to ExecutionManager.__init__ in execution_manager.py
  • Add _build_outcome method constructing TradeOutcome, emitting TradeClosed for terminal outcomes with fills and TradeOutcomeProduced for all outcomes, and invoking the async callback in execution_manager.py
  • Add filled quantity summation, VWAP computation, overfill clamping, and status determination (FILLED, PARTIAL, PENDING, REJECTED) to _process_command in execution_manager.py
  • Add 8 TestTradeOutcome tests covering callback delivery, rejected with reason, pending, partial fill, VWAP computation, no-callback, field correctness, and spine event verification in test_execution_manager.py
  • Add test_overfill_clamped_with_correct_vwap test asserting clamped filled_qty and VWAP computed from unclamped fills in test_execution_manager.py
  • Rename test_trading_state_has_position_after_fill to test_trading_state_has_closed_order_after_fill in test_execution_manager.py
  • Fix missing _terminal_commands tracking for terminal outcomes in _build_outcome in execution_manager.py
  • Fix TradeClosed emission to skip terminal outcomes with zero fills in _build_outcome in execution_manager.py
  • Fix VWAP inflated on overfill by computing avg_fill_price before clamping filled_qty in execution_manager.py
  • Fix unguarded on_trade_outcome callback propagating exceptions into account loop in execution_manager.py
  • Fix import ordering for collections.abc in execution_manager.py
  • Fix reason=str(exc) producing tuple-like strings for OrderRejectedError by using exc.args[0] in execution_manager.py
  • Update 9 existing TestProcessCommand test assertions for TradeClosed and TradeOutcomeProduced event sequences in test_execution_manager.py

v0.25.0 on 11th of March, 2026

  • Add _deadline_at and _deadline_exceeded deadline computation helpers in execution_manager.py
  • Add timeout enforcement transitioning non-terminal statuses (PENDING, PARTIAL) to EXPIRED with reason='deadline exceeded' in _process_command in execution_manager.py
  • Add order expiry eventing on timeout with cancel_order call, OrderExpired event emission on cancel success or NotFoundError, and cancel_confirmed=False fallback on other VenueError in execution_manager.py
  • Add 8 TestDeadlineHandling tests covering pending expiry, partial fill expiry, TradeOutcomeProduced with EXPIRED status, OrderExpired emission, NotFoundError fallback, VenueError skip, terminal abort no-op, and non-expired control case in test_execution_manager.py
  • Fix _TS test constant from datetime(2026, 1, 1) to datetime(2099, 1, 1) preventing false deadline triggers in existing tests in test_execution_manager.py

v0.26.0 on 11th of March, 2026

  • Add _commands and _aborted_commands state to ExecutionManager.__init__ for abort command lookup and pre-submission tracking in execution_manager.py
  • Add _process_abort method with venue cancel dispatch, OrderCanceled emission on success or NotFoundError, VWAP-preserving CANCELED outcome, and pre-submission marker fallback in execution_manager.py
  • Add _process_abort call with error guard in _account_loop priority queue drain in execution_manager.py
  • Add pre-submission abort guard in _process_command short-circuiting to CANCELED without venue call in execution_manager.py
  • Add 5 TestProcessAbort tests covering pending order abort, partial fill VWAP preservation, NotFoundError resilience, VenueError cancel failure, and pre-submission short-circuit in test_execution_manager.py

v0.27.0 on 12th of March, 2026

  • Add mode dispatch guard in _process_command rejecting unsupported ExecutionMode with REJECTED outcome instead of raising NotImplementedError in execution_manager.py
  • Add stop_limit_price: Decimal | None field to OrderSubmitIntent with positive-value validation in events.py
  • Add stop_limit_price passthrough from SingleShotParams through OrderSubmitIntent to VenueAdapter.submit_order in execution_manager.py
  • Add stop_limit_price keyword parameter to VenueAdapter.submit_order protocol in venue_adapter.py
  • Add _BINANCE_OCO_STATUS_MAP constant mapping Binance OCO list statuses (EXECUTING, REJECT) to OrderStatus in binance_adapter.py
  • Add _build_oco_params helper building Binance POST /api/v3/order/oco request parameters with symbol, side, qty, price, stopPrice, stopLimitPrice, and listClientOrderId in binance_adapter.py
  • Add _parse_oco_response helper extracting orderListId as venue_order_id, mapping listOrderStatus, and collecting fills from both orderReports in binance_adapter.py
  • Add OCO order dispatch in submit_order routing OrderType.OCO to /api/v3/order/oco with dedicated params builder and response parser in binance_adapter.py
  • Add TestModeDispatch test verifying unsupported mode produces REJECTED outcome via callback in test_execution_manager.py
  • Add TestStopLimitPassthrough test verifying stop_limit_price flows from params to OrderSubmitIntent and venue_adapter.submit_order in test_execution_manager.py
  • Add 3 TestBuildOcoParams tests covering required params, stop_limit_price inclusion, and client_order_id mapping in test_binance_adapter.py
  • Add 3 TestParseOcoResponse tests covering EXECUTING→OPEN mapping, ALL_DONE with fills, and unknown list status rejection in test_binance_adapter.py
  • Add 3 TestSubmitOcoOrder tests covering OCO endpoint dispatch, missing price rejection, and missing stop_price rejection in test_binance_adapter.py
  • Add cancel_order_list method to VenueAdapter protocol for OCO list cancellation via DELETE /api/v3/orderList in venue_adapter.py
  • Add cancel_order_list implementation with orderListId and listClientOrderId dispatch in binance_adapter.py
  • Add OCO-aware cancel routing in _process_abort and _process_command deadline path branching on OrderType.OCO to call cancel_order_list in execution_manager.py
  • Add time_in_force parameter to _build_oco_params defaulting to GTC instead of hardcoding in binance_adapter.py
  • Fix is_maker in _parse_oco_response reading isMaker from Binance OCO fill payloads instead of hardcoding False in binance_adapter.py
  • Fix ALL_DONE status derivation in _parse_oco_response deriving from leg statuses instead of mapping directly to FILLED in binance_adapter.py
  • Add TestOcoAbortRouting test verifying OCO abort calls cancel_order_list instead of cancel_order in test_execution_manager.py
  • Add 3 TestCancelOrderList tests covering orderListId dispatch, listClientOrderId dispatch, and missing-both rejection in test_binance_adapter.py
  • Add TestBuildOcoParams::test_time_in_force_passed_through test in test_binance_adapter.py
  • Add TestParseOcoResponse::test_all_done_canceled_no_fills test verifying ALL_DONE with only canceled legs produces CANCELED status in test_binance_adapter.py
  • Add TestParseOcoResponse::test_is_maker_read_from_payload test in test_binance_adapter.py

v0.28.0 on 12th of March, 2026

  • Add SlippageEstimate dataclass and estimate_slippage pure function with walk-the-book VWAP and bps computation in estimate_slippage.py
  • Add pre-submission slippage estimation in _process_command with order book query (limit=20) and non-fatal fallback logging on estimation/query failures in execution_manager.py
  • Add post-fill slippage logging in _process_command for execution_slippage_bps (vs estimated mid-price) and conditional arrival_slippage_bps (vs reference_price) in execution_manager.py
  • Add slippage-focused ExecutionManager tests for estimate logging, order-book-query failure fallback, execution slippage logging, and arrival slippage logging in test_execution_manager_slippage.py
  • Add estimate_slippage and SlippageEstimate re-exports in __init__.py

v0.29.0 on 13th of March, 2026

  • Add register_account(account_id, api_key, api_secret) and unregister_account(account_id) methods to VenueAdapter protocol in venue_adapter.py
  • Add TradingInbound service providing basic inbound account registration orchestration with hardcoded account credential mapping in trading_inbound.py
  • Add rollback behavior in TradingInbound.register_account to remove venue credentials when execution account registration fails in trading_inbound.py
  • Add TradingInbound tests covering happy path, unknown credentials, empty account id rejection, rollback behavior, and unregister orchestration in test_trading_inbound.py
  • Add protocol conformance coverage for the new account registration methods in test_venue_adapter.py

v0.30.0 on 13th of March, 2026

  • Add inbound TradingInbound.submit_command(...) handler routing directly to execution manager command intake in trading_inbound.py
  • Add inbound TradingInbound.submit_abort(...) handler routing directly to execution manager abort intake in trading_inbound.py
  • Add _ExecutionInboundGateway protocol support for submit_command and submit_abort routing contracts in trading_inbound.py
  • Add inbound routing tests for command pass-through, abort pass-through, and execution-error propagation in test_trading_inbound.py

v0.31.0 on 14th of March, 2026

v0.32.0 on 15th of March, 2026

  • Add TradingConfig MMVP runtime wiring surface and export it from package root in trading_config.py and __init__.py
  • Add Trading composition root that wires Event Spine, venue adapter, execution manager, and inbound facade in trading.py
  • Add basic MMVP lifecycle supervision to Trading with readiness gate and managed-account cleanup via start()/stop() in trading.py
  • Add focused tests for config validation/defaults, composition wiring, facade delegation, and lifecycle cleanup/no-leaked account tasks in test_trading_config.py and test_trading.py

v0.33.0 on 15th of March, 2026

  • Add startup sequencing with per-account phases in Trading.start() orchestrating replay, filters, WebSocket, and reconciliation in trading.py
  • Add ExecutionManager.replay_events(account_id, events) rebuilding trading state and runtime indices from event spine in execution_manager.py
  • Add ExecutionManager.active_symbols(account_id) returning symbols with open orders for filter preloading in execution_manager.py
  • Add VenueAdapter.load_filters(symbols) protocol method for batch exchange info preloading in venue_adapter.py
  • Add WebSocket user stream wiring routing executionReport messages to domain event flow via BinanceUserStream in trading.py
  • Add basic venue reconciliation querying live order/trade state and emitting correction events for diverged projections in trading.py
  • Add per-account readiness gating rejecting commands/aborts while account startup is in progress in trading.py
  • Add startup and readiness gating tests covering replay, filter preload, WebSocket wiring, and command rejection in test_trading.py

v0.34.0 on 16th of March, 2026

  • Add graceful shutdown sequence in Trading.stop() with cancel-orders, wait-for-terminal, close-streams phases in trading.py
  • Add _stopping flag gating command/abort rejection during shutdown in trading.py
  • Add ExecutionManager.get_open_orders(account_id) returning open orders snapshot for shutdown cancellation in execution_manager.py
  • Add TradingConfig.shutdown_timeout config field for terminal-state wait timeout in trading_config.py
  • Add shutdown sequence tests covering command rejection, abort rejection, and order cancellation in test_trading.py

v0.35.0 on 16th of March, 2026

  • Add shared spine fixture in tests/conftest.py for test harness consolidation
  • Remove duplicate spine fixture definitions from 6 test files

v0.36.0 on 16th of March, 2026

  • Remove dead TradeStatus.PAUSED enum member and docstring reference from enums.py
  • Add 26 tests for startup reconciliation (_reconcile_account, _reconcile_fills, _reconcile_terminal) and WebSocket handler (_on_execution_report, _convert_execution_report) in test_trading.py
  • Update test_domain_outcome.py to reflect PAUSED removal from _NON_TERMINAL list and test_trade_status_members expected set

v0.37.0 on 7th of April, 2026

  • Add ws_event_queue to _AccountRuntime for routing WebSocket events through account coroutine in execution_manager.py
  • Add enqueue_ws_event(account_id, event) method for single-writer compliant event routing in execution_manager.py
  • Add SAVEPOINT wrapper around dual-INSERT (dedup + event) for FillReceived atomicity in event_spine.py
  • Add _build_abort_outcome method for abort-specific outcome building from Order data in execution_manager.py
  • Add __setattr__ guards to Order validating qty > 0 and filled_qty >= 0 in order.py
  • Add __setattr__ guards to Position validating qty >= 0 and avg_entry_price >= 0 in position.py
  • Add cumulative_notional field to Order tracking running total of fill_qty × fill_price in order.py
  • Refactor _process_abort to compute VWAP from order.cumulative_notional / filled_qty instead of spine re-read in execution_manager.py
  • Update _account_loop to drain ws_event_queue before processing commands in execution_manager.py
  • Update _on_execution_report to enqueue events instead of applying directly in trading.py
  • Update _reconcile_fills and _reconcile_terminal to enqueue events instead of applying directly in trading.py
  • Update _process_abort to use Order fields from TradingState instead of _commands lookup in execution_manager.py
  • Update TradingState to clamp negative position qty to 0 after warning in trading_state.py
  • Update TradingState._update_order_on_fill to accumulate notional on each fill in trading_state.py
  • Add concurrency tests proving single-writer model prevents corruption in test_trading.py
  • Add atomicity test proving SAVEPOINT rollback on event insert failure in test_event_spine.py
  • Add restart abort test proving abort succeeds after replay in test_execution_manager.py
  • Add mutation guard tests for Order and Position in test_domain_core.py
  • Add VWAP accuracy tests in test_trading_state.py

v0.38.0 on 7th of April, 2026

  • Add nested dataclass hydration to _coerce with cached type hints for complex event types in event_spine.py
  • Add execution_params validation requiring SingleShotParams for SINGLE_SHOT mode in trade_command.py
  • Add precomputed _TYPE_HINTS dict at module load avoiding get_type_hints() per-hydration in event_spine.py
  • Add command_to_order index to _AccountRuntime for O(1) abort order lookup in execution_manager.py
  • Add _request_with_retry method extracting retry loop from request methods in binance_adapter.py
  • Add get_trading_state(account_id) and trade_id_for_command(command_id) public accessors in execution_manager.py
  • Refactor _signed_request and _api_key_request to use _request_with_retry callable factory in binance_adapter.py
  • Refactor Trading.start() event grouping to single-pass defaultdict accumulation in trading.py
  • Refactor Trading reconciliation and WebSocket handlers to use public ExecutionManager accessors in trading.py
  • Update WebSocket frame parsing to use orjson.loads with UTF-8 encoding in binance_ws.py
  • Remove TD-001, TD-003, TD-005, TD-007, TD-008, TD-010, TD-011, TD-012, TD-016 from TechnicalDebt.md
  • Add nested dataclass hydration test in test_event_spine.py
  • Add execution_params validation test in test_domain_commands.py

v0.39.0 on 16th of April, 2026

  • Add thread-safety assertion to enqueue_ws_event rejecting calls from non-event-loop threads in execution_manager.py
  • Add concurrency test proving thread-safety assertion and concurrent fill + command submission in test_td014_concurrency.py
  • Add Trading.loop property exposing asyncio event loop after start() in trading.py
  • Add per-account outcome routing via register_outcome_queue(), unregister_outcome_queue(), route_outcome() on Trading in trading.py
  • Add market_data_poller.py with MarketDataPoller — per-kline-size polling threads via TDW get_binance_spot_klines, runtime add_kline_size()/remove_kline_size() with reference counting
  • Add launcher.py with Launcher class orchestrating Praxis + Nexus + Limen in one process: asyncio loop thread, Trading, MarketDataPoller, per-account Nexus Manager threads, SIGINT/SIGTERM graceful shutdown
  • Add optional strategy_id passthrough from submit_command to Position via TradingState.trade_strategy_ids mapping
  • Add polars>=1.0 and quickstart_etl (TDW control plane) as runtime dependencies
  • Add vaquum_limen and vaquum-nexus as runtime dependencies (git install)
  • Remove resolved TD-002, TD-004, TD-013, TD-014 from TechnicalDebt.md
  • Update TD-016 to reflect resolved subitems (event loop, outcome routing, market data poller, launcher)
  • Add TD-017 for runtime kline_size registration
  • Add integration tests: launcher lifecycle, command submission, outcome routing, full cycle with strategy_id in test_launcher.py
  • Add 23 tests across new modules (723 total)

v0.40.0 on 18th of April, 2026

  • Add frozen HealthSnapshot dataclass with finite/non-negative invariants, ratio bounds, and consecutive_failures int check in health_snapshot.py
  • Add HealthTracker with rolling latency + success/failure samples, thread-safe record_request, and p99/failure-rate composition in health_tracker.py
  • Wire per-account HealthTracker into BinanceAdapter: _request_with_retry records latency and outcome once per call (retries internal); add rate_limit_utilization/clock_drift_ms properties; add sync_clock_drift() against /api/v3/time; add get_health_snapshot(account_id) that composes tracker + venue-wide metrics in binance_adapter.py
  • Add get_health_snapshot(account_id) -> HealthSnapshot to VenueAdapter Protocol in venue_adapter.py
  • Add Trading.get_health_snapshot(account_id) async method (start-required) so Manager can call via asyncio.run_coroutine_threadsafe(trading.get_health_snapshot(...), trading.loop) in trading.py
  • Add 46 tests across test_health_snapshot.py, test_health_tracker.py, test_binance_adapter.py (TestHealthSignals), and test_trading.py

v0.41.0 on 20th of April, 2026

  • BREAKING: Rewrite the launcher entrypoint for multi-account from a directory of manifests. MANIFESTS_DIR env var points at a directory of per-account manifest YAMLs; launcher enumerates them, pre-loads each to extract account_id and allocated_capital, looks up per-account Binance creds from BINANCE_API_KEY_<ACCOUNT_ID> / BINANCE_API_SECRET_<ACCOUNT_ID> (suffix normalized: non-alphanumeric → _, uppercased), builds one TradingConfig with all account credentials and one InstanceConfig per manifest
  • BREAKING: Remove allocated_capital from praxis.launcher.InstanceConfig — sourced from the loaded Nexus Manifest now (requires vaquum-nexus >= 0.28.0)
  • BREAKING: Drop allocated_capital and account_id args from the StartupSequencer call in _run_nexus_instance; drop the allocated_capital arg from the load_manifest call in _collect_kline_intervals (both match the new Nexus API)
  • BREAKING: Change env-var contract — drop ACCOUNT_ID, ALLOCATED_CAPITAL, MANIFEST_PATH, API_KEY, API_SECRET, STATE_DIR, STRATEGY_STATE_PATH; add MANIFESTS_DIR, STATE_BASE, STRATEGY_STATE_BASE, per-account BINANCE_API_KEY_<ACCOUNT_ID> / BINANCE_API_SECRET_<ACCOUNT_ID>
  • BREAKING: Bump minimum Python from 3.10 to 3.12. pyproject.toml (requires-python, ruff target-version, mypy python_version), all three CI workflows (pr_checks_tests.yml, pr_checks_mypy.yml, pr_checks_codeql.yml), and documentation (Setup-And-Verification.md) updated. Required by binancial which uses datetime.UTC (3.11+) and PEP 695 type statements (3.12+)
  • Add Dockerfile (Python 3.12-slim, installs git for git-sourced deps, non-root praxis user, entrypoint python -m praxis.launcher) and .dockerignore
  • Add render.yaml blueprint — single Render Web service, region: frankfurt, plan: starter, numInstances: 1, autoDeploy: false, healthCheckPath: /healthz, 10 GB persistent disk mounted at /var/lib/praxis. Per-account secrets declared sync: false
  • Add /healthz endpoint on the launcher's asyncio loop via aiohttp: returns 200 when Trading.started, the loop thread is alive, _stop_event is unset, and every Nexus thread is alive; 503 with a failures: list otherwise. Stopped first in _shutdown so Render sees unhealthy immediately on SIGTERM. Launcher.__init__ gains optional healthz_port: int | None = None
  • Resolve /healthz bind port from PORT (Render-injected), then HEALTHZ_PORT, then default 8080. Guard signal-handler registration on threading.main_thread() so tests can drive launch() from a worker thread
  • Route launcher main() logging through observability.configure_logging (structlog + orjson JSON to stdout) when LOG_FORMAT=json (default); LOG_FORMAT=text falls back to stdlib basicConfig for local dev. bind_context(epoch_id=...) before Launcher.launch() so every record carries epoch_id
  • Add optional db_path: Path | None = None to Launcher; when set, opens an aiosqlite connection on its own loop and builds the EventSpine internally (mutually exclusive with the caller-built event_spine path). Connection closed during shutdown
  • Migrate MarketDataPoller off tdw_control_plane.query.get_binance_spot_klines to binancial.compute.get_spot_klines (Binancial commit 634d5bd). Lazily build binance.client.Client(None, None) for public klines (no credentials needed); compute start_date as now - n_rows * kline_size seconds; convert the returned pandas DataFrame to polars. Swap pyproject.toml dep quickstart_etl @ git+.../tdw-control-plane → binancial @ git+.../Binancial
  • Lift delayed import polars as pl to the top of praxis/launcher.py
  • Add docs/Deployment-Render.md with full Render deployment runbook; rewrite docs/Launcher.md for the multi-account env-driven entrypoint + /healthz + JSON logging; add a "Two Different Health Concepts" section to docs/Health.md distinguishing HealthSnapshot from /healthz; list the new deployment guide in docs/README.md
  • Add tests/test_launcher_healthz.py (healthy-path + shutdown-path) and tests/test_launcher_json_logging.py (JSON parseable, bound-context field, text-fallback). Update tests/test_launcher.py _make_manifest_yaml to emit the required account_id: + allocated_capital: fields and drop allocated_capital= from InstanceConfig(...) call sites
  • Add 5 tests across test_launcher_healthz.py and test_launcher_json_logging.py (776 total)

v0.42.0 on 22nd of April, 2026

  • Add _build_nexus_instance_config(praxis_inst, manifest) in launcher.py — builds the per-account Nexus runtime InstanceConfig (account_id, venue='binance_spot', STPMode.CANCEL_TAKER, duplicate_window_ms=1000, capital_pct mirrored from manifest) consumed by the validator pipeline and translate_to_trade_command. Carries MMVP-conservative defaults; Stage-3 price thresholds and per-process rate limits intentionally unset (PT.1.4.1)
  • Add _build_validation_pipeline(nexus_config, capital_controller, *, health/platform/price snapshot providers) plus three default snapshot factories (_default_health_snapshot, _default_platform_snapshot, _default_price_snapshot). Wires all six validator stages — intake hooks built once via build_default_intake_hooks (preserving duplicate-window state across ticks), RiskStageLimits() / PlatformLimitsStageLimits() / HealthStagePolicy() MMVP-lenient (all thresholds unset), PriceStageLimits derived via build_price_stage_limits_from_config. Snapshot providers read on every validate() call so PT.5 / PT.3 can plug in richer state without rebuilding (PT.1.4.2)
  • Add _build_validation_context(action, strategy_id, ...) plus _build_enter_context / _build_exit_context private helpers in launcher.py — maps a strategy Action onto a ValidationRequestContext. ENTER derives order_notional from action.size * (action.reference_price or fallback_price_provider()) and returns None (logged) when no price is available; estimated_fees = order_notional * fee_rate (Binance taker default 0.001); strategy_budget from CapitalController.compute_strategy_budget. EXIT pulls notional and symbol from state.positions[action.trade_id] and returns None when the trade is missing. MODIFY logs a TD warning and returns None; ABORT returns None since submit_actions bypasses the validator for it. New module constants _DEFAULT_FEE_RATE = 0.001, _DEFAULT_SYMBOL = 'BTCUSDT' (PT.1.4.3)
  • Add _extract_kline_sizes(manifest) and _last_close_from_poller(poller, kline_sizes) helpers in launcher.py; rewire _run_nexus_instance so each account builds the Nexus InstanceConfig, CapitalController, six-stage ValidationPipeline, capital-pct-by-strategy map, fallback-price provider, build_context closure, and a submitter(actions, strategy_id) closure that calls submit_actions(...) with now=lambda: datetime.now(UTC). Both PredictLoop and TimerLoop receive action_submit=submitter. Switches to the new public sequencer.manifest / sequencer.instance_state accessors so ShutdownSequencer no longer reaches into private attributes (PT.1.4.4)
  • Add _build_strategy_context(state, manifest, strategy_id) in launcher.py — replaces the hardcoded (positions=(), capital_available=0, operational_mode=ACTIVE) stub. Returns a halted, zero-capital context when state or manifest is unavailable (HALTED rather than ACTIVE so strategies cannot act on a stub view as if all-clear); otherwise computes capital_available = max(manifest.capital_pool * spec.capital_pct / 100 − state.capital.per_strategy_deployed[sid], 0), filters positions to the strategy_id, and resolves operational_mode from state.strategy_modes[sid].state.mode (per-strategy override) or state.mode.mode (instance-level fallback). The runtime closure inside _run_nexus_instance reads sequencer.instance_state and sequencer.manifest on every call so reservations and operational-mode transitions show up between ticks (PT.2.2)
  • Wire OutcomeLoop into _run_nexus_instance. Builds a per-account command_strategy_ids: dict[str, str] registry; submitter captures submit_actions(...) results and records command_id → strategy_id on each SubmissionStatus.SUBMITTED. The registry key is the Praxis-assigned id returned by PraxisOutbound.send_command — that is also the id carried on the inbound TradeOutcome.command_id, so resolve_strategy_id is a simple dict lookup. OutcomeLoop instantiated with the same runner, praxis_inbound, state, context_provider, and submitter; started alongside predict_loop. ShutdownSequencer now receives outcome_loop=outcome_loop so the upstream PT.3.3 stop hook actually fires (PT.3.2)
  • Require vaquum-nexus >= 0.29.0 at runtime (StartupSequencer.instance_state / manifest accessors, nexus.core.outcome_loop.OutcomeLoop, nexus.strategy.action_submit.submit_actions)
  • Add 7 tests in test_launcher_nexus_instance_config.py covering account_id propagation, default venue / STPMode / duplicate-window, Stage-3 thresholds left None, capital_pct mirrored from manifest, empty-strategies case (PT.1.4.1)
  • Add 9 tests in test_launcher_validation_pipeline.py covering all six stages present, ENTER allow path, capital denial when reservation > pool, intake duplicate-command-id denial, price snapshot provider invoked per call, price denial when spread exceeds limit, MMVP defaults skip price checks, health provider invoked per call, decision-type sanity (PT.1.4.2)
  • Add 10 tests in test_launcher_validation_context.py covering ENTER ref-price path, ENTER fallback, ENTER no-price → None, fee math, strategy_budget formula, command-id auto-generation, EXIT from position (notional + symbol + side), EXIT missing trade → None, MODIFY → None, ABORT → None (PT.1.4.3)
  • Add 3 tests in test_launcher_submitter_e2e.py covering ENTER → validator allow → translate → praxis_outbound.send_command called once with the expected TradeCommand, EXIT for unknown trade_id dropped (no send_command), ABORT bypasses validator and triggers send_abort with reason='runtime_strategy_abort' (PT.1.4.4)
  • Add 9 tests in test_launcher_strategy_context.py covering state-None, manifest-None, unknown-strategy, full-budget, deployed-subtraction, over-deployed clamp, position filtering, per-strategy mode override, instance-mode fallback (PT.2.2); plus 2 tests in TestContextReflectsReservations covering capital_available drops by reservation notional + fees, and per-strategy isolation (PT.2.3)
  • Add 4 tests in test_launcher_outcome_flow_e2e.py covering registry populated on SUBMITTED, outcome dispatched via registry, orphan outcome silently skipped, returned-actions feedback loop (PT.3.4)
  • Add 50 tests across new files (826 total)
  • Split Launcher._run_nexus_instance into a 39-line orchestration step (build runtime → wait → ShutdownSequencer.shutdown) and a new private Launcher._build_nexus_runtime(inst, outcome_queue) -> _NexusRuntime method that wires every per-account component (StateStore, PraxisOutbound, StartupSequencer, NexusInstanceConfig, CapitalController, ValidationPipeline, build_context / submitter / context_provider closures, PredictLoop, TimerLoop, OutcomeLoop) and starts the loops. Adds a private _NexusRuntime dataclass to group the wired components for handoff to the lifecycle step

v0.43.0 on 23rd of April, 2026

  • Add Trading.set_on_trade_outcome(cb) — installs the on_trade_outcome callback after Trading() construction, closing the chicken-and-egg gap where TradingConfig.on_trade_outcome cannot reference the not-yet-built Trading instance. Always wraps the user callback in an async adapter that awaits the result when inspect.isawaitable(...), so coroutine functions, plain sync callables, functools.partial around coroutine functions, AsyncMock, and async-__call__ callable objects are all handled uniformly. Raises RuntimeError if called once Trading.start() has begun — the guard keys on self._started or self._loop is not None, so mid-startup swaps (after start() sets self._loop but before self._started) are also rejected (PT.4.1)
  • Add ExecutionManager.set_on_trade_outcome(cb) — the underlying setter that Trading.set_on_trade_outcome forwards to, storing the callback that ExecutionManager awaits when producing outcomes. The pre-start() guard lives on Trading.set_on_trade_outcome (the only public entry point); direct ExecutionManager calls reserved for tests stay unrestricted (PT.4.1)
  • Wire launcher.py _start_trading to install the outcome callback immediately after Trading() construction and before await trading.start(), and pre-register the per-account queue.Queue[TradeOutcome] for every instance in the same window. Without the pre-registration, Trading.start() reconciliation could enqueue WS events that produce terminal outcomes before _start_nexus_instances got around to calling register_outcome_queue, and those outcomes would be routed to no-such-queue and dropped. The same queue.Queue objects are reused when each Nexus thread builds its PraxisInbound. When TradingConfig.on_trade_outcome is unset (the default), the launcher registers Trading.route_outcome so per-account TradeOutcomes land on the queues consumed by the OutcomeLoop from Praxis #73. When TradingConfig.on_trade_outcome is set by the consumer, the launcher composes an async wrapper that calls route_outcome first and then awaits the user callback, so external telemetry / sink integrations are preserved alongside the runtime queue routing (PT.4.2)
  • Add 7 tests in test_trading.py covering: sync callback wrapped + invoked, async callback wrapped + invoked, functools.partial around an async callable wrapped + awaited (the always-wrap path the previous iscoroutinefunction branch would have misclassified), None clears, RuntimeError after Trading.start() completes, RuntimeError mid-start() (driven by patching event_spine.read to call the setter during replay), and register_outcome_queue + set_on_trade_outcome(route_outcome) end-to-end with the registered queue receiving the routed TradeOutcome (PT.4.3)
  • 833 tests passing (up from 826). Bumps vaquum-praxis 0.42.0 → 0.43.0

v0.44.0 on 23rd of April, 2026

  • Add _build_praxis_outbound(trading, loop) module-level helper in launcher.py that wires every outbound callable Nexus needs against the Praxis Trading singleton, including submit_abort_fn and get_health_snapshot_fn which the #72 / #73 launcher silently omitted. Without the wiring, PraxisOutbound.send_abort raised RuntimeError('submit_abort_fn not configured') at first use (regressing ShutdownSequencer abort escalation and the submit_actions ABORT path) and get_health_snapshot was unreachable. Trading.submit_abort is sync; the helper wraps it in an async adapter that matches the kwargs-shape PraxisOutbound.send_abort passes via run_coroutine_threadsafe, reconstructing a TradeAbort on the Praxis-loop side (PT.5.1)
  • Add _build_health_loop(praxis_outbound, state, account_id, interval_seconds=5.0) module-level helper in launcher.py that builds the per-account HealthLoop. Each tick pulls a HealthSnapshot via praxis_outbound.get_health_snapshot(account_id) (crosses the thread/loop boundary into Praxis via run_coroutine_threadsafe), evaluates it through HealthEvaluator(HealthThresholds()) with MMVP defaults (200/500/1000 ms latency warn/breach/halt, 3/5/10 consecutive failures, 10/20/40% failure rate, 70/85/90% rate-limit headroom, 500 ms clock drift), and updates state.mode on transition. The Praxis HealthSnapshot dataclass is field-compatible with the Nexus HealthSnapshot that HealthEvaluator.evaluate reads (same latency_p99_ms / consecutive_failures / failure_rate / rate_limit_headroom / clock_drift_ms attribute names), so the provider returns Praxis's type and the evaluator duck-types it without conversion (PT.5.2)
  • Add health_loop: HealthLoop field to _NexusRuntime in launcher.py; _build_nexus_runtime calls health_loop.start() right after outcome_loop.start() so per-account health tracking begins as soon as startup completes (PT.5.2)
  • Add new constant _DEFAULT_HEALTH_INTERVAL_SECONDS = 5.0 in launcher.py matching the RFC-4001 §Health cadence
  • Wire runtime.health_loop.stop() inside Launcher._run_nexus_instance immediately after self._stop_event.wait() returns and before building ShutdownSequencer. Mirrors the shutdown discipline of OutcomeLoop (which ShutdownSequencer stops via its PT.3.3 hook) without extending the sequencer signature — HealthLoop only mutates state.mode and doesn't share any external resource with the shutdown drain, so launcher-side stop is sufficient. HealthLoop.stop() is idempotent (PT.5.3)
  • Note on policy alignment: the validator HealthStagePolicy (Decimal-typed, driven by _build_validation_pipeline) and HealthEvaluator's HealthThresholds (float-typed, driven by _build_health_loop) are separate policy objects today — the two types have different field names and shapes, so they cannot be shared. Aligning them onto a single policy object is a post-MMVP concern tracked in Praxis issue #75
  • Add 4 tests in test_launcher_health_loop.py covering: the build helper returns a HealthLoop instance, a degraded snapshot (latency_p99_ms = 2000 ms exceeding HealthThresholds.latency_halt_ms = 1000 ms) flips state.mode.mode to HALTED with trigger == 'health' after tick_once(), healthy snapshot leaves state.mode untouched, and start()/stop() idempotency with a bounded-poll assertion that the worker thread actually ran (PT.5.4)
  • Add 4 tests in test_launcher_outbound_wiring.py covering: sanity check that the build helper returns a PraxisOutbound, end-to-end send_abort round-trip on a real loop thread reaching Trading.submit_abort with the reconstructed TradeAbort, get_health_snapshot round-trip reaching Trading.get_health_snapshot, and a documentation-style test showing a bare PraxisOutbound raises RuntimeError('submit_abort_fn not configured') today (pins the regression PT.5.1 fixes) (PT.5.1)
  • 841 tests passing (up from 833). Bumps vaquum-praxis 0.43.0 → 0.44.0

v0.45.0 on 27th of April, 2026

  • Bump vaquum-nexus pin from 3bda07e7 to f3fd91f1 (Nexus v0.32.0 — Vaquum/Nexus#45 merged), aligning Praxis with the Nexus paper-trade-readiness PT-FIX series and the new OrderContext.is_entry field
  • Add PT-FIX-1 lazy kline-size registration from wired sensors in launcher.py — kline sizes are now read from each WiredSensor.limen_manifest after sequencer.start() trains the manifest, so the poller is no longer empty at boot and signal_producer.produce_signal no longer raises ValueError("market_data is empty for sensor X") on every tick
  • Add PT-FIX-2 ShutdownSequencer.config wiring in launcher.py so on_shutdown actions execute through translate_to_trade_command instead of failing with RuntimeError('config not configured')
  • Add PT-FIX-3 testnet routing for MarketDataPoller in launcher.py when BINANCE_TESTNET=true
  • Add PT-FIX-4 Limen pin alignment to v2.4.3 matching Nexus
  • Add PT-FIX-6 outcome translation seam in outcome_translator.py — Praxis TradeOutcome is mapped to the Nexus shape on the per-account queue boundary so OutcomeLoop consumes the right type
  • Add PT-FIX-7 outbound execution_params → SingleShotParams wrapping via launcher.py_build_praxis_outbound and command_translator.pybuild_single_shot_params so submit_command reaches the Praxis venue with the right param object
  • Add PT-FIX-8 per-account OutcomeProcessor wiring in launcher.py (process_outcome closure built from the per-account CapitalController + InstanceState + StateStore)
  • Add PT-FIX-10 lock around TradingState.positions reads in trading_state.py — pairs with the writer-side lock to prevent partial-snapshot reads during concurrent fill ingestion
  • Add PT-FIX-11 BINANCE_TESTNET documentation in docs/Launcher.md optional-env table
  • Add PT-FIX-12 fixed pins for vaquum-nexus and binancial in pyproject.toml (no more floating main refs)
  • Add PT-FIX-13 BinanceAdapter post-close session re-creation refusal in binance_adapter.py — once close() runs, subsequent _session_factory() calls raise instead of silently re-opening a session
  • Add PT-FIX-14 sync Trading.get_health_snapshot_sync(account_id) API in trading.py (consumed by _build_health_loop in launcher.py) so the Nexus HealthLoop reads snapshots without crossing the asyncio boundary on every tick
  • Add PT-FIX-16 on_startup action drain in launcher.py — actions returned from Strategy.on_startup now flow through the same submit_actions pipeline as runtime actions
  • Add PT-FIX-19 strategies_base_path prepend to sys.path BEFORE _wire_sensors in launcher.py so user strategy packages resolve during sensor wiring
  • Add PT-FIX-20 ENTER Position pre-population in launcher.py — _ensure_entry_position registers the Position(trade_id=command_id, …) BEFORE the first FILL outcome lands, so OutcomeProcessor._grow_position finds the position record by forced_trade_id instead of raising "entry fill for missing position"
  • Add PT-FIX-21 venue-adapter close on Trading.stop() in trading.py so the HTTP session is released
  • Add PT-FIX-22 /healthz listener kept up across shutdown in launcher.py — Render now gets a clean 503 with failures: payload on SIGTERM instead of connection-refused
  • Add PT-FIX-23 hold _positions_lock through the field-mutation branches in trading_state.py (_update_position_on_fill insert, accumulate, and reduce paths; plus _on_trade_closed pop)
  • Add PT-FIX-24 set _stop_event on per-instance build failure in launcher.py so launch() unwinds cleanly when _build_nexus_runtime raises
  • Add PT-FIX-28 shared positions_lock in launcher.py — state.positions iteration in the _NexusRuntime and the terminal-cleanup del in process_outcome now hold the same lock so the dict doesn't mutate mid-iteration
  • Add PT-FIX-29 atomic command_strategy_ids + command_contexts writes under shared command_registry_lock in launcher.py
  • Add PT-FIX-30 boot-time orphan CommandAccepted reconciliation in execution_manager.py (reconcile_orphan_commands) so stranded Nexus reservations get released after a crash
  • Add PT-FIX-31 OutcomeProcessor threading through _NexusRuntime into ShutdownSequencer in launcher.py so shutdown EXIT FILLs decrement state.positions instead of being silently dropped
  • Add PT-FIX-35 CapitalController.reconcile_at_boot() call in launcher.py _build_nexus_runtime so stranded in_flight_order_notional / working_order_notional / reservation_notional from a crashed prior boot are reset
  • Add PT-FIX-39 bounded OrderedDict LRU for OutcomeTranslator's terminal-dedup table in outcome_translator.py — replaces an unbounded set with a default cap of 10000 + FIFO eviction
  • Add PT-FIX-41 pass state.positions.values() to reconcile_at_boot in launcher.py _build_nexus_runtime so per_strategy_deployed is rebuilt from live positions (without it, the persisted per-strategy attribution still includes pre-crash reservation/in-flight/working amounts and the next check_and_reserve permanently denies all new ENTERs)
  • Add PT-FIX-44 process_outcome threading through _NexusRuntime to ShutdownSequencer.non_pending_outcome_handler in launcher.py so pre-shutdown outcomes drained by _poll_until_terminal are routed through the same outcome handler the OutcomeLoop would have used
  • Thread is_entry through _build_order_context in launcher.py — is_entry=action.action_type == ActionType.ENTER matches the new required OrderContext.is_entry field in Nexus 0.32.0. Decouples intent from venue side so short-position EXITs (BUY-to-cover) are no longer mis-routed through OutcomeProcessor's entry path
  • Add TD-021..024 (round-6/7 audit deferred edge cases) to docs/TechnicalDebt.md
  • 925 tests passing (up from 841). Bumps vaquum-praxis 0.44.0 → 0.45.0

v0.46.0 on 29th of April, 2026

  • Add ExecutionManager._emit_ws_outcome(runtime, event) invoked from _account_loop after every successful trading_state.apply() — for FillReceived / OrderCanceled / OrderRejected / OrderExpired events, derives cumulative state from the now-updated Order projection (filled_qty, cumulative_notional, status), maps OrderStatus → TradeStatus, and forwards to _build_outcome so spine persistence + _on_trade_outcome callback fire on the WS-driven path. Pre-fix _build_outcome was only invoked from _process_command, so a SINGLE_SHOT LIMIT order returning no immediate_fills exited at PENDING and any subsequent venue WS fill was invisible to Nexus — capital stayed in working_order_notional, the launcher's per-account process_outcome closure never fired, and any operator LIMIT strategy silently lost every fill (BLOCKER-D)
  • Skip the _emit_ws_outcome emission when the command_id is already in _terminal_commands to dedupe against _process_command's immediate-fill emission for MARKET orders that fill inside submit_order.immediate_fills
  • Add zombie cleanup in TradingState._update_position_on_fill opposite-side branch — when new_qty == _ZERO, del self.positions[key] and pop self.trade_strategy_ids[event.trade_id]. Pre-fix the position stayed as a qty=0 zombie because _on_trade_closed (the only deletion path) only fires on TradeClosed events emitted from _build_outcome. The zombie rode into the next snapshot via pull_positions and the spine, then the next Nexus boot's _reconcile_capital imported it and reconcile_at_boot(positions=state.positions.values()) rebuilt per_strategy_deployed from the zombie → attribution mismatch denial → every ENTER for the rest of the boot rejected. Closes the Praxis-side ingress for the failure mode tracked as BLOCKER-B in Nexus (BLOCKER-E)
  • Wire StateStore.append_mutation(state) call into the launcher's _build_nexus_runtime.process_outcome closure — fires after each successful state-mutating OutcomeProcessor.process where position_updated is true, so a SIGKILL/OOM/container restart between checkpoints recovers to the most recent terminal outcome rather than rolling back to the last clean shutdown. Persistence failures are caught and logged at exception level so an outage never aborts the outcome flow. Cadence rationale: per-terminal-outcome was chosen over a periodic snapshot thread because outcomes are the only sites that mutate position_notional / per_strategy_deployed and the runtime's state-mutating events are sparse enough at MMVP order rates that I/O cost is negligible (BLOCKER-B.1, B.2)
  • Update tests/test_launcher.pytest_full_cycle_submit_fill_outcome_shutdown to assert the corrected end state — WS fill produces FILLED TradeOutcomeProduced on the spine and TradeClosed deletes the position. Pre-fix the test asserted the qty=0 zombie behavior as a passing case
  • Add 6 new tests in TestEmitWsOutcome (partial fill emits PARTIAL, full fill emits FILLED terminal, cancel-after-partial emits both PARTIAL+CANCELED with correct filled_qty, EXPIRED branch emits terminal EXPIRED outcome with reason=None, REJECTED branch emits terminal REJECTED outcome with reason=event.reason, terminal-command WS echo does not double-emit), 5 new tests in test_trading_state.py (position removed when WS exit drives qty to zero, trade_strategy_id removed at the same time, partial close regression, overclose deletion path, snapshot_positions excludes WS-closed position), and 1 new smoke test in test_launcher_persistence_wiring.py (asserts state_store.append_mutation is called from _build_nexus_runtime). Total Praxis tests: 937
  • Note: vaquum-nexus pin remains at f3fd91f1 (Nexus v0.32.0 / Vaquum/Nexus#45 merge) for now. A follow-up commit on this branch will bump the pin to the post-merge SHA of Vaquum/Nexus#47 (the Nexus v0.33.0 PR carrying BLOCKER-A / B.3-4 / C; tracked in issue Vaquum/Nexus#46) once that PR lands. Until then Praxis tests run against the editable Nexus install in the local venv, which already carries the BLOCKER-A / B.3/4 / C work
  • Tighten the append_mutation trigger in launcher.pyprocess_outcome from position_updated or capital_updated to position_updated only — ACK outcomes set capital_updated=True but mutate only working_order_notional / in_flight_order_notional book-keeping that reconcile_at_boot rebuilds on next boot, so persisting a snapshot per ACK is wasted I/O. Position-level state IS the unique-to-mid-run-persistence concern (greybeard pre-PR review)
  • Replace fall-through else: status = TradeStatus.REJECTED in _emit_ws_outcome with explicit elif isinstance(event, OrderRejected) plus a RuntimeError guard on the now-unreachable else; a future event subclass added to the outer isinstance filter without updating the chain now fails loudly instead of silently routing through the REJECTED branch and exploding on missing reason (greybeard pre-PR review)
  • Add docs/TechnicalDebt.md entry TD-028 — _on_trade_closed WARNING fires on the WS-driven LIMIT EXIT happy path because the BLOCKER-E zombie cleanup deleted the position before TradeClosed reaches the handler. Operational noise; both deletion paths are safe (PR #80 review)
  • In ExecutionManager.replay_events, reconstruct each non-terminal TradeCommand from its OrderSubmitIntent event and write it to self._commands[command_id] so post-restart WS fills on resting LIMIT orders reach _emit_ws_outcome → _on_trade_outcome rather than being silently dropped at the cmd is None early-return. Also pop _commands[command_id] when a TradeOutcomeProduced terminal is encountered during replay (memory bound + dedup against the post-restart WS echo path). MakerPreference.NO_PREFERENCE / STPMode.NONE / ExecutionMode.SINGLE_SHOT defaults are used for the fields not on OrderSubmitIntent — these fields are not read by _emit_ws_outcome's downstream chain (Vaquum/Praxis#79 MAJOR-F, Copilot PR #80 review)
  • In ExecutionManager._emit_ws_outcome, clamp the emitted filled_qty to cmd.qty before calling _build_outcome and log a WARNING when clamping fires. Pre-fix order.filled_qty could exceed cmd.qty due to duplicate / out-of-order venue fills or venue rounding past target, tripping TradeOutcome.__post_init__'s filled_qty <= target_qty invariant — the resulting raise was caught + logged by _account_loop and the outcome was dropped, so Nexus never saw the fill (Copilot PR #80 review)
  • Downgrade TradingState._on_trade_closed 'no position for TradeClosed' log from WARNING to DEBUG — fires on the WS-driven LIMIT EXIT happy path because the BLOCKER-E zombie cleanup deleted the position before TradeClosed reaches the handler. Both deletion paths are safe; the WARN level was misleading operators (closes TD-028 in code rather than as deferred TD) (Copilot PR #80 review)

v0.47.0 on 30th of April, 2026

  • Add command_strategy_ids early-write in _build_nexus_runtime's submitter — registers the strategy_id at the TOP of the for-loop body (before capital_controller.send_order / _ensure_entry_position / _build_order_context) so a fast venue ACK arriving during the post-send_command processing window resolves correctly. Pre-fix the registry write happened AFTER all those calls; OutcomeLoop popped a fast ACK, called resolve_strategy_id, got None, dropped the outcome silently. order_ack never ran → order stayed IN_FLIGHT → subsequent FILL → INVARIANT_BREACH → fill silently dropped on capital side, position not grown, capital permanently stuck in in_flight_order_notional (MAJOR-P)
  • Pass positions_lock=runtime.positions_lock to OutcomeProcessor construction. Pre-fix the lock was created and threaded into readers (_build_strategy_context) and entry-placeholder writers (_ensure_entry_position) but never into OutcomeProcessor — the writer mutated state.positions unguarded against PredictLoop's lock-protected iteration → silent strategy-tick drops via RuntimeError: dictionary changed size during iteration. Updated _build_strategy_context docstring (TD-W) to reflect actual post-MAJOR-J locking semantics (MAJOR-J + TD-W)
  • Change process_outcome's state_store.append_mutation gate from result.success and result.position_updated to result.success and (result.position_updated or result.capital_updated) so ACK / non-fill REJECT / non-fill CANCEL outcomes (which mutate in_flight_order_notional, working_order_notional, per_strategy_deployed but return position_updated=False) persist to WAL between checkpoints (MAJOR-M)
  • Pass capital_controller=capital_controller to submit_actions so the rollback path can call controller.release_reservation(reservation_id) on translate / send_command failure. Praxis-side wiring for Vaquum/Nexus MAJOR-G
  • Pass positions_lock=runtime.positions_lock to ShutdownSequencer so _dispatch_shutdown's snapshot iteration of state.positions.values() honors the same lock that PredictLoop and OutcomeProcessor use. Praxis-side wiring for Vaquum/Nexus MAJOR-S
  • Wire state_store.refresh_rolling_losses into HealthLoop via the new _build_health_loop state_store parameter so 24h/7d/30d rolling-loss windows decay as old loss events age out. Without this wiring the Nexus-side rolling-loss enforcement (Vaquum/Nexus MAJOR-H) would be over-conservative because the fields would only ever grow
  • Pop command_strategy_ids[outcome.command_id] under command_registry_lock when capital_controller.send_order returns failure post-MAJOR-P — the entry was previously left as a zombie, accumulating one per failed send_order. Tighten test_strategy_id_resolvable_during_send_order_concurrent to assert the writer thread completed without exception and produced 200 entries (Greybeard pre-PR review)
  • Add 6 new tests across test_launcher_command_registry_lock.py (TestMajorPRegistryRaceWindow: strategy_id-set-before-send_order pin + concurrent invariant), test_launcher_persistence_wiring.py (AST guard for capital_updated in the append_mutation gate). Total Praxis tests: 942
  • Add docs/TechnicalDebt.md entries TD-029 through TD-035 — defer round-13/14 audit findings that are not paper-trade-fatal (command_contexts leak on raise, OutcomeTranslator fee_rate=0 latent, REJECTED branch asymmetry, _build_partial divide-by-zero risk, ExecutionManager registries grow without purge, unbounded queues, _emit_ws_outcome clamp drops surplus venue fill)

v0.48.0 on 1st of May, 2026

  • Add cumulative_notional: Decimal field to TradeOutcome (default _ZERO). Construction-time validators now reject (a) negative cumulative_notional, (b) non-zero cumulative_notional when filled_qty == 0, and (c) zero cumulative_notional when filled_qty > 0. Carries the venue-side Order.cumulative_notional (sum of qty * price across fills) verbatim so OutcomeTranslator does not have to reverse-derive it from filled_qty * avg_fill_price, eliminating a precision-lossy round trip that on multi-partial sequences could flip delta_notional negative and silently drop the partial fill at ExecutionManager._build_outcome (called from _process_command / _process_abort / _emit_ws_outcome) (FINAL-MAJOR-07)
  • Hold command_registry_lock across the entire submitter critical section in _build_nexus_runtime: command_strategy_ids write → capital_controller.send_order → _ensure_entry_position → _build_order_context → command_contexts write. Pre-fix the registry mutations were under separate lock acquisitions with venue I/O in between; a fast venue ACK or terminal non-fill landing in that window resolved the strategy_id, found command_contexts.get(...) was None, and silently dropped the outcome — stranding _orders[command_id] and inflating capital aggregates (FINAL-MAJOR-01)
  • Pass positions_lock=positions_lock to submit_actions so the EXIT-action pending_exit += accumulator in praxis/strategy/action_submit.py is serialized against PredictLoop's lock-protected position iteration (Praxis-side wiring for Vaquum/Nexus FINAL-MAJOR-03)
  • Pass capital_controller=runtime.capital_controller to ShutdownSequencer so _final_checkpoint wraps serializer iteration in positions_lock + CapitalController.lock_cm() and freezes capital aggregates during shutdown (Praxis-side wiring for Vaquum/Nexus FINAL-MAJOR-05)
  • Attach state.risk.lock = positions_lock in _build_nexus_runtime so Nexus's RiskState.lock_cm() serializes per_strategy mutations in OutcomeProcessor._update_strategy_risk_state against validator-side to_risk_check_metrics() reads (Praxis-side wiring for Vaquum/Nexus FINAL-MAJOR-02)
  • Add hasattr(state.risk, 'lock') guard before the state.risk.lock = positions_lock assignment so the launcher fails loud if the pinned Nexus version drops the transient lock slot, instead of silently no-op'ing the FINAL-MAJOR-02 cross-thread serialization (Greybeard pre-PR review)
  • Carry cumulative_notional through ExecutionManager._process_command (immediate-fill path), _process_abort (abort path), _emit_ws_outcome (WS-driven path), and _build_outcome (shared TradeOutcome construction). The immediate-fill path scales total_notional = total_notional * cmd.qty / filled_qty on the overfill clamp so the emitted cumulative_notional matches the clamped filled_qty (one-shot emission; per-emission consistency wins). The WS path forwards order.cumulative_notional verbatim with NO scaling on overfill clamp so cumulative_notional stays monotonic across PARTIAL → terminal emission sequences for the same command (multi-emit; monotonicity wins). TD-037 documents the resulting asymmetry between the two paths (FINAL-MAJOR-07)
  • Bump vaquum-nexus pin from f4eab11 (PR #49 merge) to 7a634b4 (the squash-merge SHA of Vaquum/Nexus#55 on main, which lands paper-trade-readiness round-17). Initial pin during PR review pointed at the unmerged round-1 branch HEAD 31d4fa4; final pin re-bumped to the post-merge SHA after Nexus #55 merged. The pinned Nexus version exposes RiskState.lock, CapitalController.lock_cm(), and the outcome_id-aware WAL codec required by FINAL-MAJOR-02 / 05 / 07
  • Add TestFinalMajor01AtomicRegistration (2 tests) pinning the no-torn-observation invariant under contention and the reader-blocks-until-both-registries-populated guarantee. Add TestFinalMajor07TranslatorUsesVenueCumulativeNotional (2 tests) pinning that the translator emits non-negative delta_notional on drift-inducing partial sequences and that the per-fill emitted notional sums byte-for-byte to the venue cumulative
  • Update tests/test_domain_outcome.py, tests/test_launcher.py, and tests/test_trading.py to populate cumulative_notional on every full-fill TradeOutcome construction so the new positive-fill invariant validator does not reject existing fixtures
  • Add docs/TechnicalDebt.md entries TD-037 (overflow-clamp cumulative_notional drift), TD-038 (command_registry_lock → CapitalController._lock and command_registry_lock → positions_lock lock-order pair from the FINAL-MAJOR-01 atomic critical section), and TD-039 (TestFinalMajor01AtomicRegistration exercises a local helper, not the real submitter closure)

v0.49.0 on 3rd of May, 2026

Add

  • Add TRADE_MODE env var to the launcher's _REQUIRED_ENV_VARS and new _resolve_trade_mode(env) helper mapping paper / live to the in-code REST + WS URL pair from praxis/infrastructure/binance_urls.py. Drops VENUE_REST_URL, VENUE_WS_URL, and BINANCE_TESTNET from the env contract — the operator has no surface to route the order path to mainnet while believing they are on testnet (round-18 MAJOR-001)
  • Add DuplicateClientOrderIdError and OrderSubmitTimeoutError to venue_adapter.py; both carry client_order_id. Add idempotent: bool = True kwarg to BinanceAdapter._request_with_retry and _signed_request. Add _post_order helper that runs idempotent=False for order POSTs and translates TransientError → OrderSubmitTimeoutError, OrderRejectedError(venue_code=-2010) → DuplicateClientOrderIdError. Add _rescue_by_client_order_id and _record_submit_failed helpers in ExecutionManager._process_command: on either rescue-trigger error, query the venue by client_order_id; on confirmed live order, append OrderSubmitted and continue normal lifecycle; on confirmed-not-found or query failure, emit REJECTED via the shared sink (round-18 MAJOR-002)
  • Add LocalOrderRejectedError(OrderRejectedError) to venue_adapter.py carrying venue_code=-1013 and the rejection reason. BinanceAdapter._validate_order raises this typed error for every filter violation (lot_step / lot_min / lot_max / tick_size / min_notional) instead of plain ValueError, so the existing except VenueError flow in ExecutionManager._process_command synthesizes OrderSubmitFailed and a REJECTED TradeOutcome (round-18 MAJOR-007)
  • Add Class B orphan-reconcile path to ExecutionManager.reconcile_orphan_commands: scan for OrderSubmitIntent events without OrderSubmitted / OrderSubmitFailed / terminal TradeOutcomeProduced follow-up via a client_order_id → command_id map built during the same scan; synthesize REJECTED for these as boot-time defense-in-depth (round-18 MAJOR-007 M07.2)
  • Add OutcomeAcked(account_id, timestamp, outcome_id) event to praxis/core/domain/events.py; registered in EventSpine _EVENT_REGISTRY; no-op in TradingState.apply. Add Launcher._append_outcome_acked invoked from the process_outcome closure after OutcomeProcessor.process returns success — the durable consumption marker that future boot replay-from-spine will use as the un-acked filter (round-18 MAJOR-004 part B)
  • Add ExecutionManager._dispatch_outcome_with_retry shared helper replacing all three _on_trade_outcome swallow-and-log call sites (_emit_orphan_rejection, _emit_ws_outcome, _build_outcome); bounded retry up to _OUTCOME_CALLBACK_MAX_ATTEMPTS=3 with exponential backoff _OUTCOME_CALLBACK_BASE_DELAY=0.5 before exhausting, with the TradeOutcomeProduced spine record as the durable evidence on full failure (round-18 MAJOR-004 part B)
  • Add StaleMarketDataError to MarketDataPoller; per-cache fetched_at stamp on _fetch success; max_age_seconds: dict[int, float] constructor override (default 2 * kline_size); get_market_data raises on stale; is_stale(kline_size) non-raising checker; cleanup hooks in stop and remove_kline_size (round-18 MAJOR-005)
  • Add StaleMarketDataError swallow + fall-through in _last_close_from_poller; when every kline_size is empty or stale the helper returns None so the validator's PRICE stage rejects ENTERs cleanly instead of sizing against ancient prices (round-18 MAJOR-005 M05.5)
  • Add recover_orphaned_order invocation in the process_outcome no-context terminal cleanup branch so the orphan order tracked in Nexus _orders[command_id] is released alongside the registry pops (round-18 MAJOR-003 M03.1 cross-repo wiring)
  • Add 12 deferred-finding entries (TD-040..TD-051) to docs/TechnicalDebt.md covering: EventSpine SQLite PRAGMAs (TD-040); per-outcome append_mutation failure not escalated (TD-041); _reconcile_account does not query venue open orders absent from spine (TD-042); cross-repo state mismatch undetected at boot (TD-043); shutdown EXIT silently fails when launcher loop is dead (TD-044); symbol filters not loaded for fresh accounts (TD-045); MARKET ENTER reservation lacks slippage buffer (TD-046); no boot-time venue free-balance probe (TD-047); command routing keyed by command_id only (TD-048); no multi-account integration test for outcome routing (TD-049); EventSpine account_id payload-only (TD-050); PlatformLimitsStageLimits constructed empty in launcher (TD-051)
  • Add 2 scope-deferral TD entries (TD-052, TD-053) to docs/TechnicalDebt.md: boot replay-from-spine for unconsumed TradeOutcomeProduced events requires OutcomeTranslator determinism prework (TD-052); HealthLoop demote to REDUCE_ONLY on sustained market-data failure requires HealthSnapshot field plumbing (TD-053)
  • Add 2 pre-PR / PR-review TD entries (TD-054, TD-055) to docs/TechnicalDebt.md: the synchronous-block tax on _append_outcome_acked under loop overload (TD-054); _rescue_by_client_order_id returns immediate_fills=() even when the rescued order is FILLED / partially-filled — currently relies on WS reconcile to back-fill the missing fill information (TD-055)
  • Add new test files: test_launcher_trade_mode.py (6 tests pinning _resolve_trade_mode); test_binance_adapter_post_order_rescue.py (5 tests pinning POST timeout + duplicate-clientOrderId rescue triggers); test_execution_manager_rescue.py (5 tests pinning rescue-by-clientOrderId behavior); test_launcher_orphan_recovery_wiring.py (1 AST test pinning recover_orphaned_order wiring); test_execution_manager_filter_orphan.py (6 tests pinning filter-violation REJECTED + intent-without-followup orphan); test_execution_manager_outcome_retry.py (4 tests pinning _dispatch_outcome_with_retry); test_launcher_outcome_acked_wiring.py (1 AST test pinning _append_outcome_acked wiring); test_market_data_poller_freshness.py (10 tests pinning cache freshness + fallback guard)

Fix

  • Fix BinanceAdapter order POST retrying transport-level failures with the same client_order_id — pre-fix a TimeoutError after the venue had accepted left the retry POSTing a duplicate that Binance returned as -2010, classified as REJECTED, while the original order stayed live and the translator's terminal_emitted state suppressed the eventual late fill (round-18 MAJOR-002)
  • Fix BinanceAdapter._validate_order raising plain ValueError for filter violations — pre-fix the ValueError escaped the except VenueError branch and the worker's broad except Exception swallowed it; CommandAccepted and OrderSubmitIntent were persisted but no terminal outcome reached Nexus, capital stayed parked in in_flight_order_notional, and reconcile_orphan_commands did not flag it because the existing logic counted OrderSubmitIntent as a "follow-up" (round-18 MAJOR-007)
  • Fix ExecutionManager._build_outcome on_trade_outcome callback exception being logged once and swallowed — pre-fix TradeOutcomeProduced was durably persisted on the spine but the consumer (Nexus) was unaware of the delivery failure (round-18 MAJOR-004 part B)
  • Fix MarketDataPoller.get_market_data returning the previous DataFrame indefinitely after _fetch swallowed exceptions — strategies and fallback_price_provider could trade on hours-old klines after Binance public REST/testnet outages with no signal (round-18 MAJOR-005)
  • Fix Launcher._append_outcome_acked reaching into Trading._event_spine private attribute; switched to the public Trading.event_spine property (Greybeard pre-PR review)

v0.50.0 on 5th of May, 2026

  • Add .github/workflows/build_image.yml — builds the existing Dockerfile on push to main (and on workflow_dispatch), pushes to ghcr.io/vaquum/praxis via docker/login-action@v3 + docker/build-push-action@v6 with GitHub Actions docker layer caching (cache-from: type=gha + cache-to: type=gha,mode=max). Tagging: :sha-<commit> is always published; :<version> (parsed from pyproject.toml's version = ... field) and :main are published only when github.ref == 'refs/heads/main' so a workflow_dispatch from a feature branch cannot overwrite the floating tags with a non-main image. Auth uses secrets.GITHUB_TOKEN against the calling workflow's identity. Mirrors the build-job pattern from Vaquum/experiment_runner's deploy.yml minus the deploy-to-host step (deferred until the operator runbook for /opt/praxis/ lands)
  • Bump vaquum-nexus git+https pin from Nexus 0.38.0 main HEAD 1097d18e7e5a29ffcb212dee33b703e31f5c39ac to Nexus 0.39.0 main HEAD 52ed0f0a4b7859b941191f85b73f4aaa22911226 (Vaquum/Nexus#59 — example logreg_binary_evsfd strategy + manifest + README for paper-trade bring-up under examples/)

v0.51.0 on 5th of May, 2026

  • Bump vaquum_limen git+https pin from v2.4.3 to v3.0.1. Limen v3 introduced a Manifest API rename (RFC-1004) and a class-based limen.targets module replacing the v2 function-based target builders. Praxis production code does not import from limen directly (verified via grep -rn "^from limen\|^import limen" praxis/ — zero hits), so no Praxis code change is required; the pin bump propagates to the Docker image so Praxis's bundled Nexus runtime resolves to the same Limen version Nexus pins independently. SFD modules feeding Nexus's Trainer (e.g. the BtcLogRegEVSFD example bundle) must be re-trained against v3 limen via experiment_runner before paper-trade deploy; the bundle re-train is upstream and decoupled from this pin bump
  • Bump vaquum-nexus git+https pin from Nexus 0.39.0 main HEAD 52ed0f0a4b7859b941191f85b73f4aaa22911226 to Nexus 0.40.0 main HEAD f4cfa059554cf30c26a45ead7af56ca6501d1674 (Vaquum/Nexus#60 — Limen v3.0.1 pin bump + 10-test Trainer integration-contract suite covering __init__ / train parameter names, kinds, defaults, return type via typing.get_type_hints + get_origin / get_args, and _data / _manifest private-attribute assignments via AST walk of inspect.getsource(Trainer.__init__))

v0.52.0 on 5th of May, 2026

Add

  • Add WebSocket-API user-data-stream subscription flow to BinanceUserStream replacing the retired REST listen-key endpoints. New _subscribe helper sends a signed userDataStream.subscribe.signature request frame (HMAC-SHA256 over alphabetically-sorted apiKey / recvWindow / timestamp params), awaits the ack within _SUBSCRIBE_ACK_TIMEOUT_SECONDS = 10.0, and stores subscriptionId for the unsubscribe-on-close path. _clean_setup_connection opens the WS-API connection, calls _subscribe, and tears down the local ws on subscribe failure. _receive_loop peels the WS-API {"event": {...}} envelope before dispatching to on_message; non-event frames are debug-logged and skipped. close sends userDataStream.unsubscribe with params: {subscriptionId: <id>} (best-effort) before closing the ws. Subscribe ack validation rejects non-TEXT frames, non-JSON payloads, non-200 status, missing subscriptionId, and bool values that would otherwise pass isinstance(int) (Greybeard pre-PR review)
  • Add MAINNET_WS_API_URL = 'wss://ws-api.binance.com:443/ws-api/v3' and TESTNET_WS_API_URL = 'wss://ws-api.testnet.binance.vision/ws-api/v3' to praxis/infrastructure/binance_urls.py; both exported via __all__
  • Add ws_api_url: str constructor parameter to BinanceAdapter stored as self._ws_api_url; consumed by BinanceUserStream._clean_setup_connection to pick the WS-API endpoint
  • Add venue_ws_api_url: str = TESTNET_WS_API_URL field to TradingConfig with non-empty validation in __post_init__; defaults to testnet so existing test fixtures keep working
  • Add WS-API URL to _resolve_trade_mode return tuple — now (rest_url, ws_url, ws_api_url, testnet_flag) — and thread venue_ws_api_url into TradingConfig and into the BinanceAdapter constructor inside Trading.__init__; operators using TRADE_MODE=paper / TRADE_MODE=live automatically pick the matching WS-API URL with no env-var surface change
  • Add docs/TechnicalDebt.md entry TD-059 (BinanceUserStream._clean_setup_connection leaks freshly-opened ws on CancelledError between ws_connect and self._ws = ws assignment; pre-existing pattern preserved from listen-key-era code)

Fix

  • Fix BinanceUserStream crashlooping on container start with HTTP 410 from POST /api/v3/userDataStream — Binance retired the listen-key REST endpoints (POST / PUT / DELETE /api/v3/userDataStream) and now requires WS-API userDataStream.subscribe.signature over the WS-API connection. Removed _create_listen_key, _keepalive_listen_key, _close_listen_key and the now-orphaned _api_key_request helper from BinanceAdapter. Removed _keepalive_loop, _keepalive_task, _listen_key, keepalive_interval_seconds, _DEFAULT_KEEPALIVE_INTERVAL_SECONDS, and _build_ws_url from BinanceUserStream — the WS-API connection multiplexes subscribe + push events on the same socket and aiohttp's auto-pong handles the 20s server pings, so no separate keepalive task is required (closes #93)
  • Fix lint drift in pre-existing test fixtures: asyncio.TimeoutError → builtin TimeoutError in praxis/infrastructure/binance_ws.py and tests/test_binance_ws.py; __all__ sort order in praxis/infrastructure/binance_urls.py (Greybeard pre-PR review)

v0.53.0 on 6th of May, 2026

  • Bump vaquum_limen git+https pin from v3.0.1 to v3.0.3 (Vaquum/Limen#500). Limen v3.0.3 makes Trainer.__init__ hermetic per-experiment: the SFD module named by metadata.json["sfd_module"] is now loaded by preferring a <sfd_module>.py file inside experiment_dir (via importlib.util.spec_from_file_location + module_from_spec, no sys.path mutation) before falling back to importlib.import_module, with path-traversal hardening (segment-by-segment isidentifier() validation) on the name. Praxis production code does not import from limen directly (verified via grep -rn "^from limen\|^import limen" praxis/ — zero hits), so no Praxis code change is required; the pin bump propagates to the Docker image so Praxis's bundled Nexus runtime resolves to the same Limen version Nexus pins independently
  • Bump vaquum-nexus git+https pin from Nexus 0.40.0 main HEAD f4cfa059554cf30c26a45ead7af56ca6501d1674 to Nexus 0.42.0 main HEAD 6c80d2768faa9b0dfec5f11b95b4f4bb0e710db3 (Vaquum/Nexus#62 — the Limen v3.0.3 pin bump + comment refresh + examples/README.md SFD-loading guidance update; also includes Vaquum/Nexus#61, PredictLoop.tick_once synchronous single-shot entry point, which Praxis's Timer-driven runtime does not call but which lands in the same image)
  • Unblocks the deployment-server paper-trade smoke for the BtcLogRegEVSFD experiment_dir bundle staged at /var/lib/praxis/experiments/BtcLogRegEVSFD/ (with metadata.json["sfd_module"] = "BtcLogRegEVSFD__r0001" and BtcLogRegEVSFD__r0001.py co-located in the dir) — pre-bump the v0.52.0 image crashlooped at nexus/startup/sequencer.py:626 with ModuleNotFoundError: No module named 'BtcLogRegEVSFD__r0001' because Limen v3.0.1 only resolved the SFD name via import_module against sys.path and the launcher's STRATEGIES_BASE_PATH does not include the experiment directories. Under Limen v3.0.3 the local-file-first branch loads the SFD directly from experiment_dir, with no operator-side PYTHONPATH wiring required and no SFD-file copying into manifests/

v0.54.0 on 7th of May, 2026

  • Bump vaquum_limen git+https pin from v3.0.3 to v3.0.5 (Vaquum/Limen#505). Limen v3.0.5 fixes the experiment-local SFD load to register the loaded module in sys.modules (with rollback on exec_module failure) so downstream importlib.import_module(architecture_function.__module__) lookups (notably Limen's own Trainer._resolve_model_class) resolve to the same module instance. Without this, self-contained bundles (e.g. BtcLogRegEVSFD-style experiment_dirs whose architecture function is defined inside the SFD file) reached Trainer.__init__ cleanly but failed at train() → _resolve_model_class() with ModuleNotFoundError. Praxis production code does not import from limen directly (verified via grep -rn "^from limen\|^import limen" praxis/ — zero hits), so no Praxis code change is required; the pin bump propagates to the Docker image so Praxis's bundled Nexus runtime resolves to the same Limen version Nexus pins independently
  • Bump vaquum-nexus git+https pin from Nexus 0.42.0 main HEAD 6c80d2768faa9b0dfec5f11b95b4f4bb0e710db3 to Nexus 0.43.0 main HEAD 81088b977d855c15da0a5a97c8339f79e30ce0ce (Vaquum/Nexus#63 — the Limen v3.0.5 pin bump on the Nexus side + comment refresh + examples/README.md SFD-load guidance update)
  • Unblocks the deployment-server paper-trade smoke for the BtcLogRegEVSFD experiment_dir bundle at the _resolve_model_class path; the cp-to-manifests/ operator workaround the v0.53.0 deploy needed (because Limen v3.0.3 didn't register the experiment-local SFD module in sys.modules) is no longer required after this propagates downstream

v0.55.0 on 10th of May, 2026

  • Bump vaquum-nexus git+https pin from Nexus 0.43.0 main HEAD 81088b977d855c15da0a5a97c8339f79e30ce0ce to Nexus 0.44.0 main HEAD 33aa205d57dc37c9df6cbe021dc563f261e71220 (Vaquum/Nexus#64). Nexus v0.44.0 fixes signal_producer.produce_signal to pass the last lookback rows to sensor.predict as a polars.DataFrame instead of numpy.ndarray. The pre-fix x_train.tail(lookback).to_numpy() discarded column names, defeating SFDs that defend against feature-shape drift by selecting _model_columns from the live frame at predict time (e.g. the BtcLogRegEVSFD bundle, which records self.model_cols at fit time and calls frame.select(self.model_cols) in _raw_probs). When the predict-time frame had columns the training-time frame did not — specifically binancial.compute.get_spot_klines's 19 input columns vs the HF dataset's 17 (median, iqr extra) — the SFD's numpy-branch shape check x.shape[1] == len(self.training_feature_columns) (80 != 78) skipped the index-based slice and forwarded all 80 columns to LogisticRegression.predict_proba which expected 77, raising ValueError: X has 80 features, but LogisticRegression is expecting 77 features as input on every sensor tick. Praxis production code does not import from nexus.strategy.signal_producer directly (verified via grep -rn "from nexus.strategy.signal_producer\|import nexus.strategy.signal_producer" praxis/ — zero hits); the bundled Nexus runtime in the Docker image consumes the fix transparently when the launcher's predict loop dispatches sensor ticks
  • Unblocks the deployment-server paper-trade BtcLogRegEVSFD_5m_v3 bundle (5-minute kline variant staged at /var/lib/praxis/experiments/BtcLogRegEVSFD_5m_v3_100permut/) where every sensor tick at the configured 300s interval was hitting the column-mismatch ValueError in production. With the fix propagated through the v0.55.0 image, the SFD's pl.DataFrame branch (x = _frame_to_numpy(frame, self.model_cols)) selects the trained 77 columns by name and ignores the live-data extras, harmonising the live and training paths on the same input shape. Limen v3.0.5 pin unchanged

v0.56.0 on 10th of May, 2026

  • Bump vaquum_limen git+https pin from v3.0.5 to v3.0.6 (Vaquum/Limen#507). Limen v3.0.6 adds end_date_limit and row_count_limit (canonical name; legacy n_rows retained as alias) parameters to HistoricalData.get_spot_klines and HistoricalData.get_any_file. With both start_date_limit and end_date_limit set the data window is fully closed and reproducible across the daily HF dataset snapshot growth, which lets SFD bundles fix a deterministic training window so Trainer.train()'s Pass 1 strict reconstruction check no longer trips on day-to-day metric drift. Praxis production code does not import from limen directly (verified via grep -rn "^from limen\|^import limen" praxis/ — zero hits); the only Limen consumer in the dep tree is Nexus. The Praxis Limen pin matters for dep-tree coherence: pip install vaquum-praxis resolves both Praxis's own Limen pin and Nexus's Limen pin from vaquum-praxis -> vaquum-nexus -> vaquum_limen, and since both are git+https URLs (not version constraints), pip cannot dedupe by version. Keeping Praxis and Nexus on the same Limen pin keeps the resolver deterministic
  • Bump vaquum-nexus git+https pin from Nexus 0.44.0 main HEAD 33aa205d57dc37c9df6cbe021dc563f261e71220 to Nexus 0.45.0 main HEAD 1e3c0700f0954ae49641484ecfada2d625d0b11c (Vaquum/Nexus#65 — the Limen v3.0.6 pin bump on the Nexus side + comment refresh)
  • Unblocks the deployment-server paper-trade BtcLogRegEVSFD_5m_v3 deploy at the ReconstructionError path observed at sensor-wiring time after the v0.55.0 image landed. Pre-3.0.6 the bundle's set_data_source only supported start_date_limit, so each container start re-trained against a slightly-newer HF snapshot than the one we ran the UEL on (HF dataset is daily-snapshotted), tripping Pass 1's strict equality check on bars_total / backtest_* drift (backtest_total_return_net_pct: original=4.1, new=-9.5; backtest_bars_total: original=44543, new=44595). With v3.0.6 a future re-run of the UEL pinning start_date_limit='2024-01-01', end_date_limit='<fixed date>' produces a deterministic results.csv that survives daily HF refresh

v0.57.0 on 10th of May, 2026

  • Bump vaquum-nexus git+https pin from Nexus 0.45.0 main HEAD 1e3c0700f0954ae49641484ecfada2d625d0b11c to Nexus 0.46.0 main HEAD b075042aa0cd5aad6da8355ce7d672983fb71eb1 (Vaquum/Nexus#66). Nexus v0.46.0 fixes signal_producer.produce_signal to support RuleBasedManifest SFDs alongside MLManifest. The predict path was previously hard-coded against the MLManifest.prepare_data output shape — data_dict.get('x_train') for the live train frame and wired.sensor.predict({'x_test': ...}) for the predict call — but RuleBasedManifest.prepare_data returns {'train', 'val', 'test', '_alignment', 'strategy'} with no x_train / x_test keys, so every rule-based sensor tick raised ValueError: prepare_data returned no x_train for sensor <id> on the empty-train guard. Post-fix, produce_signal branches on isinstance(wired.limen_manifest, RuleBasedManifest) and pulls train / passes test for that path. ML-SFDs are unaffected. Praxis production code does not import from nexus.strategy.signal_producer directly (verified via grep -rn "from nexus.strategy.signal_producer\|import nexus.strategy.signal_producer" praxis/ — zero hits); the bundled Nexus runtime in the Docker image consumes the fix transparently when the launcher's predict loop dispatches sensor ticks
  • Unblocks the deployment-server paper-trade stub-strategy bundle (StubStrategySFD with four trivial sub-strategies — always_one, always_zero, alternating, coin_toss — staged at /var/lib/praxis/experiments/StubStrategySFD_4permut/) where every sensor tick at the configured 900s (15-minute) interval was hitting the empty-train guard in production. With the fix propagated through the v0.57.0 image, all four stubs tick cleanly through the rule-based predict path and the operator can validate the executor end-to-end on signal patterns the existing BtcLogRegEVSFD (which sits HOLD silently) does not exercise. Limen v3.0.6 pin unchanged

v0.58.0 on 10th of May, 2026

  • Add translate_order_side, translate_order_type, translate_execution_mode, translate_maker_preference, and translate_stp_mode helpers to praxis/command_translator.py. Each helper re-keys a foreign enum member to the matching Praxis praxis.core.domain.enums member by .value, raising TypeError if the input lacks a string .value and ValueError if the value has no Praxis equivalent. Praxis members pass through identity-equal so callers that already hold Praxis enums pay no overhead
  • Wire the new translators into launcher.py's submit_command_with_translated_params so every Nexus TradeCommand enum (side, order_type, execution_mode, maker_preference, stp_mode) is rebuilt as the Praxis enum member before the call reaches Trading.submit_command. Without this, validate_trade_command (called inside ExecutionManager.submit_command) rejected every order with no allowed order types configured for mode SINGLE_SHOT because _ALLOWED_ORDER_TYPES.get(cmd.execution_mode) returned None — the dict is keyed by Praxis ExecutionMode members but cmd.execution_mode was a Nexus ExecutionMode instance with the same .value but a different class identity. The same hidden-class-mismatch trap silently bypassed TradeCommand.__post_init__'s self.execution_mode is ExecutionMode.SINGLE_SHOT identity check (so the isinstance(execution_params, SingleShotParams) invariant was not enforced for Nexus-shape commands) and would also have skipped _validate_maker_preference for any Nexus-side MAKER_ONLY order
  • Add _STP_MODE_VALUE_MAP (CANCEL_MAKER → EXPIRE_MAKER, CANCEL_TAKER → EXPIRE_TAKER, CANCEL_BOTH → EXPIRE_BOTH) so translate_stp_mode carries Nexus's nexus.core.stp_mode.STPMode onto the equivalent Praxis STPMode member. Nexus and Praxis are the only enum pair whose value strings disagree (Nexus uses CANCEL_*, Praxis uses EXPIRE_*) so without the map a generic value-lookup translation would silently throw on every command that carries the Praxis-default stp_mode
  • Add 16 new tests to test_command_translator.py covering: each translator passes Praxis members through identity-equal; each translator re-keys a synthetic foreign enum (defined in-file to avoid coupling tests to Nexus internals) to the Praxis member; STPMode carries the three CANCEL_* → EXPIRE_* semantic mappings; and unknown values / non-enum inputs raise ValueError / TypeError respectively
  • Unblocks the deployment-server paper-trade stub-strategy bundle (StubStrategySFD_4permut) where the four always_one / always_zero / alternating / coin_toss sensors finally produced ENTER actions through the rule-based predict path (post-v0.57.0) but each command was rejected at validate_trade_command before it could reach the BinanceAdapter. Pre-fix praxis-1 logs showed no allowed order types configured for mode SINGLE_SHOT on every signal tick; post-fix the same UEL routes through submit_command_with_translated_params → translated Praxis enums → validate_trade_command → BinanceAdapter.submit_order. The original BtcLogRegEVSFD bundle never tripped this validator because its strategy file's _reference_price(signal) already short-circuits on the missing signal.get('close') field, so the enum-translation gap was masked end-to-end until the stub bundle started actually firing actions

v0.58.1 on 10th of May, 2026

  • Patch translate_maker_preference and translate_stp_mode in praxis/command_translator.py to substitute None with the matching Praxis enum default (MakerPreference.NO_PREFERENCE and STPMode.NONE, respectively) instead of forwarding None to _translate_enum and crashing with TypeError: maker_preference must be MakerPreference or an enum with a string .value, got NoneType. The strict three (translate_order_side, translate_order_type, translate_execution_mode) keep their None-rejecting behaviour because the corresponding Nexus Action fields are guaranteed non-None at the ENTER boundary by Action._validate_action_type_requirements. Pre-patch submit_command_with_translated_params raised TypeError on every Nexus Action whose strategy did not set maker_preference — observed on the deployment server at 2026-05-10T14:31:57Z for all four StubStrategySFD_4permut sensors after the v0.58.0 image landed. Substituting at the boundary keeps the downstream Trading.submit_command type contract honest (Praxis enums all the way down, no Optional widening of public submit signatures) while preserving the implicit pre-v0.58.0 "no opinion / no STP" semantics
  • Update tests/test_command_translator.py: add test_translate_maker_preference_substitutes_no_preference_for_none, test_translate_stp_mode_substitutes_none_member_for_none, and three test_translate_*_rejects_none cases (one per strict translator) pinning the new contracts so a future refactor can re-introduce neither the v0.58.0 deployment-server crash nor an accidental None passthrough on a strict field. Foreign-enum re-keying, STPMode semantic mapping (CANCEL_* → EXPIRE_*), and the TypeError path for non-None non-enum inputs (translate_order_side('BUY')) remain unchanged

v0.59.0 on 11th of May, 2026

  • Add _snap_qty_to_lot_step helper in praxis/infrastructure/binance_adapter.py and call it at the top of submit_order so the order quantity is rounded down to the symbol's cached LOT_SIZE step before reaching _validate_order and the Binance REST endpoint. Pre-patch the deployment server hit Order rejected: Illegal characters found in parameter 'quantity'; legal range is '^([0-9]{1,20})(\.[0-9]{1,20})?$'. (code -1100) on every stub-strategy ENTER tick (observed at 2026-05-10T17:59:03Z for all four StubStrategySFD_4permut sensors after the v0.58.1 image landed): Nexus strategies size ENTER as notional / reference_price with no quantization, which produces a Decimal carrying the full getcontext().prec (default 28) digits — Decimal('20') / Decimal('81458') resolves to 0.0002455253013823074467823909254 (31 fractional digits) and format(qty, 'f') faithfully renders all of them, overflowing the venue's 20-fractional-digit cap. Snaps via (qty // lot_step) * lot_step (floor-divide-then-multiply), not Decimal.quantize(lot_step, ...) — quantize rounds to the exponent of lot_step rather than to an integer multiple of it, so Decimal('0.0002455…').quantize(Decimal('0.00001000'), ROUND_DOWN) would have produced 0.00024552 (eight fractional digits, neither a multiple of 0.00001 nor accepted by Binance's LOT_SIZE filter). Binance's exchangeInfo returns stepSize='0.00001000' (exponent -8) for BTCUSDT, so the trailing-zero shape is the production case, not a hypothetical. Floor-divide-then-multiply is exact for any lot_step shape including non-pure-10^-n steps. The snap is a no-op when the symbol's filters are not cached (returns qty unchanged), so the existing "No cached filters for X, skipping validation" warning path remains the single signal for a missing filter cache rather than being masked by a silent fallback
  • Add bootstrap_filter_symbols: frozenset[str] = frozenset() to Trading.__init__ and merge it into the symbol set passed to VenueAdapter.load_filters from _startup_account. Pre-patch the deployment server logged No cached filters for BTCUSDT, skipping validation ahead of every venue submission because ExecutionManager.active_symbols only returns symbols with open orders or positions, which is the empty set on a fresh paper-trade boot — so load_filters([]) was a no-op, the LOT_SIZE / PRICE / NOTIONAL invariants in _validate_order were silently bypassed, and the strategy-supplied high-precision qty reached Binance unsnapped. Wire praxis/launcher.py to construct Trading(...) with bootstrap_filter_symbols=frozenset({_DEFAULT_SYMBOL}) so BTCUSDT filters are loaded before any sensor can fire its first ENTER action
  • Make BinanceAdapter.load_filters idempotent: skip symbols already present in _filters instead of unconditionally overwriting. _startup_account runs load_filters(union(active_symbols, bootstrap_filter_symbols)) per account, so without the skip every multi-account boot would refetch exchangeInfo for the bootstrap symbol once per account — N venue weight units and N round-trips of startup latency for nothing, since per-symbol filter values are deploy-gated and immutable within a process lifetime. In-process filter refresh is intentionally unsupported — the only way to pick up new venue filters is to restart the process; if a future use case ever needs in-process refresh, add an explicit method on the VenueAdapter protocol rather than mutating private adapter state from outside
  • Add TestSnapQtyToLotStep with seven cases in tests/test_binance_adapter.py covering: 31-fractional-digit input snaps to 0.00024 on lot_step=0.00001; snap floors (never exceeds input); already-aligned qty preserved unchanged; missing-filter symbol returns the input unchanged (no silent quantize-by-default); submit_order end-to-end emits a quantity=0.00024 URL fragment matching Binance's ^([0-9]{1,20})(\.[0-9]{1,20})?$ regex; the venue-wire-format lot_step=Decimal('0.00001000') (with trailing zeros, exponent -8) snaps to a value that satisfies BOTH the wire-form-modulo and the numeric-multiple-modulo invariants; and a non-power-of-ten step (lot_step=5) floors 13 to 10. The trailing-zero and non-10^-n cases pin the floor-divide-then-multiply contract specifically (a Decimal.quantize(...) implementation would silently fail both). Add test_trading_start_preloads_bootstrap_filter_symbols_on_fresh_boot and test_trading_start_merges_bootstrap_and_active_symbols in tests/test_trading.py pinning the new Trading.__init__ kwarg's behaviour on the fresh-boot and replay-with-orders branches respectively. Existing test_trading_start_preloads_filters_for_active_symbols left unchanged — the bootstrap set defaults to empty and the historical behaviour is preserved
  • Unblocks the deployment-server paper-trade StubStrategySFD_4permut bundle past the venue boundary. With v0.59.0 the four stub sensors' next 900s ENTER ticks are expected to: snap qty to 0.00024 on cached BTCUSDT filters → pass _validate_order invariants → emit a quantity=0.00024 REST param that matches Binance's regex → receive a venue ACK (the testnet account has BTCUSDT depth; orders will fill or rest depending on order_type). The four sensors share a MARKET order_type via logreg_binary_evsfd.py so the expected steady state is immediate fill with the testnet's lot_step=0.00001 precision. Once an ENTER fills, the strategy's _exit path can fire on the next _preds == 0 tick (for always_zero, alternating, coin_toss) and verify the full ENTER → fill → EXIT → fill → close-position loop end-to-end

v0.59.1 on 12th of May, 2026

  • Anchor MarketDataPoller._poll_loop's fetch cadence to the original schedule (anchor + n * interval) instead of resleeping interval between fetches, with skip-missed-slots so a multi-interval-overrun fetch does not trigger back-to-back catch-up fetches. Pre-patch the loop did while not stop_event.wait(timeout=interval): self._fetch(...) — the wait fired after _fetch returned, so realized period was interval + fetch_duration. On Binance testnet under load _fetch regularly takes 200-500s (the get_spot_klines HTTP call queues behind rate-limited concurrent requests from the venue adapter), which for kline_size=300 (5m kline, interval=300s) pushed realized period past _DEFAULT_MAX_AGE_MULTIPLIER * kline_size = 600s and tripped StaleMarketDataError on the next sensor tick — observed on the deployment server at 2026-05-12T07:37:12Z and recurring every 25-75min thereafter for the 2d9aedcbea82:29 (logreg_binary_evsfd) sensor with measured ages of 606-732s. The anchored guarantee is no cumulative drift: after each fetch returns, n advances to max(n + 1, int(elapsed // interval) + 1) so any number of "missed" slots (when a single fetch spans k > 1 intervals) collapses into a single catch-up fetch at the next future scheduled slot rather than firing k - 1 back-to-back fetches with wait(0). The freshness goal of skipped slots is moot — the slow fetch's return brings data through now — and the post-overrun cadence resumes immediately at the original timeline. n slow fetches therefore do not produce n * overrun cumulative drift
  • Apply the same skip-missed-slots logic to n's initialization after the initial fetch: n = max(1, int(elapsed // interval) + 1). Pre-patch this commit hardcoded n = 1 after the explicit pre-loop fetch, so a slow initial fetch (e.g. cold-cache exchangeInfo round-trip + first historical kline fetch) caused iter 1's wait_seconds = max(0, 1 * interval - elapsed) to fall to 0 and fire fetch #2 immediately back-to-back — exactly the burst skip-missed-slots is meant to prevent. Now the initial fetch's overrun follows the same skip rule as every subsequent fetch
  • Extract the n-advancement math into a module-level _next_slot_index(anchor, interval, now, min_n) helper with an FP-safety while-loop bump. The naive int((now - anchor) // interval) + 1 formula is almost always correct, but binary FP rounding can leave anchor + n * interval == now exactly for unlucky pairs — e.g. elapsed=1.0, interval=0.1 gives n=10 and 10 * 0.1 == 1.0 exactly, so wait_seconds = max(0, anchor + n * interval - now) = 0 would fire the next fetch back-to-back, defeating skip-missed-slots. The helper's while anchor + n * interval <= now: n += 1 enforces the strict-future invariant; runs 0 times in the common case, 1-2 times in the FP-corner case. Both n-advancement sites in _poll_loop (after the initial pre-loop fetch and after each in-loop fetch) call the helper now, also collapsing the previous "two time.monotonic() reads per advance step" into a single now. Add four TestNextSlotIndex cases pinning the strict-future invariant for the exact-multiple FP corner case (elapsed=1.0, interval=0.1), the FP-undercount case (0.3 // 0.1 == 2.0), the min_n floor enforcement, and the min_n=1 initial-fetch contract — verified that removing the while-loop bump deterministically fails the exact-multiple test
  • Widen the interval type hint from int to float on _PollerThread.interval, MarketDataPoller.add_kline_size, MarketDataPoller.__init__'s kline_intervals: dict[int, float], and the internal _start_thread_locked / _poll_loop signatures. Production callers continue to pass integer seconds (300, 900); the regression tests need sub-second cadences (0.1, 0.105) to actually run in CI time. kline_size stays int (Binance kline sizes are all integer seconds). Tighten the existing positivity check from interval <= 0 to not math.isfinite(interval) or interval <= 0 so the float widening cannot smuggle in NaN (slips through <= 0 because any comparison with NaN is False, then propagates to wait_seconds = anchor + n * NaN - now = NaN and breaks Event.wait) or inf (passes <= 0, makes wait(inf) block the poller thread forever with no re-fetches). Add test_add_kline_size_rejects_nan_and_inf_interval and test_start_rejects_nan_and_inf_initial_intervals pinning the new invariant on both validation paths
  • Add three regression tests in tests/test_market_data_poller.py: test_slow_fetch_does_not_accumulate_drift_in_fetch_schedule pins cumulative-no-drift for sub-2-interval overruns (anchored fetch #4 at 4 * interval = 0.40s vs pre-fix 3 * interval + slow_delay = 0.45s, threshold 0.425s); test_multi_interval_slow_fetch_collapses_missed_slots pins the in-loop skip behaviour for slow_delay = 2.5 * interval (fetch #3 lands at next future slot, not back-to-back with slow return); test_slow_initial_fetch_skips_to_next_future_slot pins the initial-fetch skip for slow_delay = 1.05 * interval (fetch #2 at next slot 0.20s vs pre-fix back-to-back at 0.105s, threshold 0.1525s with ~0.045s margin each side). All three regressions verified locally by swapping the loop body to each pre-state implementation and confirming the corresponding test fails before restoring

v0.59.2 on 13th of May, 2026

  • Fix EventSpine silent-data-loss-across-restart bug: append() and ensure_schema() now call await self._conn.commit() after every successful write, so events become durable on the main DB file before the method returns. Pre-patch the spine relied on aiosqlite's default isolation_level="" (implicit transactions) and never committed — every insert sat in the rollback journal, invisible to any other connection, and rolled back on connection close without explicit commit() (and on crash/unclean shutdown). Observed in production at 2026-05-13T03:50Z: the host-mounted /opt/praxis/state/event_spine.sqlite showed main DB modtime stuck on 2026-05-05 (the boot date when the schema was first created via CREATE TABLE IF NOT EXISTS) while a 25KB rollback journal file was being actively written; a separate sqlite3.connect(...) to the same path returned events count = 0 despite the running launcher having written 83+ trade-flow events that were visible only to its own connection. Each docker compose up -d recreate (e.g. for an image bump) wiped the entire prior session's spine. Per-event commit() is the minimal correct fix: matches the at-least-once log semantics callers already assume (await append(...) returning a seq means "this event is on disk"), and per-event fsync cost is negligible against the venue REST round trip on the same critical path
  • Add test_append_commits_so_separate_connection_sees_event and test_append_survives_writer_connection_loss in tests/test_event_spine.py. Both tests use a real file-backed sqlite (not :memory:) so the cross-connection visibility property is actually exercised. The first opens a separate sqlite3.connect() after await spine.append(...) and asserts the row count = 1; the second writes 5 events, explicitly await writer_conn.close() with no extra commit() (matches the production failure mode where aiosqlite.Connection.close() forwards to sqlite3.Connection.close() which does not commit pending transactions), opens a fresh connection on the same file, and asserts all 5 events are still on disk. Verified locally that both tests fail deterministically when the new commit() calls are removed

v0.59.3 on 13th of May, 2026

  • Fix configure_logging to add structlog.stdlib.ExtraAdder() to ProcessorFormatter.foreign_pre_chain so stdlib _log.info('msg', extra={...}) payloads survive into JSON output instead of being silently dropped
  • Add structured logging emit sites to EventSpine: schema-ensured info, append debug, dedup warning, fill-atomic rollback exception
  • Add test_stdlib_extras_appear_in_json regression test in tests/test_observability.py

v0.59.4 on 13th of May, 2026

  • Bump vaquum-nexus git+https pin from Nexus 0.46.0 main HEAD b075042aa0cd5aad6da8355ce7d672983fb71eb1 to Nexus 0.47.0 main HEAD 902c895f8151318b285c64f6242cad62b720457a (Vaquum/Nexus#67 — ExtraAdder fix in nexus/infrastructure/observability.py + per-action bound_context wrapping in submit_actions). Pairs with the Praxis-side ExtraAdder fix in v0.59.3 so both observability modules in the deployed image honour stdlib _log.info('msg', extra={...}) extras and the Nexus-side trade-lifecycle emits carry strategy_id / action_type / trade_id / command_id via structlog contextvars

v0.59.5 on 14th of May, 2026

  • Fix BinanceAdapter._used_weight to step-down to zero after Binance's 60s per-IP sliding window elapses (held unchanged within the window). Pre-patch a startup load_filters burst pinned the value at the testnet weight limit, kept HealthEvaluator returning REDUCE_ONLY, and blocked every ENTER with INTAKE_MODE_BLOCKS_ENTER for 4+ hours
  • Add three regression tests in tests/test_binance_adapter.py covering drop-to-zero past window, hold-pinned within window, and the exact 2026-05-14 pinned-mode failure mode

v0.60.0 on 15th of May, 2026

  • Add praxis/market_data_cache.py with MainCache (disk-persisted 1-min kline cache fed daily from Limen's HF dataset and per-minute from binancial.get_spot_klines, both writing to one parquet under a single _write_lock) and CacheScheduler (two daemon threads driving the two refresh paths). Unit tests in tests/test_market_data_cache.py cover refresh paths, source-aware overlap precedence, atomic writes, concurrent refresh, scheduler lifecycle + restart-after-dead-thread, snapshot, corrupt-state / corrupt-parquet / future-state self-heal, and finite-value validation for scheduler intervals (Vaquum/Praxis#108)
  • Gut praxis/market_data_poller.py from a per-kline_size poller-thread pool (502 LOC) to a thin staleness-aware adapter over MainCache (~215 LOC). MarketDataPoller(cache, max_age_overrides); get_market_data and is_stale semantics + StaleMarketDataError shape preserved for existing callers; lifecycle is owned by CacheScheduler
  • Wire praxis.launcher _start_poller to build MainCache (paths from MAIN_CACHE_DIR env var, default /var/lib/praxis/maincache), bootstrap the cache from disk if missing, synchronously fill the trailing day from binancial, start CacheScheduler, then wrap the cache in the MarketDataPoller adapter for the existing market_data_provider callback. _register_wired_kline_sizes no longer calls add_kline_size (cache is symbol-scoped); _shutdown calls cache_scheduler.stop() instead of poller.stop()
  • Replace tests/test_market_data_poller.py with cases pinning adapter delegation, staleness raise, max_age_overrides validation (positive / finite / numeric), is_stale, and single-snapshot read consistency; delete tests/test_market_data_poller_freshness.py and tests/test_market_data_poller_testnet.py (functionality moved to MainCache + adapter); update tests/test_launcher_kline_registration.py to drop add_kline_size assertions and add invalid-kline_size guard regressions; add mock_market_data_cache fixture to tests/conftest.py for launcher-startup tests

v0.60.1 on 16th of May, 2026

  • Fix praxis/market_data_cache.py _apply_new_bars to normalize every column dtype in new_bars to match the in-memory _frame's schema before concat. The Limen HF parquet stores Datetime('ms', 'UTC') and UInt64 on no_of_trades, while binancial's pandas → polars frame produces Datetime('us', 'UTC') and Int64. Pre-fix pl.concat raised polars.exceptions.SchemaError on the first mismatched column and the cache froze at Limen's high-water mark. Production-observed after the v0.60.0 first-boot Limen bootstrap on 2026-05-16; the scheduler logged the same SchemaError every 60s, the boot binancial refresh failed too, and the cache stayed at 2026-05-15 23:59:00 UTC until the fix landed
  • Pin the fix with test_apply_new_bars_normalizes_schema_across_sources in tests/test_market_data_cache.py — builds a Limen-shaped _frame (ms datetime + UInt64 no_of_trades), feeds in a binancial-shaped new_bars (us datetime + Int64 no_of_trades), asserts the concat succeeds and the resulting _frame retains Limen's canonical schema
  • Cast the future-row filter's cutoff literal to merged.schema['datetime'] instead of hard-coding Datetime('us', 'UTC') so the round-16 filter survives a ms-precision merged frame

v0.60.2 on 17th of May, 2026

  • Fix praxis/infrastructure/event_spine.py append(FillReceived) to use Python sqlite3's implicit BEGIN-on-DML + explicit commit() / rollback() instead of SAVEPOINT fill_atomic / RELEASE / ROLLBACK TO. Pre-fix the SAVEPOINT path interacted poorly with the default isolation_level="" semantics: non-DML statements (SAVEPOINT, RELEASE, ROLLBACK TO) trigger an implicit COMMIT before they run, which collapses the savepoint stack. In production this surfaced as sqlite3.OperationalError: no such savepoint: fill_atomic on every RELEASE and produced 23 errors over 22h of paper trading (19 on_message callback error from the WebSocket fill stream + 4 unhandled exception while processing command from the command-dispatch loop, both call sites hitting the same broken event_spine.append). The new pattern wraps the dedup-insert + event-insert pair in Python's auto-begun transaction and uses explicit commit() on success / rollback() on failure — atomicity preserved, no SAVEPOINT pitfalls
  • Add tests/test_event_spine.py test_fill_atomicity_many_consecutive_appends_no_savepoint_error — exercises 50 consecutive FillReceived appends (the same shape that produced the production errors) and asserts no OperationalError is raised
  • Add curl to Dockerfile and a Docker HEALTHCHECK directive that probes http://localhost:${PORT:-${HEALTHZ_PORT:-8080}}/healthz every 30s after a 10-minute start-period (covers the first-ever boot's synchronous Limen HF snapshot download per TD-061). Pre-fix the image shipped no probe tool and no HEALTHCHECK was declared, so docker exec ... curl /healthz failed (binary missing) and docker ps showed no Health column. Post-fix docker ps reports (healthy) / (unhealthy) and a hung launcher surfaces within ~90s of the first failed probe
  • Apply round-1 review feedback on the SAVEPOINT fix: (a) rewrote append()'s docstring to drop the stale SAVEPOINT mention (the implementation comment block in the function body retains the historical context); (b) split the FillReceived try/except into separate DML and commit blocks so a commit failure now propagates the COMMIT exception, not a rollback failure that masks it; new _safe_rollback() helper does best-effort rollback that logs but does not raise; (c) added file-backed spine_file fixture (uses aiosqlite.connect(tmp_path/.sqlite)) for the regression test so it reproduces the same transaction semantics as production (the default :memory: fixture has subtly different journal/transaction behavior and did NOT reproduce the original SAVEPOINT bug); pinned the new commit-failure and rollback-failure paths with test_fill_atomicity_commit_failure_preserves_original_exception and test_fill_atomicity_rollback_failure_does_not_mask_dml_exception
  • Bump vaquum-nexus pin to v0.48.0 (Nexus@836ad76) to pick up Nexus PR #68 — INFO-level signal produced log emitted at every sensor tick before strategy dispatch, with full type-safe coercion of Signal.values for the orjson renderer
  • Apply round-3 review feedback: (a) parameterize the Dockerfile HEALTHCHECK port via ${PORT:-${HEALTHZ_PORT:-8080}} so the probe stays in sync with whichever env var the operator / platform actually sets (matches the launcher's resolution order in praxis/launcher.py); (b) drop the stale wget reference in this v0.60.2 entry (the fix added curl, not wget); (c) switch the three test_fill_atomicity_* direct-attribute-restore patterns in tests/test_event_spine.py to pytest's monkeypatch fixture so a mid-test assertion failure cannot leave the connection's commit/rollback/_append_event replaced with a failing stub (restore now happens in pytest teardown regardless of test outcome)

v0.61.0 on 19th of May, 2026

  • Add praxis.binsim package — an in-process Binance simulator that replaces Binance testnet as Praxis's paper-trading venue, addresses issue #112. Removes testnet-borne incidents (recvWindow rejections from clock skew, per-IP weight pinning BinanceAdapter._used_weight, rate-throttling) and unlocks the same backend for high-speed replay later
  • Add praxis/binsim/book.py OrderBook — single-symbol top-N snapshot with replace(bids, asks, last_update_id, ts_ms) (validates non-empty, positive prices/qtys, strict descending bids / ascending asks, no crossed book, monotonic update id) and non-mutating consume_qty_for_market_order(side, qty) that walks the book and returns the fill ladder; returns partial fills when the book is exhausted, raises on empty book / non-positive qty
  • Add praxis/binsim/feed.py DepthPoller — aiohttp.ClientSession poll loop against https://binance-spot-depth20-1000ms.onrender.com/top20 at 1000ms cadence, Bearer auth from env, exposes last_success_ts_ms so the HTTP layer's staleness gate has a freshness read. Split exception handling logs transient network errors at WARNING (aiohttp.ClientError/TimeoutError) and malformed-payload errors at ERROR (ValueError/KeyError) so a persistently broken upstream is louder than a flaky network
  • Add praxis/binsim/ledger.py Ledger — per-account {USDT, BTC, fills, seen_client_order_ids} state under a single asyncio.Lock; atomic snapshot via tempfile.mkstemp + Path.replace (same pattern as MainCache._atomic_write_main_cache_state) after every mutation. Two settlement APIs: apply_fill(...) (single fill, no dedup, used by tests) and apply_order(account_id, side, fills, client_order_id) (atomic multi-level with client_order_id dedup, used by the HTTP POST handler). Returns assigned monotonic order_id + per-fill monotonic trade_ids. Fee model is USDT-only for MMVP — apply_fill raises on fee_asset != 'USDT'
  • Add praxis/binsim/server.py BinsimServer + make_app — aiohttp.web.Application wiring all binsim routes plus a lifecycle wrapper that owns AppRunner + TCPSite. Deps injected via typed web.AppKey instances (BOOK_KEY, LEDGER_KEY, POLLER_KEY, STALENESS_THRESHOLD_MS_KEY, WS_SUBSCRIPTION_COUNTER_KEY)
  • Add binsim HTTP routes: GET /healthz ({"status":"ok"}), GET /api/v3/time ({serverTime: <unix-ms>}), GET /api/v3/exchangeInfo (static BTCUSDT filter response — PRICE_FILTER tickSize=0.01, LOT_SIZE step/min=1e-5 max=9000, NOTIONAL min=5), GET /api/v3/depth (book snapshot in Binance shape with symbol+limit validation), GET /api/v3/account (ledger balances), and signed stubs GET /api/v3/order (404 + Binance code -2013), GET /api/v3/openOrders ([]), GET /api/v3/myTrades ([])
  • Add binsim POST /api/v3/order — HMAC presence check → staleness gate (now_ms - last_success_ts_ms > threshold_ms → 503 + Binance code -1003) → param validation (symbol/side/type/quantity/newClientOrderId + Binance-shaped 400 codes -1100 / -1121) → OrderBook.consume_qty_for_market_order → liquidity check (sum-of-walked-qty < requested → 400 + -2010) → per-fill 10bps taker commission → atomic Ledger.apply_order (insufficient balance / duplicate clientOrderId → 400 + -2010) → Binance FULL response shape with fills[].{tradeId, price, qty, commission, commissionAsset} matching Praxis's _parse_submit_response
  • Add HMAC presence helper _require_signed_caller — checks X-MBX-APIKEY header + signature query param + resolves api_key → account_id via Ledger.account_for_api_key (which hashes the incoming key and looks it up in the index built from registered accounts). Per-MMVP spec, the binsim does presence checking only, not full HMAC verify
  • Add binsim WebSocket routes: /ws-api/v3 (accepts userDataStream.subscribe.signature, hands out monotonic subscriptionId via per-app _WsSubscriptionCounter, validates api_key via Ledger.account_for_api_key, error frames mirror Binance {id, status, error: {code, msg}} shape — 401/-1022 for bad sig, 401/-2014 for unknown key, 400/-1100 for unknown method) and /stream (accepts connection but pushes no frames; aiohttp built-in heartbeat=180s keeps the connection alive past idle timeout)
  • Add praxis/binsim/__main__.py CLI entrypoint — reads env (BINSIM_DEPTH_TOKEN, BINSIM_STATE_DIR required; BINSIM_HOST, BINSIM_PORT, BINSIM_DEPTH_URL, BINSIM_STALENESS_MS, BINSIM_POLL_INTERVAL_MS optional), wires OrderBook + Ledger.load() + DepthPoller.start() + BinsimServer.start(), registers SIGTERM/SIGINT handlers BEFORE starting long-lived components for deterministic shutdown. The poller's background loop primes the book on its first iteration; the staleness gate trips until it succeeds
  • Add BINSIM_URL paper-mode override in praxis/launcher.py _resolve_trade_mode — when set under TRADE_MODE=paper, derives REST/WS/WS-API URLs from a single http(s)://host:port base (http→ws, https→wss, WS-API path hard-coded to /ws-api/v3). Mixing BINSIM_URL with TRADE_MODE=live is a hard RuntimeError. Bad scheme (not http/https) or missing host raises with a clear message
  • Relax the wss:// scheme check in praxis/infrastructure/binance_ws.py BinanceUserStream.initiate_connection to accept ws:// only when the BINSIM_URL env var is set. Production deployments without BINSIM_URL retain the original fail-closed wss-only behavior — the relaxation is gated so a mis-configured deployment cannot fall back to an insecure scheme by accident. Docstrings on _setup_connection and _clean_setup_connection updated to mention the gated ws:// allowance
  • Add Dockerfile.binsim — python:3.12-slim base, installs the same wheel as the main Praxis image but uses a separate binsim:1000 user, /var/lib/binsim state dir, BINSIM_STATE_DIR=/var/lib/binsim + BINSIM_PORT=8081 baked-in defaults, HEALTHCHECK probes ${BINSIM_PORT}/healthz with start-period=30s (no Limen download needed, fast boot), ENTRYPOINT ["python", "-m", "praxis.binsim"]
  • Add .github/workflows/build_image_binsim.yml — parallel to build_image.yml, pushes to a separate ghcr.io/vaquum/praxis-binsim repo with scoped buildx cache so it does not contend with the main image cache. Same tag scheme (sha-<sha>, <version>, main)
  • Add 257 binsim tests across tests/test_binsim_book.py (34, OrderBook validation + walk), tests/test_binsim_feed.py (23, poller lifecycle + auth header + failure modes), tests/test_binsim_ledger.py (55, balance math + atomic snapshot + concurrent fills + dedup), tests/test_binsim_server.py (51, every HTTP endpoint), tests/test_binsim_ws.py (9, WS handshake), tests/test_binsim_main.py (20, env parsing), tests/test_binsim_binance_adapter_smoke.py (9, end-to-end against the real BinanceAdapter), and tests/test_binsim_execution_manager_smoke.py (5, end-to-end through ExecutionManager asserting the CommandAccepted → OrderSubmitIntent → OrderSubmitted → FillReceived event-spine sequence)
  • Bump 8 launcher trade-mode tests in tests/test_launcher_trade_mode.py covering BINSIM_URL derivation, https→wss, empty-fallback-to-testnet, live-mode hard-block, scheme/host validation. Add 2 tests/test_binance_ws.py tests for the ws:// scheme gating (rejected without BINSIM_URL, accepted with it)
  • Note TD-064, TD-065, TD-066 in docs/TechnicalDebt.md for the MMVP-deferred items surfaced during pre-PR review: LOT_SIZE filter not enforced in POST /api/v3/order, hardcoded process-wide taker fee rate vs the issue spec's per-account fee model, and unbounded seen_client_order_ids set growth
  • Refactor binsim api_key management: drop the operator-supplied BINSIM_API_KEYS env var and the api_keys parameter from make_app / BinsimServer. Ledger.register_account now mints a fresh 64-hex-char api_key via secrets.token_hex(32), persists it as part of the account snapshot, and returns it. The HTTP layer's signed handlers resolve X-MBX-APIKEY via Ledger.account_for_api_key. Adds a register subcommand to the CLI: python -m praxis.binsim register --account-id <id> --initial-usdt <amount> [--initial-btc <amount>] mints the key and prints it on stdout for the operator to paste into Praxis's BINANCE_API_KEY_<acct> env. Removes a layer of operator config drift — one place to register accounts, one place the api_key exists

v0.62.0 on 20th of May, 2026

  • Fix BinanceAdapter._request_with_retry to exempt NotFoundError from HealthTracker failure counting when binsim is the configured venue (gated on a non-empty BINSIM_URL env var; mirrors the strip-pattern check used by _resolve_trade_mode and BinanceUserStream._clean_setup_connection). On real venues a NotFoundError (Binance code -2013) on routes like GET /api/v3/order still records as a health failure as before. Closes #114
  • Add module-level _binsim_enabled helper in binance_adapter.py
  • Add NotFoundError branch in _request_with_retry placed before the broader except VenueError, so binsim's documented stub -2013 responses no longer drive consecutive_failures / failure_rate past HealthEvaluator halt thresholds on restart-time order reconciliation
  • Add four tests in TestHealthSignals covering: (a) NotFoundError records failure without BINSIM_URL, (b) NotFoundError skipped with BINSIM_URL set, (c) whitespace-only BINSIM_URL falls back to the safe default of recording, (d) non-NotFoundError VenueError subclasses still record even with BINSIM_URL set

v0.63.0 on 21st of May, 2026

  • Bump vaquum-nexus pin from 836ad76 (v0.48.0) to a37bff5 (v0.49.0) in pyproject.toml. The new Nexus revision adds _inject_reference_price in nexus/strategy/signal_producer.py, which forwards the latest raw close from the pre-feature-engineering market_data frame into Signal.values when the predictor doesn't include close itself. Unblocks the deployed logreg_binary_evsfd sensor (and any future ML sensor whose predict() runs close through fractional_diff or any other column-replacing transform) from the silent-no-op failure mode where every _preds=1 produced zero commands because the strategy's _reference_price(signal) returned None. Stub-pattern predictors that forward close directly are unaffected — the shim never overwrites a close the predictor already supplied

v0.64.0 on 23rd of May, 2026

Update

  • Bump vaquum_limen git+https pin from v3.0.6 to v3.9.0 (Vaquum/Limen@v3.9.0) in pyproject.toml. Limen v3.9.0 ships the new YAML-based SFD pipeline (limen/yaml/ package — parser, compiler, resolver, validator, rules) that unblocks experiment_runner bundles declaring metadata.json["sfd_module"] = "yaml:<name>" with a manifest.yml instead of a <sfd_module>.py predictor file. Without this bump the existing vaquum_limen 3.0.6 Trainer.__init__ raises ValueError on the yaml: prefix (: is not a valid Python identifier segment per the path-traversal hardening at trainer.py:158) before any bundle file is read, so the new bundle shape cannot wire at startup
  • Re-verify Praxis's direct Limen imports against v3.9.0. praxis/market_data_cache.py imports HistoricalData (public) and the private _aggregate_spot_klines as _limen_aggregate_spot_klines (lines 33-35; the private dependency is acknowledged in the docstring at lines 465-466 with a TD note in docs/TechnicalDebt.md about pushing Limen for a public API). Both still resolve in v3.9.0 with the same signatures — HistoricalData.get_spot_klines(row_count_limit=None, kline_size=60, start_date_limit=None, end_date_limit=None, *, n_rows=None) -> pl.DataFrame (line 762 of Limen's v3.9.0 historical_data.py uses it), _aggregate_spot_klines(data: pl.DataFrame, kline_size: int) -> pl.DataFrame (defined at line 408). The re-validate-on-upgrade contract that motivated the TD note holds for this jump. Mirrors the Nexus v0.45.0 / v0.50.0 precedent of explicitly documenting private-attribute / private-function re-validation on every Limen pin bump
  • Bump vaquum-nexus pin from a37bff5 (v0.49.0) to 6d6af60 (v0.50.0) in pyproject.toml. The new Nexus revision lands the matching vaquum_limen v3.0.6 → v3.9.0 pin bump (Vaquum/Nexus#70) so the two transitively-pinned vaquum_limen versions agree (Praxis's pip resolver refuses to install otherwise). Nexus also refreshes the two # NOTE … as of vaquum_limen 3.0.6 comments in nexus/startup/sequencer.py (lines 631, 651) to 3.9.0 so the private-attribute re-validate-on-upgrade marker reflects the version Nexus 0.50.0 actually validates against. No Nexus production code changed by the Limen bump; the public Trainer / RuleBasedManifest surfaces consumed by produce_signal / _wire_sensors are stable across the v3.0.6 → v3.9.0 jump (verified by Nexus's 10 test_limen_trainer_contract.py cases plus the rule-based / ML-manifest branch tests in test_signal_producer.py — all 1385 Nexus tests pass against v3.9.0 unmodified)
  • Add transitive runtime dependency on ruamel.yaml>=0.18 via Limen v3.9.0 (limen/yaml/parser.py imports from ruamel.yaml import YAML). Picked up automatically through Limen's pyproject.toml dependency list — Praxis does not import ruamel.yaml directly, but loading any yaml:-prefixed SFD bundle through Nexus's Trainer will trigger the import chain. Praxis's full pytest suite passes against the new stack (1352 passed, 1 skipped, 3 pre-existing binance / websockets deprecation warnings — unrelated to the Limen / Nexus bump)
  • Note TD-067 in docs/TechnicalDebt.md: no Praxis-side integration test exists for the YAML-backed SFD bundle launch path enabled by this bump. The existing tests/test_launcher_sfd_path.py only covers the legacy Python-module SFD path (importlib.import_module(metadata['sfd_module'])); the YAML path bypasses that helper entirely. Meaningful regression coverage lives upstream in Limen's tests/test_yaml.py (975 lines) and Nexus's tests/test_limen_trainer_contract.py (10 cases). When to fix: once the experiment_runner bundle format stabilizes against a tagged Limen version (currently the downstream artifact btc_logreg_15m_up_early__r0024 ships with limen_version: "3.9.2" — unreleased dev), or when the next YAML-bundle deploy lands and a real production bundle can serve as the fixture template

v0.65.0 on 24th of May, 2026

Update

  • Bump vaquum_limen git+https pin from v3.9.0 to v4.0.1 (Vaquum/Limen@v4.0.1) in pyproject.toml. v0.64.0 pinned v3.9.0 to unblock YAML-based SFD bundles, but that tag's Trainer cannot actually reconstruct one: Trainer.__init__ passes metadata.json["sfd_module"] (for a YAML SFD, the CompiledSFD.__name__ literal "yaml:<name>") to _load_sfd_module, whose seg.isidentifier() path-traversal guard rejects the : and raises ValueError: sfd_module name 'yaml:...' is not a dotted sequence of valid Python identifiers. The yaml_reference reconstruction branch (Trainer.__init__ rebuilding the SFD via CompiledSFD(yaml_reference)) only landed in Limen v3.9.2 (commits 7775f9a / f37eb74 / e6ce7eb), tagged after v0.64.0's pin was chosen. Verified locally against the real btc_logreg_15m_up_early bundle (limen_version: "3.9.2", 500 rounds): raises the identifier ValueError under v3.9.0, loads cleanly under v4.0.1 (Trainer init OK, MLManifest reconstructed from yaml_reference, round 24 with 34 populated params)
  • Go to v4.0.1 (latest) rather than the minimal v3.9.2 fix — the only breaking change across v3.9.2 → v4.0.1 is UniversalExperimentLoop.run() skipping terminal post-processing by default (Limen v4.0.0), which is the training loop; Praxis only consumes trained bundles via Nexus's Trainer, never runs UEL. Praxis's direct Limen imports in praxis/market_data_cache.py (lines 33-35: HistoricalData + private _aggregate_spot_klines) re-verified against v4.0.1 — both resolve with unchanged signatures (HistoricalData.get_spot_klines(row_count_limit=None, kline_size=60, start_date_limit=None, end_date_limit=None, *, n_rows=None) -> pl.DataFrame, _aggregate_spot_klines(data: pl.DataFrame, kline_size: int) -> pl.DataFrame). The bundle's YAML schema VERSION is still '1.0' under v4.0.1, so a v3.9.2-produced bundle loads
  • Bump vaquum-nexus pin from 6d6af60 (v0.50.0) to 952f6fc (v0.51.0) in pyproject.toml. Nexus 0.51.0 lands the matching vaquum_limen v3.9.0 → v4.0.1 pin bump (Vaquum/Nexus#71) so the two transitively-pinned vaquum_limen versions agree (Praxis's pip resolver refuses to install otherwise). No Nexus production code changed; the public Trainer / RuleBasedManifest surfaces consumed by produce_signal / _wire_sensors are stable across the v3.9.0 → v4.0.1 jump (all 1385 Nexus tests pass against v4.0.1 unmodified). Praxis's full pytest suite passes against the new stack (1352 passed, 1 skipped, 3 pre-existing binance / websockets deprecation warnings — unrelated to the bump)

v0.66.0 on 25th of May, 2026

NOTE

  • Epoch-scoping state_dir / strategy_state_path (see Fix below) changes the on-disk layout: on first boot of v0.66.0, state written by ≤v0.65.0 under the old account-level paths (STATE_BASE / <account_id>, STRATEGY_STATE_BASE / <account_id>) is not recovered — even with an unchanged EPOCH_ID. The account starts from a fresh InstanceState (capital_pool re-read from the manifest, positions rebuilt from the venue at boot). This one-time reset is intended; old directories are left in place (TD-068). To preserve continuity, copy the old account-level tree (STATE_BASE / <account_id>/{snapshots,wal,strategy_state}, plus STRATEGY_STATE_BASE / <account_id>/ if set) into the matching <EPOCH_ID>/ subdirectories before upgrading — see docs/Launcher.md

Fix

  • Fold EPOCH_ID into the per-account InstanceState path in praxis/launcher.py main() — state_dir and strategy_state_path are now STATE_BASE / <account_id> / <epoch_id> and STRATEGY_STATE_BASE / <account_id> / <epoch_id> rather than … / <account_id>. Previously the snapshot/WAL dir was account-scoped only, so an EPOCH_ID bump reset the event spine (epoch-scoped by column) but not the InstanceState: StateStore.recover() found the prior epoch's snapshot + WAL and restored the persisted capital_pool instead of taking the fresh InstanceState.fresh(manifest.capital_pool) path. A manifest capital_pool change across an epoch was therefore silently ignored — orders were sized off the new manifest pool but budget-checked against the stale recovered pool (compute_strategy_budget reads state.capital_pool), so every ENTER was denied at the CAPITAL stage (CAPITAL_RESERVATION_DENIED) and the deployment produced signals but zero trades. Folding the epoch into the path makes an epoch bump yield a fresh InstanceState (recover() → None → fresh from manifest), matching the event spine's existing epoch isolation; crash recovery within an epoch is unchanged (same epoch → same dir → same snapshot/WAL). Closes #120
  • Update the _require_safe_account_id docstring in praxis/launcher.py to reflect the STATE_BASE / <account_id> / <epoch_id> layout
  • Update operator-facing docs/Launcher.md (STATE_BASE / STRATEGY_STATE_BASE rows) for the epoch-scoped path layout, and note that strategy state falls back under state_dir when STRATEGY_STATE_BASE is unset
  • Add tests/test_launcher_state_dir_epoch.py — asserts main() builds both state_dir and strategy_state_path with the EPOCH_ID path component
  • Note TD-068 in docs/TechnicalDebt.md: old per-account / superseded-epoch state dirs (under both STATE_BASE and STRATEGY_STATE_BASE) are never reaped

v0.67.0 on 26th of May, 2026

  • Bump vaquum-nexus pin from 952f6fc (v0.51.0) to 9d249d7 (v0.52.0) in pyproject.toml. v0.52.0 reworks _wire_sensors with two opt-in, env-gated accelerators for Limen Sensor reconstruction, both defaulting to the prior serial behavior so an unconfigured deployment wires exactly as before: process-parallel reconstruction across NEXUS_WIRE_MAX_WORKERS worker processes (default 1 = inline, since train() is GIL-bound and gains nothing from threads) and a reconstruct-once disk cache under NEXUS_SENSOR_CACHE_DIR (unset = off), keyed by a SHA-256 over the bundle's metadata.json + manifest.yml and the permutation_id, that auto-invalidates on limen_version / data-window change. Effect for this deployment: the ~5000-permutation btc_logreg bundle that previously took ~8h to wire serially on every boot — and re-wired in full on each restart / EPOCH_ID bump — can now fan reconstruction across cores and load already-reconstructed sensors from disk, making restarts and epoch bumps near-instant once the cache is warm. No Praxis code change is required; the launcher opts in purely by setting the two environment variables in the deployment environment

v0.68.0 on 28th of May, 2026

NOTE

  • Operational migration: Nexus v0.52.1 (transited by this bump) is a BREAKING change for any deployment that set NEXUS_WIRE_MAX_WORKERS > 1 in v0.67.0. As of v0.52.1, _wire_sensors no longer runs a ProcessPoolExecutor in the launcher; NEXUS_WIRE_MAX_WORKERS now governs the standalone pre-launch warmer (python -m nexus.startup.warm_cache) instead of in-launcher wiring. The warmer reconstructs every sensor in a process that never imports Polars, writes the disk cache, and exits before the launcher starts; the launcher then wires inline against the warm cache. The root cause was a Polars rayon worker-stack segfault — creating a worker pool in the launcher (which owns the global rayon pool for the market-data cache) degraded that pool, and a later large Polars merge segfaulted the process every ~37 min on the 5000-permutation deploy. A deployment previously parallelising sensor wiring via NEXUS_WIRE_MAX_WORKERS > 1 must add the warmer invocation to its pre-launch step; an unconfigured deployment (warmer absent, NEXUS_WIRE_MAX_WORKERS unset) wires inline and is unchanged. Closes the segfault crash-loop observed on prod

Update

  • Bump vaquum-nexus pin from 9d249d7 (v0.52.0) to bb2356b (Nexus PR #74, v0.52.1 + v0.53.0) in pyproject.toml. v0.53.0 replaces PredictLoop's bounded ThreadPoolExecutor with a spawn ProcessPoolExecutor so the GIL-bound Limen MLManifest.prepare_data (~4.4 s/predict, ~99.9% Python/Polars on a ~224k-row frame) parallelises across cores. Measured on the prod-equivalent 5000-permutation 15m deploy: 16 spawn workers with POLARS_MAX_THREADS=1 per worker = 6.37 predicts/sec (required 5.05/sec to clear the 15-minute cadence SLA); threads previously yielded ~0.3/sec, missing SLA by ~24x. Parent-side strategy dispatch, context lookup, and action submission are serialised by the pool's result-handling thread, so capital / WAL / risk plumbing is untouched. Per-cycle Arrow IPC sharing of the aggregated market-data frame (one parent aggregation per (kline_size, latest_bar) written to a refcounted temp IPC file) means 5000 sensors sharing one kline pay one parent aggregation per cycle, not one per sensor. New env knobs: NEXUS_PREDICT_MAX_WORKERS (default 16) and NEXUS_PREDICT_POLARS_MAX_THREADS (default 1, set via os.environ.setdefault('POLARS_MAX_THREADS', ...) before pool creation so spawned worker interpreters inherit it). No Praxis code change is required; the launcher passes the same market_data_provider / context_provider / action_submit callables it always did. v0.52.1 (transited) ships the pre-launch warmer described in the NOTE above
  • Pin transits two minor Nexus releases (v0.52.1, v0.53.0); commit body for the bump references both and the operational migration note. Praxis's full pytest suite passes against the new stack unmodified

v0.68.1 on 29th of May, 2026

NOTE

  • Hotfix bump for two prod-surfaced regressions introduced by v0.68.0's transit of Nexus v0.53.0. The v0.53.0 ThreadPoolExecutor → spawn ProcessPoolExecutor swap in PredictLoop crossed a process boundary for the first time, surfacing a latent Signal pickling defect; concurrent dispatch onto state.positions while serialize_state iterated the live dict surfaced a RuntimeError: dictionary changed size during iteration that demoted the operational mode to REDUCE_ONLY for ~26h until the next epoch reset. Both fixes were monkeypatch-validated on prod as praxis:0.68.0-mp1 (run 14:17–15:58 UTC on 2026-05-28: 16,241 signal produced, 4,253 command submitted, 0 pickling errors, 0 restarts) before being promoted to a tagged Nexus release. No Praxis code change is required; the pin bump alone delivers the upstream fixes

Update

  • Bump vaquum-nexus pin from bb2356b (v0.53.0) to 2cae5c0 (Nexus PR #75, v0.53.1) in pyproject.toml. v0.53.1 ships two fixes: (1) Signal.__reduce__ so a Signal returned from a spawn ProcessPoolExecutor worker survives the pool's result-pickle path — Signal.__post_init__ wraps values in types.MappingProxyType for immutability, which is not picklable by default, so the v0.53.0 spawn pool raised TypeError: cannot pickle 'mappingproxy' object inside _sendback_result on the first predict cycle of every deploy; __reduce__ ships values as a plain dict across the wire, the receiving side re-runs __post_init__ and re-wraps it, and consumers still see MappingProxyType. (2) serialize_state now snapshots every mutable dict it iterates via dict() before the per-item encode comprehensions — covers state.positions, state.strategy_modes, state.capital.per_strategy_deployed, and state.risk.per_strategy; wal_lock is innermost in the lock chain so serialize_state runs without positions_lock / CapitalController._lock and cannot exclude concurrent writers. No Praxis code change is required; the parent-side dispatch path is unchanged
  • Praxis's full pytest suite passes against the new stack unmodified

v0.68.2 on 30th of May, 2026

NOTE

  • _resolve_trade_mode previously forced market_data_testnet=True under TRADE_MODE=paper regardless of whether BINSIM_URL was set. The launcher pre-dates the binsim work (the MAJOR-001 paper/live URL safety wall was built when "paper" meant "paper orders to Binance Spot testnet"); when binsim wiring landed (Praxis #112) the spec-prescribed URL override at launcher.py:1873-1875 covered the trading-path REST/WS/WS-API triple but the market-data client constructed separately at launcher.py:1294 inherited the testnet=True flag from the paper-mode default. Production observation on praxis:0.68.1 with BINSIM_URL=http://binsim:8081: every binancial cache-refresh call hit https://testnet.binance.vision/api/v3/aggTrades and the historicalTrades GETs intermittently raised ValueError: No trades found at or after <ts> because testnet has no continuous trade flow. Sensors built their feature reconstruction from sparse testnet trades while binsim filled against its mainnet-quality depth feed — defeating the purpose of running the sim. The Praxis #112 spec is explicit ("Removes testnet-borne incidents... and unlocks the same backend for high-speed replay later" and the order-book source is mainnet-mirrored at 1s cadence), so the coupling was an unintended gap, not a deliberate constraint

Fix

  • Route market-data poller to mainnet (testnet=False) when BINSIM_URL is set under TRADE_MODE=paper in _resolve_trade_mode. The trading-path URL triple still derives from BINSIM_URL; only the fourth tuple element flips. The MAJOR-001 safety property (no paper-orders against mainnet data) is preserved because the property only meaningfully applies when paper orders reach a real venue — binsim orders never do. TRADE_MODE=paper without BINSIM_URL is unchanged (returns testnet URLs + testnet=True); TRADE_MODE=live is unchanged (mainnet + testnet=False); TRADE_MODE=live with BINSIM_URL set still raises (unchanged). Update the docstring on _resolve_trade_mode and the env-routing table in docs/Binsim.md to document the mainnet market-data path under binsim
  • Update TestResolveTradeModeBinsim: the two assertions that previously pinned testnet is True under paper+BINSIM_URL (test_paper_with_binsim_url_returns_derived_urls_and_testnet_flag, test_paper_with_https_binsim_url_uses_wss) now assert testnet is False and have been renamed to test_paper_with_binsim_url_returns_derived_urls_and_mainnet_market_data / test_paper_with_https_binsim_url_uses_wss_and_mainnet_market_data with a docstring stating the rationale (binsim's mainnet-quality depth feed plus sensor feature reconstruction must read the same data distribution); empty/whitespace BINSIM_URL fallback to testnet+True is unchanged

v0.69.0 on 31st of May, 2026

NOTE

  • Wires the v0.54.0 Nexus schedulers (SnapshotScheduler + MtmLoop) into praxis/launcher.py so the v0.54.0 fixes for Nexus #76 actually take effect on prod. Pre-v0.69.0, the Nexus modules existed but the launcher never instantiated them, so state_store.checkpoint() still ran only at boot-time capital reconciliation and graceful shutdown (snapshot drifted 13+ h behind the live state on the observed prod box, WAL grew to 11.5 GB) and Position.unrealized_pnl stayed at zero across the lifetime of every position (live MTM hid +$3,066 unrealized across 4,161 open positions on the observed prod box, with risk gates running blind to the open book). This pin bump + wiring delivers both fixes to the running deployment

Add

  • Wire SnapshotScheduler into the per-account Nexus runtime in Launcher._build_nexus_runtime alongside HealthLoop. Constructed with positions_lock (the same threading.Lock already aliased into state.risk.lock for the FINAL-MAJOR-02 cross-thread invariant), capital_lock_cm=capital_controller.lock_cm, and interval_seconds resolved from NEXUS_SNAPSHOT_INTERVAL_SECONDS (default 300 s). Started before the runtime is returned; stopped in _run_nexus_instance BEFORE ShutdownSequencer runs its own final checkpoint, so the scheduler's last periodic checkpoint and the shutdown checkpoint cannot race. Lock-cluster invariant is enforced by the scheduler's constructor (PR #77 review): both state.risk.lock is positions_lock AND capital_lock_cm must be supplied when positions_lock is — Praxis's wiring satisfies both conditions
  • Wire MtmLoop into the same per-account Nexus runtime. Constructed with positions_lock (same identity-equal lock as above) and a mark_price_provider callable that returns Decimal | None per symbol: for the current single-symbol BTCUSDT deployment, it wraps the existing _last_close_from_poller (which returns the last 1m close from MainCache or None when the cache is empty or stale). Symbols other than BTCUSDT return None, which MtmLoop treats as "mark unavailable" and aborts the tick without partial writes. interval_seconds resolved from NEXUS_MTM_INTERVAL_SECONDS (default 30 s). Started after SnapshotScheduler.start(); stopped before it in _run_nexus_instance
  • Add snapshot_scheduler: SnapshotScheduler and mtm_loop: MtmLoop fields to the _NexusRuntime dataclass so _run_nexus_instance can stop both in lifecycle order before ShutdownSequencer. Add _DEFAULT_SNAPSHOT_INTERVAL_SECONDS = 300.0 and _DEFAULT_MTM_INTERVAL_SECONDS = 30.0 module constants
  • Add _positive_float_env helper that parses a positive, finite numeric env var with operator-visible errors on typo or invalid value. Bare float(os.environ.get(...)) raises ValueError: could not convert string to float: ... which surfaces as a per-account thread death (caught by _run_nexus_instance's BLE001) with no operator-actionable signal; the helper validates the value and raises RuntimeError carrying the env var name + value + expected shape, which surfaces in the launcher's structured log. The finiteness gate (math.isfinite(value)) rejects inf and nan — both slip past value <= 0 (float('inf') <= 0 and float('nan') <= 0 are both False), and either would propagate to threading.Timer as silent misconfiguration (inf makes the scheduler wait forever, nan is undefined) — defeating the helper's whole purpose of operator-visible validation (PR #128 review by zero-bang). Applied to NEXUS_SNAPSHOT_INTERVAL_SECONDS and NEXUS_MTM_INTERVAL_SECONDS. Tests in tests/test_launcher_positive_float_env.py (9 cases) pin unset/empty/valid/non-numeric/zero/negative/inf/nan paths
  • Add TD-069 to docs/TechnicalDebt.md: MtmLoop.mark_price_provider returns None for any symbol other than BTCUSDT, which MtmLoop treats as "abort entire tick" (per its strict-no-partial-writes contract). Low impact today (BTCUSDT-only deployments shipped) but becomes a correctness blocker on first multi-symbol manifest — silently degrades MTM for the open book with only a per-tick WARN log as signal. Migration path: per-symbol-keyed MainCache.get_last_close(symbol, kline_size) plus a boot-time assertion that every manifest symbol has a working lookup

Update

  • Bump vaquum-nexus pin from 2cae5c0 (v0.53.1) to bd61a0a (Nexus PR #77, v0.54.0) in pyproject.toml. v0.54.0 ships SnapshotScheduler + MtmLoop + a strategy_unrealized_pnl: Decimal field on StrategyRiskState + split max_drawdown (realized-only) vs new max_total_drawdown (realized + unrealized) lifetime peaks on RiskState. Backward-compat decode (_decode_risk_state defaults max_total_drawdown and _decode_strategy_risk_state defaults strategy_unrealized_pnl to '0' when missing) means existing Praxis snapshots load without migration; the new MtmLoop tick overwrites zeros on the next cycle. The validator's max-drawdown gate (risk_stage.py → to_risk_check_metrics → max_drawdown_pct) retains realized-only semantics — pre-v0.69.0 calibration stays valid; the new max_total_drawdown_pct field is exposed for telemetry and any future tighter mark-aware gate
  • Update tests/test_launcher_shutdown_config_wiring.py _stub_nexus_runtime to supply the two new _NexusRuntime fields (snapshot_scheduler=MagicMock(), mtm_loop=MagicMock()) so the shutdown-wiring test still constructs a complete runtime. Praxis's full pytest suite passes against the new stack: 1354 passed, 1 skipped — identical to v0.68.2 baseline

v0.70.0 on 2nd of June, 2026

NOTE

  • Hardens the binsim depth poller against a recurring upstream-mirror failure mode. Post-mortem of the 2026-05-31T16:47:23Z HALT (recovered manually, ran for 19h+ in HALTED state before restart) traced the cascade to a single bad upstream snapshot served by binance-spot-depth20-1000ms.onrender.com: 17 consecutive POST /api/v3/order rejections over 629 ms all reported insufficient book liquidity: requested 0.02721, visible 0.00962 across 20 levels — the exact same visible value to the last decimal across all 17. That uniformity is the design's intended in-window behavior (OrderBook.consume_qty_for_market_order is non-mutating, so all orders within a single 1000 ms poll window see the identical snapshot — see praxis/binsim/book.py docstring), but a top-20 BTCUSDT depth of 0.00962 BTC is not a real Binance state; the upstream mirror served broken data and binsim accepted it because no policy gate beyond shape validation existed. The same identical-visible cluster pattern appears in the event spine for May 27 (2 hits @ 0.02141/0.02149), May 28 (3 hits across hours), May 30 morning (9 hits @ 0.02023 in 0.45 s), and May 30 evening (2 hits @ 0.02550 in 5 ms) — recurring mirror pathology, not isolated market events. The fixes below add two policy gates and one diagnostic at the poller boundary so future hiccups produce clean -1003 (book stale) rejections via the existing HTTP staleness gate rather than burst rejections that look like market signal to HealthEvaluator

Add

  • Add a magnitude-floor gate to DepthPoller.poll_once: on each successful HTTP poll, after _parse_payload succeeds, compute sum(qty for _, qty in asks[:20]) and sum(qty for _, qty in bids[:20]). If either is below min_top20_depth_btc (default 0.05, env-tunable via BINSIM_MIN_TOP20_DEPTH_BTC), log at ERROR with both sums + per-side *_levels_in_payload counts + the floor + last_update_id + ts_ms and return without touching the book or _last_success_ts_ms. The book stays on its last accepted snapshot; the existing 5 s HTTP staleness gate in server._submit_order fires after the threshold and surfaces the upstream problem as Binance-shaped -1003 rejections. The 0.05 BTC default catches every historical bad snapshot (0.00962 → 0.02597) while leaving headroom over the current upstream bid-side depth (~0.4 BTC). The check is part of the policy layer, not OrderBook.replace, so OrderBook stays a pure data-shape primitive. The module constant _TOP_20_LEVELS = 20 (Greybeard pre-PR review) keeps the gate width's "20" tied to the env var name BINSIM_MIN_TOP20_DEPTH_BTC so the two cannot drift
  • Add a stuck-lastUpdateId detector to DepthPoller.poll_once: real Binance advances lastUpdateId on every diff, so an upstream serving the identical id across max_stuck_update_id_polls consecutive polls (default 5, env-tunable via BINSIM_MAX_STUCK_UPDATE_ID_POLLS, meaningful minimum 2 — baseline + one repeat; 1 would brick the feed since the first poll alone would trip the threshold, so both the DepthPoller constructor and the env-var parser reject it explicitly — PR #129 review by zero-bang / Copilot) is frozen even if its shape and magnitude validate. New _previous_last_update_id + _stuck_update_id_count poller state tracks the run, counting the first observation as poll 1 so BINSIM_MAX_STUCK_UPDATE_ID_POLLS=N means "reject on the Nth consecutive identical poll" — matches the operator's natural reading of the env-var name (Greybeard pre-PR review). A fresh id resets the counter to 1 (this poll is observation 1 of the new id); reaching the threshold logs at ERROR with the id + run length + threshold and returns without replace / _last_success_ts_ms update. Same recovery path as the magnitude floor — the HTTP staleness gate becomes the operator's surfacing layer
  • Add a per-poll success diagnostic log to DepthPoller.poll_once: on every successful book.replace, emit a single structured INFO line containing ask_top_n_qty, bid_top_n_qty, ask_levels_in_payload, bid_levels_in_payload, best_ask_price, best_ask_qty, best_bid_price, best_bid_qty, last_update_id, ts_ms. The *_levels_in_payload fields (Greybeard pre-PR review) record how many levels the upstream actually returned so a truncated snapshot (e.g. 3 levels totalling 0.06 BTC) cannot pass the floor silently — the operator can spot from logs that the depth was thin-by-truncation rather than thin-by-market. Previously the success path was silent — only failures logged — which made post-mortem reconstruction of bad upstream snapshots impossible once the affected OrderSubmitFailed events rotated out of the launcher's container log
  • Add env-var wiring in praxis/binsim/__main__.py: two new optional BINSIM_* env vars (BINSIM_MIN_TOP20_DEPTH_BTC, BINSIM_MAX_STUCK_UPDATE_ID_POLLS) feed _Config and the DepthPoller constructor. The Decimal parser (_parse_positive_decimal_env) rejects non-finite values (NaN, Infinity, -Infinity), zero, and negatives at parse time so the validation surfaces before the poller starts. The binsim ready startup log line includes both tunables so deployment operators see the configured values without inspecting env vars manually. Both new env vars are also documented in docs/Binsim.md's operator-facing "Required Binsim Environment" reference table so operators consult one canonical source (PR #129 review by zero-bang)
  • Add 11 new tests to tests/test_binsim_feed.py covering: constructor validation for non-positive / non-finite min_top20_depth_btc and non-positive max_stuck_update_id_polls; poll_once rejection paths for sub-floor ask-side and bid-side depth; poll_once acceptance at exact floor; stuck-id detector rejecting after N identical polls; stuck-id counter resetting when the id changes; and the per-poll success diagnostic containing the magnitude + best-of-book values needed by an operator post-mortem. Add 4 new tests to tests/test_binsim_main.py for the new env vars (defaults, full overrides, invalid-decimal cases including NaN/Infinity/0/negative, invalid-int cases for the stuck-polls var, blank-fallback)

Update

  • Bump version from 0.69.0 to 0.70.0 in pyproject.toml. Full binsim test suite passes: 275 tests passed across test_binsim_book.py, test_binsim_feed.py (54 cases, 11 new), test_binsim_main.py (37 cases, 4 new), test_binsim_server.py, test_binsim_ledger.py, test_binsim_ws.py. ruff check clean on the four touched files
  • Note TD-070 in docs/TechnicalDebt.md: the per-poll success diagnostic INFO log fires at the full BINSIM_POLL_INTERVAL_MS cadence (~86,400 lines/day at the 1 Hz default), which is operationally noisy enough to push useful Praxis events past the container json-file driver's max-size=50m × max-file=5 rotation window faster than they would otherwise age out. Migration: either throttle the INFO line to a once-per-N-polls heartbeat with the per-poll line at DEBUG, or emit the snapshot as a structured metric instead. When to fix: when the volume starts displacing useful Praxis logs in a real post-mortem, OR when a metrics path lands
  • Note TD-071 in docs/TechnicalDebt.md: the magnitude floor applies min_top20_depth_btc symmetrically to ask AND bid sides via or, but the live upstream shows persistent ask/bid asymmetry (~5.6 BTC ask vs ~0.4 BTC bid top-20) and the current buy-only deployment depends on ask-side liquidity; any future tightening of the floor past the upstream's typical bid depth would force every poll to reject on the bid side even with a healthy ask. Migration: split into min_top20_ask_depth_btc + min_top20_bid_depth_btc poller fields with corresponding env vars, defaulting to the existing single-knob value for backward compatibility. When to fix: when an incident reveals ask-side thinness in the gap between the current floor and the bid-side norm, OR when a sell-side strategy lands

v0.71.0 on 4th of June, 2026

NOTE

  • Adds a Docker-Compose-based observability stack (ClickHouse + spine-mirror service + Grafana) under observability/ that ingests every row from event_spine.sqlite into a ReplacingMergeTree(event_seq) ClickHouse table for flexible querying. Mirrors against /opt/praxis/state/event_spine.sqlite read-only and tails new event_seq rows on a 5-second cadence; ClickHouse MATERIALIZED columns project strategy_id, command_id, trade_id, symbol, side, account_id, status, reason, qty, price, fee out of the JSON payload at write time so dashboards can filter / group / aggregate without per-query JSONExtract*. Grafana is provisioned with the ClickHouse datasource + two starter dashboards (praxis-overview and praxis-events) and exposes UI on 127.0.0.1:3001 behind basic auth. ClickHouse exposes two operator-facing ports: HTTP on 127.0.0.1:8124 for ad-hoc curl http://praxis:<PW>@127.0.0.1:8124/?query=... style access, and the native TCP protocol on 127.0.0.1:9001 for clickhouse-client --host 127.0.0.1 --port 9001 --user praxis --password ... --database praxis (the native protocol is what clickhouse-client uses; HTTP is for tooling that prefers REST). The stack is operationally separate from Praxis runtime: stopping it has zero impact on trading

Add

  • Add observability/docker-compose.observability.yml — three services on a private observability bridge network: praxis-clickhouse (ClickHouse 24.8, persistent named volume clickhouse_data, file-descriptor ulimit 262144, published on 127.0.0.1:8124), praxis-spine-mirror (built from observability/Dockerfile.spine-mirror — python:3.12-slim base with clickhouse-connect==0.8.10 pre-installed and spine_mirror.py baked in at image build, no pip-install on container start; mounts the host's /opt/praxis/state read-only), and praxis-grafana (Grafana 11.2.0, grafana-clickhouse-datasource plugin auto-installed at start, anonymous + sign-up disabled, basic-auth required, published on 127.0.0.1:3001). Both secrets (CLICKHOUSE_PASSWORD, GRAFANA_ADMIN_PASSWORD) are read from an observability/.env file via Compose env interpolation with mandatory :?<msg> guards so the stack refuses to start with missing values. Add observability/Dockerfile.spine-mirror so spine-mirror builds a pre-baked image rather than running pip install on every container start
  • Add observability/spine_mirror.py — standalone polling-mirror service. Opens the spine SQLite as file:...?mode=ro via a with sqlite3.connect(...) context manager (URI mode with PRAGMA query_only=ON for defense-in-depth read-only access), tracks the high-water mark via SELECT max(event_seq) FROM <database>.events (idempotent on restart — no separate cursor file; <database> is the validated CLICKHOUSE_DATABASE value), pulls up to BATCH_SIZE=10000 rows per tick WHERE event_seq > cursor ORDER BY event_seq, parses the timestamp column to a UTC-aware datetime via _parse_ts (handles +00:00, Z, naive, and tz-aware non-UTC offsets — uses astimezone(UTC) when an offset is present and only replace(tzinfo=UTC) for truly-naive inputs), and batch-inserts into <database>.events. Recoverable errors are caught via _RECOVERABLE_ERRORS = (sqlite3.Error, OSError, clickhouse_connect.driver.exceptions.DatabaseError, clickhouse_connect.driver.exceptions.OperationalError), logged at ERROR with traceback via _log.exception, and sleeping is gated by _backoff_seconds(consecutive_failures) (exponential, doubling from 1s, clamped at 300s) so a transient ClickHouse outage / network blip does not kill the service — the next successful tick reads the persisted max(event_seq) and resumes
  • Add observability/grafana-provisioning/datasources/clickhouse.yaml — auto-provisions the "Praxis ClickHouse" datasource (UID praxis-clickhouse) at Grafana start; password is read from the CLICKHOUSE_PASSWORD env var that Compose injects into the Grafana container
  • Add observability/grafana-provisioning/dashboards/dashboards.yaml + praxis-overview.json + praxis-events.json — two starter dashboards available immediately on first launch. praxis-overview shows event-rate-per-type, top-N strategies by event count, and fill / reject / ack proportions; praxis-events is a row-level query workbench with strategy_id / event_type / time-range variables wired to the materialized columns
  • Add observability/.env.example — commit-safe template with placeholder values for CLICKHOUSE_PASSWORD and GRAFANA_ADMIN_PASSWORD. Operators copy this to observability/.env (already gitignored via the repo-wide .env rule) and fill in the real values before docker compose -f observability/docker-compose.observability.yml up -d --build (--build is required on first launch to bake the spine-mirror image)

Update

  • Bump version from 0.70.0 to 0.71.0 in pyproject.toml. The observability stack is operational infrastructure — no Praxis runtime code is touched, no Praxis test surface is added or modified; existing test suites continue to pass unchanged
  • Pre-PR Greybeard review (6 VALID_FIX, 5 VALID_TD recorded; describes the diff from the first commit's pre-fix draft to the shipped behaviour): hoist env-var reads from module scope into main() so the module can be imported for testing / tooling without the full prod env set; replace the draft's three print() call sites with logging.getLogger(__name__) + _log.info / _log.exception (the latter auto-includes a traceback so a future ClickHouse driver DatabaseError lands in the container log with full call frames); narrow the draft's bare except Exception to a _RECOVERABLE_ERRORS = (sqlite3.Error, OSError, clickhouse_connect.driver.exceptions.DatabaseError, clickhouse_connect.driver.exceptions.OperationalError) tuple so programming errors propagate immediately instead of being swallowed; add exponential backoff — the shipped function is _backoff_seconds(consecutive_failures) (single arg after the round-1 review simplified the original draft signature), doubling from _BACKOFF_BASE_S=1.0s per consecutive failure and clamping at _BACKOFF_MAX_S=300s, with the counter resetting to 0 on the next successful tick (replaces the draft's "hot-loop every 5s on ClickHouse outage" pattern that would have hammered a broken upstream indefinitely); rename the _to_rows loop variable from payload to raw_payload + introduce decoded_payload so the rebinding-loop-var pattern flagged by ruff PLW2901 is gone; use datetime.UTC instead of the deprecated datetime.timezone.utc (ruff UP017). Also: convert the spine-mirror container from the draft's image: python:3.12-slim + command: sh -c "pip install ... && python ..." (which ran pip install on every container start, 5–10s of network-dependent latency, fails on a flaky pip mirror) to a pre-baked image built from observability/Dockerfile.spine-mirror + image: praxis-spine-mirror:0.71.0. ruff check clean on the touched file
  • Pre-PR Greybeard review (deferred to TD): record TD-073, TD-074, TD-075, TD-076 in docs/TechnicalDebt.md. TD-073: clickhouse_connect.get_client is called once at startup and the library's internal auto-reconnect on transport failure is documented but not verified end-to-end against a real ClickHouse container restart; migration is a _ClientHolder that rebuilds on consecutive OperationalError. TD-074: depends_on.praxis-clickhouse.condition: service_started waits for the container to be up, not for ClickHouse to accept queries; migration is a healthcheck block on praxis-clickhouse and flipping both consumers to service_healthy. TD-075: the /opt/praxis/state:/spine:ro bind-mount source is a hardcoded host path; migration is ${PRAXIS_STATE_DIR:-/opt/praxis/state} with the default preserving existing deployments. TD-076: spine_mirror.py's _parse_ts, _current_cursor, _backoff_seconds, and _to_rows have no automated coverage; migration is a tests/test_spine_mirror.py with parser-shape / NULL-cursor / backoff-clamp cases
  • Post-PR-review fix (PR #131 round-1 review by zero-bang + Copilot, 13 threads): (1) pin Grafana to 127.0.0.1:3001:3000 in docker-compose.observability.yml — was "3001:3000" which binds all interfaces, contradicting the documented localhost-only posture (CHANGELOG NOTE bullet); (2) drop the action_type MATERIALIZED column from the ClickHouse schema in spine_mirror.py — no spine event dataclass carries an action_type field (audited all 12 events in praxis/core/domain/events.py; action_type is a Nexus ActionType attribute that lives on nexus.strategy.action.Action, not on any persisted Praxis spine event) so the column was permanently empty '' and the open_pos panel's countIf(event_type='CommandAccepted' AND action_type='enter') was always 0; the panel's query is rewritten to uniqExactIf(trade_id, event_type='CommandAccepted' AND trade_id != '') - uniqExactIf(trade_id, event_type='TradeClosed' AND trade_id != '') which correctly counts open trades via distinct trade_id (each closed trade emits 2 CommandAccepted events for entry+exit but only 1 TradeClosed); action_type references also dropped from praxis-events.json's SELECT and column-width override; (3) parameterize the _SCHEMA_SQL table name via _SCHEMA_SQL_TEMPLATE.format(database=database) so a non-default CLICKHOUSE_DATABASE env value doesn't create the table in praxis and then insert into the configured database; (4) hoist clickhouse_connect.get_client + _ensure_schema into the retry loop body, gated by ch is None and schema_ready flags, so a ClickHouse cold-start race (the depends_on: service_started only-waits-for-container-up case) flows through _RECOVERABLE_ERRORS + _backoff_seconds instead of crashing the process before the loop starts; (5) simplify _backoff_seconds(consecutive_failures) — drop the unused base_interval_s parameter and the dead consecutive_failures <= 0 branch (the call site always passes >= 1 after the consecutive_failures += 1 increment); update the call site accordingly; (6) switch _fetch_batch to with sqlite3.connect(...) as conn: context manager (consistent with tests/test_event_spine.py's usage); (7) switch the three MATERIALIZED toDecimal128OrZero columns (qty, price, fee) to Nullable(Decimal(38, 18)) + toDecimal128OrNull (Copilot review overruled the pre-PR TD-072 deferral: brand-new stack, no migration needed — TD-072 entry is removed); (8) wrap the cash-flow panel's qty * price ± fee arithmetic in coalesce(col, 0) so the newly-Nullable columns don't propagate NULL through the time series; (9) password: $CLICKHOUSE_PASSWORD → password: ${CLICKHOUSE_PASSWORD} in grafana-provisioning/datasources/clickhouse.yaml — Grafana provisioning expands ${VAR} but treats $VAR as a literal, so the datasource was authenticating with the string "$CLICKHOUSE_PASSWORD" (would have failed silently against ClickHouse on first dashboard load); (10) remove the hardcoded allValue: "0,1,...,20" from the epoch variable in praxis-overview.json — once epoch_id exceeds 20, selecting "All" would silently exclude newer epochs; with allValue omitted Grafana fans out the variable's current query results dynamically; (11) update the original Add bullet for docker-compose.observability.yml and the Add bullet for .env.example above to reflect the actual shipped stack (pre-baked Dockerfile image, 127.0.0.1:3001, observability/-prefixed compose-up example with --build)
  • Post-PR-review fix (PR #131 round-2 review by Copilot, 6 threads): (1) validate CLICKHOUSE_DATABASE against a ^[A-Za-z_][A-Za-z0-9_]*$ identifier-shape regex in main() before it gets interpolated into the schema CREATE DATABASE / CREATE TABLE SQL strings — rejects names with quoting needs, whitespace, hyphens, or anything malicious before the first SQL call lands; (2) NOTE bullet for v0.71.0 above no longer claims an action_type MATERIALIZED column (dropped in round-1, the NOTE list is now in sync with the shipped schema); (3) the Add bullet for docker-compose.observability.yml above no longer says "All three secrets" — there are two (CLICKHOUSE_PASSWORD, GRAFANA_ADMIN_PASSWORD); (4 + 5) the Pre-PR Greybeard Update bullet above is reframed to make clear the _backoff_seconds(consecutive_failures, base_interval_s) and bare-except Exception shapes are the draft state being replaced, not the shipped state; the shipped function is _backoff_seconds(consecutive_failures) and the shipped error scope is the _RECOVERABLE_ERRORS tuple; (6) TD-074 description in docs/TechnicalDebt.md updated to reference the shipped _RECOVERABLE_ERRORS retry envelope and the _backoff_seconds(consecutive_failures) API instead of the round-0 draft signature
  • Post-PR-review fix (PR #131 round-3 review by Copilot, 2 threads): (1) _parse_ts in observability/spine_mirror.py no longer overwrites the offset on tz-aware non-UTC strings — the previous implementation's default branch used datetime.fromisoformat(raw).replace(tzinfo=UTC), which silently shifted instants when the spine wrote event.timestamp.isoformat() with any offset other than +00:00. The spine's validator (_EventBase.__post_init__) enforces tz-awareness but not UTC, so a non-UTC offset can land on disk; the fix normalizes a trailing Z to +00:00, parses via fromisoformat, and then either astimezone(UTC) (preserves instant) when the parsed value is tz-aware OR replace(tzinfo=UTC) only for the truly-naive case. Verified against six shapes (+00:00, Z, naive, -05:00, +05:30, microsecond-bearing) via inline smoke-tests; (2) add docstrings to all seven functions in spine_mirror.py (_parse_ts, _ensure_schema, _current_cursor, _fetch_batch, _to_rows, _backoff_seconds, main) matching the project's NumPy-style convention used in praxis/infrastructure/observability.py and praxis/launcher.py (one-line summary, Args:, Returns:/Raises: blocks where applicable, single-quote triple-strings, no embedded examples per CLAUDE.md)
  • Post-PR-review fix (PR #131 round-4 review by Copilot, 6 threads): (1) fix the NOTE bullet's ClickHouse-access wording — was "ClickHouse HTTP on 127.0.0.1:8124 for ad-hoc psql / clickhouse-client access" which is wrong on two counts (ClickHouse doesn't use psql; clickhouse-client uses the native TCP protocol on 127.0.0.1:9001, not HTTP). New wording splits the two access paths: HTTP for curl http://praxis:<PW>@127.0.0.1:8124/?query=... style REST tooling, native TCP for clickhouse-client --port 9001; (2) rewrite the Add observability/spine_mirror.py bullet (line 876) to describe the shipped behaviour — replaces the stale draft description of "Bare-Exception catch + structured print(...)" with the actual shipped _RECOVERABLE_ERRORS = (sqlite3.Error, OSError, clickhouse_connect.driver.exceptions.DatabaseError, clickhouse_connect.driver.exceptions.OperationalError) tuple, _log.exception logging, exponential backoff via _backoff_seconds(consecutive_failures), with sqlite3.connect(...) context manager, validated <database> identifier, and the _parse_ts astimezone-vs-replace branching. The line-871 NOTE-bullet fix and this line-876 Add-bullet fix together close the last two CHANGELOG sites that still described the round-0 draft instead of the shipped v0.71.0 state; (3 – 6) switch all four praxis-events.json panels (rows-matching, distinct-strategies, distinct-commands, spine-events-table) from raw-interpolated '$strategy_id_filter' to Grafana's ${strategy_id_filter:sqlstring} formatter, which auto-quotes the value and escapes embedded single quotes via the SQL '' doubling convention. This closes the SQL-injection / quote-breakage surface in the events dashboard for any operator input containing a ' (e.g. a strategy_id like O'Brien_v3). praxis-overview.json does not declare or interpolate strategy_id_filter so no parallel sites; the SELECT clauses' static single-quoted literals (event_type = 'CommandAccepted', etc.) are not affected — only operator-provided variables route through :sqlstring
  • Post-PR-review fix (PR #131 round-5 review by Copilot, 4 threads): (1) harden observability/Dockerfile.spine-mirror to match the repo's existing image-build pattern in Dockerfile + Dockerfile.binsim — add PYTHONUNBUFFERED=1 + PYTHONDONTWRITEBYTECODE=1 + PIP_NO_CACHE_DIR=1 + PIP_DISABLE_PIP_VERSION_CHECK=1 env defaults, create a non-root spinemirror user at uid 1000 via useradd --create-home, chown -R spinemirror:spinemirror /app, and USER spinemirror so the spine-mirror process drops privileges before running spine_mirror.py. Reduces blast radius if the process is ever compromised (the mount of /opt/praxis/state is already :ro so the worst case is a non-root container with read-only access to the spine — no write path to anything on the host); (2 + 3) replace the hardcoded "current": {"selected": true, "text": "10", "value": "10"} default on the epoch variable in both praxis-overview.json and praxis-events.json with "current": {"selected": true, "text": "All", "value": "$__all"} so a fresh / new-host deployment opens to the full epoch set instead of an empty dashboard (the "10" was a copy from the dev box's epoch); (4) cache the spine cursor in-process across polling ticks in spine_mirror.py's main(). The previous implementation called _current_cursor(ch, ch_database) on every tick — a SELECT max(event_seq) FROM <database>.events round-trip against ClickHouse — even though the mirror already knows the last inserted event_seq after each successful insert. The new flow primes cached_cursor from _current_cursor exactly once on the first successful tick (logged at INFO: 'cursor primed from ClickHouse: event_seq=%d'), advances it to last_seq after each successful ch.insert, and only re-primes from ClickHouse on a process restart. Steady-state ticks now hit only the SQLite _fetch_batch query and (when there are new rows) the ClickHouse INSERT; the read-side max(event_seq) query is gone from the hot path. Per-tick latency drops from "two ClickHouse round-trips + one SQLite query" to "one SQLite query" when the spine is idle, and "two ClickHouse round-trips + one SQLite query" → "one ClickHouse round-trip + one SQLite query" when there are new rows. main()'s docstring updated to document the cursor-priming + advance-on-insert semantics
  • Post-PR-review fix (PR #131 round-6 review by Copilot, 2 threads): (1) drop the database=ch_database keyword from clickhouse_connect.get_client(...) in spine_mirror.py main(). The client constructor selects the named database on connect; if the target database doesn't yet exist (which is exactly the case _ensure_schema's CREATE DATABASE IF NOT EXISTS is meant to handle), the very first get_client call would have failed with "Database doesn't exist" — putting main() into a permanent _RECOVERABLE_ERRORS backoff loop, never reaching _ensure_schema to create the database. The fix removes database= so the connection is database-less; every SQL statement already uses fully-qualified <database>.events so the default-database selection was not load-bearing for any query path. Mirror can now bootstrap against a ClickHouse instance that has never seen the target database; (2) add tests/test_spine_mirror.py (36 cases, all pass) covering _parse_ts across 6 timestamp shapes (UTC, Z, naive, -05:00, +05:30, microsecond-bearing), _backoff_seconds monotonicity + clamp at _BACKOFF_MAX_S, _to_rows bytes/str/invalid-utf8 round-trip + integer coercion, _current_cursor empty-table / NULL / populated / supplied-database paths against a mocked clickhouse_connect client, _IDENTIFIER_RE positive (6 safe names) + negative (10 unsafe names including hyphen / space / semicolon / ' / ` / $ / . / SQL-injection shapes), and _ensure_schema issues the correct CREATE DATABASE + CREATE TABLE statements against the supplied database name. Test file uses importlib.util.spec_from_file_location to load the module by path since observability/spine_mirror.py is outside the praxis package import surface. TD-076 entry removed from docs/TechnicalDebt.md (Copilot review overruled the pre-PR deferral, matching the TD-072 pattern from round-1)

v0.72.0 on 5th of June, 2026

NOTE

  • Closes Vaquum/Praxis#130. Companion fix to Vaquum/Nexus#78 (terminal-fill residual release), which closed with Vaquum/Nexus#79 merged at Nexus ac0aadd. Same prod incident class — 876 strategies × ~$2–7 of ghost-deployed capital after fully-closed round-trips on Praxis prod (epoch 10, binsim) — split between the Praxis-side qty mismatch and the Nexus-side notional residual. Nexus v0.55.0 closed the notional half; this PR closes the qty half by floor-snapping cmd.qty to the venue's LOT_SIZE.stepSize at command-creation time (before the validator pipeline runs capital reservation), so TradeOutcomeProduced.status=PARTIAL no longer fires on every entry where the strategy's un-quantized action.size = budget / reference_price carried sub-step precision. Acceptance criterion 3 from the issue: OrderSubmitIntent.qty now matches what BinanceAdapter._snap_qty_to_lot_step would have produced — the adapter-side snap at submit_order becomes a no-op for command-creation paths that route through the new quantize_for_command

Add

  • Add CommandQuantization frozen dataclass to praxis/infrastructure/venue_adapter.py: snapped_qty: Decimal | None + rejection_reason: str | None, with the invariant that exactly one is None (success → snapped_qty populated; rejection → rejection_reason carries a structured INTAKE_* string). Used as the return type of the new protocol method VenueAdapter.quantize_for_command
  • Add quantize_for_command(symbol, qty, order_type, *, reference_price=None) to the VenueAdapter protocol. Implementations floor-snap qty to the symbol's LOT_SIZE.stepSize via (qty // step) * step (NOT Decimal.quantize, which rounds to the step's decimal-exponent rather than to an integer multiple — wrong for non-pure-10^-n steps like 5 or 0.00001000 with eight fractional digits), gate against LOT_SIZE.minQty pre-snap AND post-snap (a sub-step input can snap to 0), and gate against NOTIONAL.minNotional when reference_price is supplied. Implementations return the input qty unchanged when the symbol's filters are not yet cached — the existing submit_order-time snap remains the backstop and the launcher's command flow stays operational even before exchangeInfo lands
  • Add quantize_for_command implementation to BinanceAdapter reading from the existing self._filters[symbol] cache populated by load_filters / get_exchange_info. Rejection reasons follow the INTAKE_<CHECK> <key>=<value> convention: INTAKE_BELOW_MIN_QTY qty=... symbol=... lot_min=... (pre-snap minQty miss), INTAKE_BELOW_MIN_QTY qty=... snapped=... symbol=... lot_min=... lot_step=... (snap-to-zero case), and INTAKE_BELOW_MIN_NOTIONAL notional=... qty=... reference_price=... symbol=... min_notional=... (snapped notional below the venue floor). Suitable for direct emission as a Nexus ACTION_REJECTED reason
  • Add venue_adapter: VenueAdapter | None = None keyword parameter to _build_validation_context, _build_enter_context, and _build_exit_context. When present, the launcher routes action.size through venue_adapter.quantize_for_command(symbol, action.size, quantize_order_type, reference_price=...) BEFORE computing order_notional, so ValidationRequestContext.order_size and ValidationRequestContext.order_notional reflect the snapped qty all the way to capital reservation. quantize_order_type is derived as translate_order_type(action.order_type) if action.order_type is not None else OrderType.MARKET so future LIMIT / STOP actions are quantized under the venue's per-type filter rules (round-4 review fix). On rejection (CommandQuantization.rejection_reason is not None), the helper logs a structured WARNING with strategy_id, command_id (or trade_id for EXIT), symbol, reference_price / entry_price, requested_size, and the structured reason, then returns None — the caller drops the action. Wired through the build_context closure in Launcher.start to self._trading.venue_adapter (the canonical adapter Trading.__init__ instantiates — either the injected one or the internally-constructed BinanceAdapter; round-6 critical-correctness review fix means quantization runs in the default prod wiring rather than only on explicit-injection test paths)
  • Add 9 new tests in TestQuantizeForCommand covering: unchanged passthrough when filters are not cached, high-precision input snapped to 0.00024 against a 5-decimal lot_step, already-aligned qty preserved, INTAKE_BELOW_MIN_QTY rejection pre-snap, snap-to-zero on a lot_step=5 filter with qty=4, INTAKE_BELOW_MIN_NOTIONAL rejection when snapped notional falls below the venue floor, reference_price=None skipping the notional gate, return-type pinning to CommandQuantization, and the parity invariant (re-running _snap_qty_to_lot_step on an already-quantized qty is a no-op — acceptance criterion 3)
  • Add tests/test_launcher_qty_snap.py (14 cases): _build_enter_context and _build_exit_context with venue_adapter=None preserve action.size unchanged (pre-fix parity); with a real BinanceAdapter they snap a high-precision 0.0002455253013823074467823909254 input to 0.00024, recompute order_notional = snapped_qty * reference_price, and return None on INTAKE_BELOW_MIN_QTY / INTAKE_BELOW_MIN_NOTIONAL rejections (acceptance criterion 1 + 4). Includes a parametrized round-trip for four non-aligned action.size shapes and a MagicMock-based test that pins the quantize_for_command(..., reference_price=...) keyword-call contract

Update

  • Bump vaquum-nexus git+https pin from bd61a0a60eefe8c55ef43719c72081193f66e097 (Nexus v0.54.0 — SnapshotScheduler + MtmLoop) to ac0aadd6e76c593592a14e76f7be5be50340386d (Nexus v0.55.0 — terminal-fill residual release, Vaquum/Nexus#79). Required for the qty-side fix to land its full impact: a Praxis-side step-snap that brings cmd.qty onto the LOT_SIZE grid eliminates the most common cause of fill_notional < reservation.notional (sub-step underfills), but a venue VWAP below the reservation reference price can still leave a sub-notional residual on the entry — Nexus v0.55.0's CapitalController.order_fill(terminal=True) now releases that residual back to available / per_strategy_deployed instead of parking it forever. The two fixes together close both halves of the per_strategy_deployed ghost-residual class
  • Update tests/test_venue_adapter.py TestVenueAdapterProtocol.test_conforming_class_isinstance: the _FakeAdapter stub adds a no-op quantize_for_command method so the @runtime_checkable Protocol isinstance check stays green after the new method joined the protocol surface
  • Bump version from 0.71.0 to 0.72.0 in pyproject.toml. Full Praxis test suite passes (1450 tests, 1 skipped, 0 failures before the Greybeard fixes below, 1457, 1 skipped after); ruff check praxis tests clean
  • Pre-PR Greybeard review (3 VALID_FIX, 1 VALID_TD recorded): (1) add qty.is_finite() + reference_price.is_finite() guards at the top of BinanceAdapter.quantize_for_command with new INTAKE_NON_FINITE_QTY / INTAKE_NON_FINITE_REFERENCE_PRICE rejection reasons; a Decimal('NaN') or Decimal('Infinity') from any caller (replay, backtest, future custom strategy) now produces a clean structured rejection rather than decimal.InvalidOperation propagating uncaught into the launcher dispatch loop. (2) enforce the CommandQuantization "exactly one of snapped_qty, rejection_reason non-None" invariant in __post_init__ with ValueError on either-both-None or either-both-non-None — the docstring already documented the contract but a stray constructor at the call site would have silently produced a downstream contradiction. (3) remove the unreachable snapped <= 0 half of the post-snap rejection in quantize_for_command; the pre-snap qty < lot_min rejection at the top already prevents reaching post-snap with snapped <= 0 given lot_min > 0, so the disjunction obscured which branch fires the rejection. Add 4 new tests in TestQuantizeForCommand (NaN qty, Infinity qty, NaN reference_price, finite-check ordering before filter-cache lookup) and 4 new tests in new TestCommandQuantizationInvariant class (accepts snapped-only, accepts rejection-only, rejects both-None, rejects both-non-None)
  • Pre-PR Greybeard review (deferred to TD): record TD-077 in docs/TechnicalDebt.md. On cold start, BinanceAdapter._filters is empty until the first get_exchange_info round-trip lands; quantize_for_command(symbol, qty, ...) returns the input qty unchanged in that window, so the launcher reserves capital against the un-snapped qty before submit_order's _snap_qty_to_lot_step snaps the actual venue request down. Bounded by one lot_step × reference_price (e.g. $0.80 on a BTCUSDT order at $80k), transient (gone after the first round-trip closes via Nexus v0.55.0's terminal-release path), but documented as a known cold-start quirk. Migration: either reject as INTAKE_FILTERS_NOT_CACHED (conservative, eats initial throughput), or gate Launcher.start_dispatch on a get_exchange_info await (cleaner, +100-200ms cold start)
  • Post-PR-review fix (PR #132 round-1 review by zero-bang, 1 thread): fix test_rejects_when_snap_collapses_to_zero (renamed to test_rejects_when_snap_collapses_below_min_qty) in tests/test_binance_adapter.py so it actually exercises the post-snap INTAKE_BELOW_MIN_QTY branch in BinanceAdapter.quantize_for_command. Pre-fix the test used lot_min=5, lot_step=5, qty=4 — but qty=4 < lot_min=5 means the pre-snap guard fires and the post-snap branch (line 1173, if snapped < filters.lot_min) is never reached; the assertion only checked the shared INTAKE_BELOW_MIN_QTY substring, so the test passed for the wrong reason and provided no coverage of the post-snap re-check. Filters now lot_step=5, lot_min=1: qty=4 >= 1 passes pre-snap, then snapped = (4 // 5) * 5 = 0 < 1 correctly trips the post-snap branch. New assertions check 'snapped=0' and 'lot_step=5' substrings — both uniquely produced by the post-snap rejection (the pre-snap variant emits neither). Also add a comment in quantize_for_command noting the post-snap re-check is defensive-only on real Binance Spot filters (where minQty >= stepSize always holds), but reachable for custom SymbolFilters with lot_step > lot_min
  • Post-PR-review fix (PR #132 round-2 review by Copilot, 1 thread): change assert result.snapped_qty is raw to assert result.snapped_qty == raw in test_returns_unchanged_when_filters_not_cached. The quantize_for_command contract only requires returning a numerically equal Decimal, not the same Python object — is over-constrains the implementation against a future refactor that copies, normalizes, or caches Decimals. Sweep audit: this was the only object-identity assertion on a Decimal value across all 31 new test cases (TestQuantizeForCommand + TestCommandQuantizationInvariant + test_launcher_qty_snap); every other is check is is None / is not None, which is correct because None is a singleton
  • Post-PR-review fix (PR #132 round-3 review by Copilot, 1 thread): change the _FakeAdapter.quantize_for_command stub in tests/test_venue_adapter.py from -> None: ... to -> CommandQuantization: return CommandQuantization(snapped_qty=Decimal('1'), rejection_reason=None). isinstance(x, VenueAdapter) only checks method names (Protocol runtime check), so the wrong return type didn't fail the test, but the stub mis-documented the API and would have returned None at any hypothetical call site that depended on the protocol's actual contract. Sweep audit: the other 16 _FakeAdapter stubs also return -> None: ... despite their protocol return types being non-None (SubmitResult, CancelResult, VenueOrder, etc.); those pre-date this PR's diff and Copilot didn't flag them — they remain a pre-existing cleanup opportunity not in scope here
  • Post-PR-review fix (PR #132 round-4 review by Copilot, 3 threads): (1 + 2) thread action.order_type through to venue_adapter.quantize_for_command in both _build_enter_context and _build_exit_context instead of hardcoding OrderType.MARKET. The Nexus Action.order_type is the Nexus OrderType enum; the launcher now translates it to the Praxis OrderType via the existing translate_order_type helper, falling back to OrderType.MARKET only when action.order_type is None (which Nexus's Action.__post_init__ permits for EXIT but not ENTER). Forward-compat for future LIMIT / STOP order paths so the venue's per-type filter behavior (e.g. NOTIONAL's applyMinToMarket=true exemption for non-MARKET) can be expressed in quantize_for_command without revisiting the call sites. Add 2 new tests in TestQuantizationStubInteraction: test_threads_action_order_type_through_to_adapter (Nexus OrderType.LIMIT action surfaces as Praxis OrderType.LIMIT in the adapter call), test_defaults_order_type_to_market_when_exit_action_order_type_is_none (EXIT action with order_type=None falls back to MARKET); (3) fix the TD-077 relative-link prefix in docs/TechnicalDebt.md — was [praxis/launcher.py](praxis/launcher.py) (resolves to docs/praxis/... on GitHub, broken), now [praxis/launcher.py](../praxis/launcher.py) (matches the working ../tests/... pattern used by TD-076). Same fix applied to the binance_adapter.py link in the same **Module**: line. Sweep audit: many other TD entries in the file use the prefix-less [praxis/...](praxis/...) form; those pre-date this PR's diff and weren't flagged in prior reviews — they remain a pre-existing cleanup opportunity not in scope here
  • Post-PR-review fix (PR #132 round-6 review by Copilot, 1 thread — critical correctness): the build_context closure in Launcher.start was passing self._venue_adapter (the constructor arg, defaults to None in the default main() wiring) where it should have passed self._trading.venue_adapter (the canonical adapter that Trading.__init__ always instantiates — either the injected one or an internally-constructed BinanceAdapter). Net effect of the bug: in default prod wiring (Launcher(...) called without venue_adapter=), _build_*_context saw venue_adapter=None, skipped the quantize_for_command block entirely, and the entire qty pre-snap fix this PR introduces was effectively dead code in production — cmd.qty would still arrive at the validator un-snapped, the BinanceAdapter._snap_qty_to_lot_step at submit_order time would do the only snap, and the PARTIAL-on-stepSize-rounding pattern that motivated this PR would persist. Fix: replace venue_adapter=self._venue_adapter with venue_adapter=(self._trading.venue_adapter if self._trading is not None else None). Existing test fixtures (MockVenueAdapter injected via the venue_adapter= kwarg) would not have caught this since the injected path passes self._venue_adapter through identically; only the default-wiring path was broken
  • Post-PR-review fix (PR #132 round-7 review by Copilot, 2 threads — both VALID_DOC): (1) update _build_validation_context's docstring (line 503-onwards) to describe the venue_adapter-aware order_notional shape — was order_notional = action.size * reference_price / ... * action.size (pre-fix prose), now correctly says snapped_qty * reference_price when venue_adapter is supplied and the original action.size * reference_price only when venue_adapter is None (e.g. in test paths). Both ENTER and EXIT bullets updated. (2) update the ### Add bullet for the venue_adapter kwarg above (line 904) to describe the shipped wiring — was claiming hardcoded OrderType.MARKET and self._venue_adapter, now correctly describes the translate_order_type(action.order_type) derivation with None-fallback (round-4 fix) and the self._trading.venue_adapter source (round-6 critical-correctness fix). Both fixes close the documentation drift introduced by rounds 4 + 6
  • Post-PR-review fix (PR #132 round-8 review by Copilot, 1 thread): mint command_id at the top of _build_enter_context via action.command_id or f'cmd-{uuid.uuid4().hex}' and use the minted value in all 3 rejection-path log lines (no-reference-price, no-size, quantize_for_command rejection). Pre-fix the rejection logs used action.command_id directly, which is None until _build_enter_context's accept-path mint at the bottom of the function — so a rejected ENTER would log command_id: null and the operator had no correlation handle for the dropped action. Sweep audit found a same-class variant in _build_validation_context's MODIFY skip log (line 576), fixed with the same or f'cmd-{uuid.uuid4().hex}' pattern. EXIT's rejection logs already used trade_id (required non-None at the function's earlier guard) so they're correlation-safe and untouched here
  • Post-PR-review fix (PR #132 round-9 review by Copilot, 2 threads): remove the unused _TS module-level constant (line 50) and the now-orphaned from datetime import UTC, datetime import (line 17) from tests/test_launcher_qty_snap.py. Pure dead-code cleanup — ruff didn't flag them (module-level constants aren't covered by F841's function-local scope) but the constant was an artifact from an earlier draft of the test file that didn't survive. Sweep audit: UTC / datetime had no other use in the file (_BTCUSDT_FILTERS and the action factories are the only other module-level names and they don't need either)
  • Post-PR-review fix (PR #132 round-10 review by Copilot, 1 thread): move from praxis.core.domain.enums import OrderType from line 34 (mid-nexus.* block) to the praxis.* import section just after from praxis.command_translator import (...). Pre-fix the first-party import was inserted in the middle of the third-party nexus.* block, breaking the file's stdlib → third-party → first-party grouping. Sweep audit: only this one import was misplaced — all other praxis.* imports in this file are correctly in the first-party block at line 84+. No other PR-introduced imports cross the boundary
  • Post-PR-review fix (PR #132 round-11 review by Copilot, 1 thread): make test_below_min_qty_returns_none_with_intake_rejection_logged actually assert on the log line. Pre-fix the test claimed via its name that an intake-rejection WARNING was logged but only checked ctx is None; a regression that removed or silenced the warning would have passed. Test now wraps the call in caplog.at_level('WARNING', logger='praxis.launcher'), filters records for the exact rejection message, and asserts on the structured extras (strategy_id == 'strat-a', symbol == 'BTCUSDT', requested_size == '0.000001', reason contains INTAKE_BELOW_MIN_QTY, command_id is non-None and starts with cmd- or matches action.command_id). The command_id assertion also implicitly pins the round-8 minting fix — a regression that reverts to logging raw action.command_id (which defaults to None for synthesized actions) would now fail this test. Sweep audit: this is the only test in test_launcher_qty_snap.py whose name implies log-assertion semantics

v0.73.0 on 7th of June, 2026

NOTE

  • Quote-native MARKET BUY ships paired with Nexus v0.56.0 (companion PR Vaquum/Nexus#80, merged at commit 4530720887d). Replaces the v0.72.0 200-bps reservation buffer (order_notional = order_size * reference_price * Decimal('1.02')) with Binance's native quoteOrderQty parameter on MARKET BUY ENTERs. Strategy emits quote_qty=budget; venue computes the executed base qty from live liquidity; reservation matches spend exactly. Eliminates the kline-staleness slippage gap at the source instead of papering over it. Prod-observed evidence (v0.72.0 monkeypatch, Jun 2026): 1658 MARKET BUY ENTERs failed order_fill with fill_notional > remaining; bps-excess distribution p10=2.4 / p50=15.7 / p90=48.7 / p99=154 / max=170 over a 15-min stale reference window. WS-path terminal handling for quote-native is recorded as TD-079 against this PR and tracked as a follow-up

Add

  • Bump vaquum-nexus pin from ac0aadd6 (v0.55.0) to 4530720887d (PR #80 merge — quote-native MARKET BUY plumbing). Imports Action.quote_qty, TradeCommand.quote_qty, and the PraxisOutbound.send_command(quote_qty=...) conditional kwarg so Praxis's Trading.submit_command receives quote_qty= from Nexus on quote-native ENTERs
  • Add quote_qty: Decimal | None = None field to TradeCommand with is_quote_native property; __post_init__ requires exactly one of qty or quote_qty to be set; both positive-Decimal validated. The property is the canonical read site for any code path that needs to branch behavior on the order shape
  • Add quote_qty: Decimal | None = None field to Order; qty made Decimal | None; __post_init__ enforces the same XOR contract; remaining_qty returns None for quote-native (no base target known). _update_order_on_fill in trading_state.py stops at PARTIALLY_FILLED for quote-native (no implicit FILLED transition); the explicit OrderQuoteNativeFilled event flips it
  • Add quote_qty: Decimal | None = None field to OrderSubmitIntent with the same XOR enforcement; threaded through the spine so event_spine replay reconstructs TradeCommand.quote_qty correctly
  • Add OrderQuoteNativeFilled spine event to events.py and to the Event union; registered in event_spine._EVENT_REGISTRY. Carries only client_order_id + timestamp. TradingState._on_order_quote_native_filled flips the order's status to OrderStatus.FILLED and calls _close_order — the terminal signal for quote-native orders since filled_qty >= qty is undefined when qty is None
  • Add quote_qty: Decimal | None = None kwarg to the VenueAdapter.submit_order protocol and to BinanceAdapter.submit_order. When quote_qty is set, dispatches via a new _build_quote_native_market_params helper that sends Binance's quoteOrderQty parameter; rejects non-MARKET / non-BUY / dual-set combinations with ValueError (caught upstream by ExecutionManager._process_command and routed to _record_submit_failed)
  • Add quoteOrderQty support to binsim.server: the POST /api/v3/order endpoint accepts quoteOrderQty for MARKET BUY (mutually exclusive with quantity); enforces the BUY-only constraint to match Binance; rejects quoteOrderQty with non-positive Decimal. binsim.book.consume_quote_for_market_buy walks the ask ladder until the quote budget is exhausted (partial-takes the last level to land exactly on quote_qty)
  • Add TD-078 to docs/TechnicalDebt.md: estimate_slippage is observation-only; no execution guard rejects bad-fill MARKET orders. Deferred from the quote-native scope
  • Add TD-079 to docs/TechnicalDebt.md: quote-native terminal signal arrives only on the REST submit-response path; WS-driven fills set the order to PARTIALLY_FILLED and the WS reconcile path does not emit OrderQuoteNativeFilled. The current trading shape is REST-synchronous so this is latent; tracked as a follow-up before any LIMIT or post-only quote-native path lands

Update

  • Branch _build_enter_context on action.quote_qty: when set, bypasses the quantize_for_command step (LOT_SIZE snapping is venue-side for quote-native), uses action.quote_qty as order_notional directly, leaves order_size=None. The qty-native path keeps the v0.72.0 pre-snap (snapped_qty * reference_price) and drops the v0.72.0 200-bps multiplier (now order_notional = order_size * reference_price exact). _ensure_entry_position falls back to a Decimal('1') sentinel for entry_price when action.quote_qty is not None and no reference_price is available — the placeholder's entry_price is overwritten on the first fill via _grow_position's VWAP when old_size == 0
  • Make TradingState.mark_quote_native_filled (later replaced by the OrderQuoteNativeFilled event handler) gate the terminal flip on filled_qty > _ZERO. Closes the rescue zero-fill regression: when the rescue path returned status=FILLED with empty immediate_fills it had been emitting a zero-fill outcome that suppressed the later WS fills. Status-branch in ExecutionManager._process_command similarly requires result.status == FILLED AND filled_qty > _ZERO before emitting TradeStatus.FILLED
  • Catch adapter ValueError in ExecutionManager._process_command submit try-block and route to _record_submit_failed (rather than letting it propagate as an unhandled exception that parked capital)
  • Branch validate_trade_command._validate_venue_filters on cmd.is_quote_native: skip LOT_SIZE checks (venue applies them at fill time), validate cmd.quote_qty >= filters.min_notional instead. Adds _validate_quote_native_shape to reject quote_qty with non-BUY or non-MARKET at intake time
  • Branch ExecutionManager._process_command on cmd.is_quote_native: skip estimate_slippage (observation-only and based on base qty), skip the immediate-fills overfill clamp, skip the WS-driven emitted_filled_qty > cmd.qty clamp. Thread quote_qty=cmd.quote_qty to the OrderSubmitIntent and to submit_order. The replay path at line 369 also threads quote_qty=event.quote_qty when reconstructing TradeCommand from the spine
  • Make TradeOutcome.target_qty Decimal | None (quote-native has no base target). fill_ratio returns None when target_qty is None. OutcomeTranslator._build_partial and _build_terminal compute remaining_size = target_qty - filled_qty if target_qty is not None else None

Fix

  • Validator-pipeline rejection of quote_qty on non-BUY / non-MARKET shapes now fires at intake, before any reservation is taken — symmetric with Nexus's Action.__post_init__ guard
  • Quote-native terminal Order state is now persisted via the new OrderQuoteNativeFilled event; spine replay reconstructs the closed state instead of leaving the order stranded at PARTIALLY_FILLED
  • _ensure_entry_position no longer requires a reference_price for quote-native ENTERs (placeholder uses Decimal('1') sentinel; first fill overwrites). The strategy's _reference_price helper now sanitizes signal-derived Decimals to None on non-finite or non-positive, but that lives on the Nexus side (companion PR)

v0.74.0 on 8th of June, 2026

NOTE

  • OrderRejectedError no longer counts toward the venue HealthTracker's consecutive_failures / failure_rate. The venue signaling -2010 INSUFFICIENT_BALANCE / -1013 MIN_NOTIONAL / -1013 LOT_SIZE / -1100 ILLEGAL_PARAMETER (and any other business-rule rejection code) means the venue is healthy and refused the specific order's parameters or the account's current balance state. The HealthLoop should react to venue-availability problems (timeouts, 5xx, auth, rate limits), not to per-order business-rule outcomes. Same class of design defect as the NotFoundError-when-binsim exemption that shipped in #114; the class sweep then should have included OrderRejectedError too. Prod-observed motivation: a v0.73.0 deploy halted after two consecutive ENTERs with stale binsim ledger balance (-2010 from binsim) tripped the consecutive-failure threshold, flipped state.mode to HALTED, every subsequent ENTER got rejected with INTAKE_MODE_BLOCKS_ENTER, and no fresh signed successes could dilute the failure window — permanent halt despite later SELLs that would have refilled USDT had they been allowed to run.

Fix

  • Insert except OrderRejectedError: clause in BinanceAdapter._request_with_retry before the generic except VenueError handler. The new clause calls _record_health(account_id, start, succeeded=True) before re-raising — the venue responded successfully and applied its business rules correctly, so the round-trip is a positive health signal: the latency sample is real and _consecutive_failures resets, preventing a prior transient failure from persisting through a chain of business-rule rejections. AuthenticationError, RateLimitError, TransientError (including transport-layer wrap from aiohttp.ClientError / TimeoutError), NotFoundError on real venues (the existing #114 binsim gate is untouched), and OrderSubmitTimeoutError continue to be recorded as health failures. DuplicateClientOrderIdError is constructed downstream by submit_order when the underlying OrderRejectedError's venue_code matches _DUPLICATE_CLIENT_ORDER_ID_CODE (note: -2010 is overloaded in Binance for both INSUFFICIENT_BALANCE and DUPLICATE_CLIENT_ORDER_ID, so the prod path always sees the rejection upward as DuplicateClientOrderIdError); the record-as-success here applies regardless of how the caller classifies the raise. Replaces tests/test_binance_adapter.py::test_non_not_found_venue_error_still_records_with_binsim_url with four focused tests: test_order_rejected_error_records_as_success_and_resets_consecutive_failures (-2010 INSUFFICIENT_BALANCE — seeds a prior failure, asserts the rejection resets consecutive_failures to 0 and contributes a positive latency sample), test_min_notional_rejection_records_as_success_and_resets_consecutive_failures (-1013 MIN_NOTIONAL — same shape), test_authentication_error_still_records_health_failure (HTTP 401 — scope-pin proving the exemption is bounded to business-rule classes), and test_submit_order_with_client_order_id_records_success_on_2010 (end-to-end through submit_order with a client_order_id — asserts DuplicateClientOrderIdError is raised AND consecutive_failures resets, anchoring the prod-path claim that the underlying exemption fires regardless of the downstream wrap)

v0.75.0 on 9th of June, 2026

NOTE

  • Vaquum/Praxis#135: binsim Ledger._snapshot_locked serialized the full ledger — every account, the full fills history, the full seen_client_order_ids set — to JSON and wrote it synchronously on the asyncio event loop, inside the asyncio.Lock held across settlement, on every apply_order / apply_fill. Account.fills was unbounded so payload size grew linearly with cumulative order count; per-order latency was O(n) and cumulative cost O(n²). Measured: 50 k fills → 117 ms per write, 40× throughput collapse (315 → 7.8 ord/s), p99 latency 94 ms → 4.1 s, and event-loop jitter up to 4.3 s — past the 5 s BINSIM_STALENESS_MS default, so the depth poller starves and -1003 rejections cascade. At observed prod fill rates the 50 k threshold lands inside three days. This release reduces the field-of-attack at the source: fills[] is dropped from snapshot persistence (no production reader — binsim.server._my_trades_stub returns []), and the remaining snapshot write moves off the event loop via asyncio.to_thread. Residual growth not addressed by this PR: Account.seen_client_order_ids is still persisted via _account_to_dict (called inside _snapshot_locked on the event loop, including a sorted(...) on the full set per snapshot), so the snapshot payload still grows linearly with cumulative order count via that field — and the sorted call remains on the loop above the to_thread boundary. The apply_order hot path adds one entry to the set per order; apply_fill does not. Dominated-term-only mitigation, not full constant-sizing. The in-memory Account.fills list and Account.seen_client_order_ids set also remain unbounded; recorded against the same module as TD-081 so the next bound pass closes both the persistence and on-loop-sort components.

Update

  • Drop fills from _account_to_dict and stop persisting it. Ledger.fills(account_id) still returns the in-memory list for tests and any future in-process consumer; the data is now process-lifetime rather than restart-durable. binsim.server._my_trades_stub already returns [] so no production endpoint observed the persisted fills — the change is invisible to clients. _account_from_dict tolerates legacy snapshots that still carry fills (silently ignored) and initializes Account.fills=[] on every load
  • Convert Ledger._snapshot_locked to async and route the disk I/O through await asyncio.to_thread(self._write_snapshot_atomic, payload). The lock stays held across the await (so concurrent mutations remain serialised) but the event loop is freed for the depth poller and other request handlers during the write. Updates the three call sites in register_account, apply_fill, and apply_order to await self._snapshot_locked(). The atomic write itself (mkstemp → write_text → replace) lives in a new sync helper _write_snapshot_atomic so the asyncio.to_thread boundary is a single function call. Removes now-dead _fill_to_dict / _fill_from_dict helpers
  • Update tests/test_binsim_ledger.py: rename test_load_restores_balances_and_fills → test_load_restores_balances_and_counters (asserts balances + next_trade_id survive load, fills does not). Rename test_ledger_fill_record_round_trips_through_snapshot → test_fills_do_not_survive_snapshot_round_trip (asserts the persisted shape no longer carries fills). test_snapshot_written_after_register_and_fill swaps len(payload[...]['fills']) == 1 for 'fills' not in payload[...]. Adds four regression tests: test_snapshot_size_stays_bounded_under_fill_growth_only (after 100 apply_fill calls the snapshot file is within 256 B of the empty baseline — the fills-term pathology), test_apply_order_still_grows_snapshot_via_seen_client_order_ids (after 100 apply_order calls with distinct client_order_ids the snapshot DID grow past a floor — documents the residual growth as fact, not a regression, so a future reader doesn't read the bounded-under-fill test as proving the whole snapshot is bounded), test_legacy_snapshot_with_fills_field_loads_balances (a snapshot from before this PR still loads, balances restore, the persisted-fills field is silently dropped on the next snapshot write), and test_snapshot_write_completes_when_caller_cancelled (instruments _write_snapshot_atomic with a synthetic delay, cancels the apply_fill task mid-write, asserts the in-flight write completes before the lock is released — covers the cancellation race the asyncio.shield + finally pattern in _snapshot_locked exists to prevent)

Fix

  • Closes Vaquum/Praxis#135. Bounds the per-order snapshot cost to a constant (proportional to account count, not cumulative fill count) and unblocks the event loop during the write — the two conditions Mikko's measurements identified as the cause of the 40× throughput collapse and the depth-poller-staleness cascade

v0.76.0 on 9th of June, 2026

NOTE

  • Vaquum/Praxis#142: in prod (epoch=16, v0.75.0, ~3h post-deploy on 2026-06-09) 1,325 trades were stuck in an infinite EXIT-retry loop, each emitting an INTAKE_BELOW_MIN_QTY rejection at praxis/launcher.py:_build_exit_context every 15–30 min. Two blocker paths flow through the same function — post-fill sub-lot residue (B1, fixed Nexus-side in Vaquum/Nexus#82 at OutcomeProcessor._reduce_position) and pre-submit sub-lot rejection (B2, fixed here in _build_exit_context's rejection branch). The Nexus companion (v0.57.0) introduced intended_full_close on both ValidationRequestContext and OrderContext, plus OutcomeProcessor.close_as_dust(trade_id, reason, dust_close_id) + a durable InstanceState.account_dust: dict[str, Decimal] ledger. This Praxis release computes the intent flag at the launcher boundary, threads it through both context classes (required because _build_order_context re-runs build_context rather than passing the original through), and calls close_as_dust when intake-time venue quantization rejects a full-close EXIT as sub-lot. After Praxis v0.76.0 + Nexus v0.57.0 land together, the cycle Mikko measured at the 1,325-stuck-trades threshold is closed at both entry points.

Update

  • Bump vaquum-nexus git-pin to 7ce0260 (Nexus v0.57.0). The new pin makes ValidationRequestContext.intended_full_close, OrderContext.intended_full_close, InstanceState.account_dust, and OutcomeProcessor.close_as_dust reachable from Praxis. The pin update is paired with the launcher changes below — earlier Praxis revisions cannot reference close_as_dust because Nexus v0.56.0 doesn't expose it
  • Update praxis/launcher.py:_build_exit_context to compute remaining = position.size - position.pending_exit and intended_full_close = action.size == remaining (exact Decimal equality), then set intended_full_close on the returned ValidationRequestContext. The command_id derivation moves above the quantization step so a stable command id is in scope across the rejection branch's extra dict and downstream
  • Update praxis/launcher.py:_build_exit_context's rejection branch (previously return None after logging 'EXIT action rejected by venue filters at intake; skipping'): when intended_full_close=True AND the caller supplied an outcome_processor, call OutcomeProcessor.close_as_dust(trade_id=trade_id, reason=quantization.rejection_reason, dust_close_id=f'dust-{trade_id}') before returning. The dedup key is trade_id-derived (not command_id-derived) so it stays deterministic even when action.command_id is None and the launcher generates a fresh per-call UUID — a position can only become dust once per epoch, so trade_id is the natural key for that invariant. Partial-close rejections still drop silently — the close_as_dust path only fires for full-position EXIT intent. The rejection log now includes intended_full_close AND command_id so the operator can correlate the rejection with a specific strategy action at a glance
  • Update praxis/launcher.py:_build_order_context at the OrderContext construction site to copy validation_context.intended_full_close onto OrderContext.intended_full_close. Required because _build_order_context re-runs build_context(action, strategy_id) rather than passing the original ValidationRequestContext through, so a field only on OrderContext would be lost across the rebuild
  • Update praxis/launcher.py:_build_validation_context signature to accept an optional outcome_processor: OutcomeProcessor | None = None kwarg and thread it into _build_exit_context. The caller in the runtime build_context closure (where outcome_processor is in scope after construction) passes the live instance through

Add

  • Add tests/test_launcher_validation_context.py::TestExitContextIntendedFullCloseFlag (3 cases): intended_full_close=True when action.size == position.size - position.pending_exit (the prod hot path with pending_exit=0); same True result when pending_exit > 0 and action.size == remaining; False on a deliberate partial-exit
  • Add tests/test_launcher_validation_context.py::TestExitContextDustCloseRouting (4 cases): full-close EXIT rejected by venue quantization routes to OutcomeProcessor.close_as_dust with dust_close_id=f'dust-{trade_id}' and the venue's rejection_reason; partial-close rejection does NOT route to close_as_dust (the close-as-dust path is gated on intended_full_close=True); full-close rejection without an outcome_processor falls back to the legacy return None behavior so test callers that don't pass one still work; two _build_validation_context calls with command_id=None on the same trade produce identical dust_close_id values so the Nexus-side _processed_dust_close_ids dedup catches the second one
  • Add tests/test_launcher_validation_context.py::TestOrderContextCarriesIntendedFullClose (2 cases) — regression for the field-only-on-OrderContext bug codex flagged in the Nexus audit. Constructs a _build_order_context call with a build_context_for_test closure that re-runs _build_validation_context, verifies the flag survives the rebuild for both full-close and partial-exit shapes
  • Uses minimal _FakeVenueAdapterRejecting (returns a rejecting CommandQuantization) and _RecordingOutcomeProcessor (captures close_as_dust calls into a list) stubs in the same test file rather than mocking BinanceAdapter — keeps the test scope tight to the launcher decision logic

Fix

  • Closes Vaquum/Praxis#142. Companion Nexus-side fix at Vaquum/Nexus#82 (shipped as Nexus v0.57.0, merged at commit 7ce0260). The two PRs are paired: Praxis alone cannot reach close_as_dust because Nexus must define it first; the matching Nexus changes (intended_full_close on both context classes, account_dust ledger on InstanceState with WAL/snapshot codec roundtrip, the close_as_dust method itself) shipped earlier today

v0.77.0 on 10th of June, 2026

NOTE

  • During the v0.76.0 paper-trade validation (2026-06-10), positions were not closing: 175 of 190 SELL EXITs in one epoch left state.positions entries at full pre-fill size with pending_exit still set, and the new close_as_dust path then read that stale state and moved full positions (~0.0325 BTC each) into account_dust — 8.75 BTC of phantom dust in one epoch. Root cause: Nexus position/capital accounting is applied by the OutcomeLoop's single worker, which serializes it with strategy callbacks and action submission; under load, translated FILLED outcomes lag behind strategy ticks, so strategies and the dust path act on stale state.positions. This release applies accounting synchronously at the Praxis outcome boundary and gates the dust-close on no-EXIT-in-flight, closing both halves

Update

  • Bump vaquum-nexus git-pin to Nexus v0.58.0, which makes OutcomeProcessor._handle_ack context-aware: EXIT ACKs are a no-op success instead of the structural order_ack failed: order not found failure (EXIT commands never reserve capital, so no TrackedOrder exists for them)
  • Update vaquum_limen git-pin from the v4.0.1 tag to the commit it resolved to (06815fab) — the tag no longer exists on the Limen remote and its absence breaks dependency install in CI. Installed content is identical; only the reference form changes
  • Update praxis/launcher.py:_build_exit_context's dust-close branch with a position.pending_exit == _ZERO gate: when a prior EXIT order is in flight, the rejection no longer dusts the position — the in-flight fill will reduce position.size when it lands and the strategy's next tick re-evaluates against the true residue. Dusting with an EXIT in flight moved the not-yet-sold quantity into account_dust
  • Update praxis/launcher.py:_route_translated to apply the Nexus in-memory mutation synchronously before enqueuing each translated outcome for the async OutcomeLoop, via the new Launcher._apply_sync_accounting. Persistence stays off the Trading event loop: mutated command ids are generation-stamped into unpersisted_commands and the async process_outcome — on the OutcomeLoop worker thread — performs the append_mutation on the dedup-hit redelivery, withholds OutcomeAcked until it succeeds, and discards an id only when its generation still equals the pre-append snapshot's (so a command re-mutated during the serialize stays pending), preserving the boot-replay durability contract. The stale-positions race is closed by the synchronous state mutation, not by synchronous persistence

Add

  • Add _AccountOutcomeWiring dataclass (non-frozen, matching _NexusRuntime — it carries mutable members by reference): per-account references (outcome_processor, command_contexts, command_registry_lock, unpersisted_commands) registered by _build_nexus_runtime and consumed by _route_translated for the synchronous accounting path
  • Add Launcher._apply_sync_accounting static method: looks up the outcome's OrderContext under the registry lock (skips when not yet registered — the async path covers those once the submitter completes registration), calls OutcomeProcessor.process, records mutated command ids in unpersisted_commands for the async consumer's persist, and contains all failures so accounting errors never block strategy-callback delivery
  • Add tests/test_launcher_sync_accounting.py (6 cases): position mutation marks the command unpersisted; capital mutation marks the command unpersisted; skip on missing OrderContext; failure result does not mark; success without mutation does not mark; processor exception contained
  • Add test_full_close_rejection_with_pending_exit_does_not_route_to_close_as_dust to tests/test_launcher_validation_context.py: a sub-lot full-close rejection with pending_exit > 0 must NOT call close_as_dust

v0.78.0 on 11th of June, 2026

NOTE

  • Companion to Nexus v0.59.0's unresolved-outcome retry: the registration-gap race (translated outcomes reaching the accounting paths ~1ms before the submitter's post-send_command registration loop made command_strategy_ids / command_contexts visible) surfaced in epoch 24 as two venue-filled EXITs whose accounting never ran. The Nexus side now retries; this release makes the Praxis-side skip observable

Update

  • Bump vaquum-nexus git-pin to Nexus v0.59.0 (OutcomeLoop retries unresolved-strategy outcomes on a backoff schedule instead of dropping them)
  • Update Launcher._apply_sync_accounting: the missing-OrderContext skip is no longer silent — it logs a warning with account_id, command_id, outcome_id, outcome_type, and has_strategy_mapping (whether the strategy registry already contains the command, checked in the same lock hold as the context lookup), distinguishing the pre-registration race from a genuinely unknown command

Add

  • Add account_id and command_strategy_ids to _AccountOutcomeWiring — telemetry-only references for the skip warning, registered alongside the existing wiring fields

v0.79.0 on 12th of June, 2026

Add

  • Add optional command_id: str | None = None to ExecutionManager.submit_command: a caller-supplied identifier is used verbatim (treated as an opaque non-empty string; an identifier already in use by any accepted or in-memory command fails inbound validation rather than being regenerated, and the identity is reserved before the spine append's await so concurrent same-id submissions cannot interleave), and a UUID is minted exactly as before when omitted. This lets the caller know the command's identity before the handoff and register it in its own state pre-submit — the enabling half of the cross-repo fix for the registration-gap race (#146; companion Nexus changes track Vaquum/Nexus#86 and Vaquum/Nexus#87)
  • Add validate_command_id_for_client_order_id and enforce it in submit_command: a caller-supplied command_id must have at least 16 characters after stripping hyphens (the generate_client_order_id derivation floor), so a too-short id is rejected at the inbound boundary before a CommandAccepted is persisted rather than failing later at submission. generate_client_order_id now delegates its inline length check to the same validator
  • Add tests to tests/test_execution_manager.py::TestSubmitCommand: caller-supplied id used verbatim and registered; empty id rejected; too-short id rejected before any CommandAccepted reaches the spine; in-use id rejected; concurrent same-id submissions — exactly one wins and exactly one CommandAccepted reaches the spine; a failed/cancelled spine append frees the reservation for reuse

Update

  • Update praxis/launcher.py:_build_exit_context: the venue-filter intake rejection logs at info when intended_full_close is set — that rejection IS the designed dust-close trigger (v0.76.0) and was producing 1,000+ warning lines per trading cycle for nominal behavior. Rejections of partial-close EXITs keep the warning level (#147)
  • Add test_full_close_rejection_logs_info_partial_logs_warning to tests/test_launcher_validation_context.py pinning the level split

v0.80.0 on 13th of June, 2026

NOTE

  • Closes the registration-gap race at its root rather than after the fact. Earlier releases (v0.78.0) made the race observable and (Nexus v0.59.0) retried the outcomes it dropped; this release removes the gap. The launcher now registers a command's strategy mapping, capital order, position effect, and OrderContext BEFORE the send_command handoff — using the caller-supplied identity from v0.79.0 — so a fast venue's ACK/FILL resolves against state that already exists and the post-handoff registration loop is gone. Paired with Nexus v0.60.0 (Vaquum/Nexus#86, #87, #88), which transmits the deterministic command id, treats a send_command timeout as SUBMISSION_UNKNOWN (retain the reservation+registration; the command may still execute) instead of releasing capital, and serializes the WAL/snapshot codec. This release also wires the StateSnapshotLocks snapshot-lock ownership move (Nexus v0.61.0 deleted the external checkpoint wraps; v0.62.0 added StateStore.attach_snapshot_locks, Vaquum/Nexus#92): the launcher now attaches the bundle to its StateStore after recovery, so the store owns the positions_lock + capital_lock serialization and the launcher drops its external append_mutation / scheduler / shutdown wraps

Update

  • Bump vaquum-nexus git-pin to Nexus v0.62.0 (b59a4e7): submit_actions accepts a pre_register callback invoked before the send_command handoff and returns a SubmissionRegistration handle (mark_submitted / mark_unknown / rollback); a handoff timeout resolves to SUBMISSION_UNKNOWN rather than SUBMIT_FAILED; PraxisOutbound exposes supports_command_id; StateStore owns the snapshot-serialization locks (ShutdownSequencer / SnapshotScheduler no longer wrap checkpoint(), so their lock parameters are gone) and exposes attach_snapshot_locks for post-recovery wiring
  • Update praxis/launcher.py action-submission path to register before handoff: the build_context builder is wrapped to record each command's (action, strategy_id, OrderContext) by command_id (ids are assigned inside build_context, so the recording happens as they are minted), and submit_actions is called with that recording builder plus a pre_register callback (only when praxis_outbound.supports_command_id). The legacy post-send_command registration loop is skipped on the pre-registration path
  • Update praxis/launcher.py:_build_nexus_runtime to attach the snapshot-lock bundle to its StateStore immediately after recovery (once state / positions_lock / capital_controller exist and state.risk.lock is wired to positions_lock), via state_store.attach_snapshot_locks(_build_state_snapshot_locks(...)), before any runtime consumer starts. The store now acquires positions_lock + capital_lock internally around serialize_state, so the external with positions_lock: wrap around the async append_mutation is dropped (it would re-acquire the non-reentrant lock and self-deadlock), and SnapshotScheduler / ShutdownSequencer are constructed without the now-removed lock parameters

Add

  • Add _PreRegisteredSubmission and the module-level _make_pre_register factory: pre_register inserts the strategy mapping, consumes the capital reservation into an order (send_order, raising on failure so the command is not handed off), applies the position effect (ENTER places a zero-size placeholder via _ensure_entry_position; EXIT increments pending_exit), and builds + registers the OrderContext from the validator's already-captured context — all before send_command. The OrderContext is built from the captured context rather than by re-running build_context, because the EXIT path has just incremented pending_exit and a re-run would recompute intended_full_close (action.size == size − pending_exit) against the inflated value, flipping a true full-close to not-full-close and breaking the dust-close path. The returned handle records exactly what it inserted so rollback is precise and idempotent, and mark_unknown retains every registration (a late outcome must resolve against it). The post-send_order body (position effect + context build + insert) runs under a try that, on any exception, undoes the position effect, recovers the orphaned capital order, and pops the registries before re-raising — so a raise after the reservation is consumed cannot leak the capital order plus strategy mapping (Nexus's _release_granted_reservation is a no-op for an already-consumed reservation)
  • Add _UnknownSubmission frozen record (command_id, strategy_id, created_at, action_type, symbol, side, order_notional, error): mark_unknown stamps one with datetime.now(UTC) when a handoff times out, retaining the registration. process_outcome pops the record on the first successfully-processed outcome for that command (including an EXIT ACK no-op success) and defensively on terminal cleanup; a failed-processing outcome leaves it unknown
  • Add _UnknownSubmissionMonitor: a threading.Timer scan loop (mirroring SnapshotScheduler) that warns about commands stuck in SUBMISSION_UNKNOWN past a threshold, logging count, max_age_seconds, and a bounded command_ids list. Telemetry only — no venue query, no forced release. Intervals via NEXUS_UNKNOWN_SUBMISSION_WARN_SECONDS (default 60) and NEXUS_UNKNOWN_SUBMISSION_SCAN_SECONDS (default 15); started in _build_nexus_runtime, stopped on shutdown
  • Add _build_state_snapshot_locks: the composition-point helper that builds the StateSnapshotLocks bundle and asserts state.risk.lock is positions_lock (so the bundle's positions_lock covers state.risk.per_strategy serialization). This is the single enforcement point for that identity now that the Nexus-side construction guards are gone
  • Add tests/test_launcher_pre_registration.py (12 cases): ENTER registers before handoff; send_order failure raises and leaves no registration; a post-send_order exception (a non-positive entry price) recovers the capital order and pops the registries; the registered EXIT OrderContext carries the captured intended_full_close even after pending_exit is incremented; ENTER rollback removes the placeholder; EXIT rollback decrements pending_exit; mark_unknown retains the registration and records the metadata; registries are populated when send_command is entered (cross-module, real submit_actions); the monitor is silent below threshold and warns above with count / max_age_seconds / command_ids; stop cancels a pending scan; and an AST check that process_outcome pops the unknown only on the success branch
  • Document NEXUS_UNKNOWN_SUBMISSION_WARN_SECONDS / NEXUS_UNKNOWN_SUBMISSION_SCAN_SECONDS in docs/Launcher.md's Optional-environment table
  • Add tests/test_launcher_snapshot_lock_wiring.py (5 cases): _build_state_snapshot_locks returns the shared positions_lock + capital_controller.lock_cm(); it raises when state.risk.lock is not positions_lock; and AST checks that _build_nexus_runtime builds the bundle via the helper and calls attach_snapshot_locks before both outcome_loop.start() (the append_mutation path) and snapshot_scheduler.start() (the checkpoint path) — the attach-before-consumers ordering

v0.80.1 on 14th of June, 2026

NOTE

  • Completes the deterministic-command-id passthrough that v0.79.0 / v0.80.0 left half-wired. Those releases taught the bottom layer (ExecutionManager.submit_command) to accept and honour a caller-supplied command_id, but the two intermediary submission seams between the launcher and the execution layer — Trading.submit_command and TradingInbound.submit_command — did not declare the parameter, so the deterministic id transmitted by Nexus reached a signature that rejected it and every submission raised TypeError: submit_command() got an unexpected keyword argument 'command_id'. The existing tests mocked submission at the PraxisOutbound boundary and never drove the real Trading → TradingInbound → ExecutionManager chain, so the gap was invisible to the suite. No capital leaked: each failed submission was rolled back cleanly by the pre-registration handle, but no order could be placed

Fix

  • Update praxis/trading.py:submit_command and praxis/trading_inbound.py:submit_command (both the TradingInbound implementation and its _ExecutionInboundGateway Protocol) to declare command_id: str | None = None and forward it to the next layer, so a Nexus-supplied deterministic id flows launcher → Trading → TradingInbound → ExecutionManager intact
  • Update praxis/launcher.py:submit_command_with_translated_params to accept command_id as an explicit keyword parameter (rather than only through **kwargs) and forward it to trading.submit_command, so PraxisOutbound feature-detection classifies the id as authoritative instead of best-effort

Add

  • Add TestSubmitCommandRealChain to tests/test_execution_manager.py: drives a caller-supplied command_id through the real TradingInbound → ExecutionManager chain and asserts the returned id and the emitted CommandAccepted.command_id both equal the supplied id (no TypeError), plus a boundary case asserting a too-short id is rejected before any CommandAccepted is appended
  • Add test_submit_command_forwards_caller_supplied_command_id to tests/test_trading_inbound.py pinning that TradingInbound forwards and returns a supplied command_id; update _FakeExecutionManager.submit_command to mirror the real command_id parameter so the test double can no longer drift ahead of the production signature
  • Update the submit_command fake in tests/test_launcher_execution_params_shim.py to echo the supplied command_id instead of returning a fixed id: now that the launcher wrapper declares command_id explicitly, PraxisOutbound classifies the id as authoritative and rejects a returned id that diverges from the transmitted one, so the double must honour the identity contract the real execution layer upholds

v0.81.0 on 15th of June, 2026

BREAKING

  • Cut the price/market-data path over to the Furnace Conduit data plane and drop the in-process market-data cache. The launcher no longer fetches or aggregates bars from Binance: predictions are consumed from the furnace_conduit volume (/opt/conduit) and ENTER / mark-to-market prices from the control-plane Arrow volume (/opt/arrow) via ArrowPriceStore. The deployment must mount both volumes read-only on the praxis service. Pairs with Nexus v0.63.0 (the Conduit signal API): PredictLoop is constructed with signal_bindings + conduit_dir / arrow_dir (no market_data_provider), and the strategy manifest's per-strategy block is now signal: {series, interval_seconds, ...} (was sensors: [...])

NOTE

  • Mark-price / fallback pricing resolves a single (series, interval_seconds) pair against the manifest via _resolve_mark_price_series: the lone manifest series by default, or PRAXIS_MARK_PRICE_SERIES (plus PRAXIS_MARK_PRICE_INTERVAL_SECONDS when the chosen series is not declared by any strategy) to disambiguate; it raises loudly on an ambiguous (multiple) or empty series set. Conduit / Arrow roots are overridable via PRAXIS_CONDUIT_DIR / PRAXIS_ARROW_DIR

Add

  • Add praxis/arrow_price_store.py ArrowPriceStore: a stateless reader of /opt/arrow/<series>/latest.arrow returning the latest closed bar's close (ts + interval_seconds <= now, excluding the still-forming bar) as a Decimal; None on an absent frame, no closed bar, or a non-finite close. Backs fallback_price_provider (ENTER reference price) and the MtmLoop mark-price provider
  • Add _resolve_mark_price_series and tests/test_resolve_mark_price_series.py (5 cases): single manifest series by default; PRAXIS_MARK_PRICE_SERIES override matching a manifest series; an off-manifest series with PRAXIS_MARK_PRICE_INTERVAL_SECONDS; and RuntimeErrors on the multiple-series-unset and unknown-series-missing-interval paths

Update

  • Bump vaquum-nexus pin to v0.63.0 (742d851): StartupSequencer exposes signal_bindings, and PredictLoop(signal_bindings, conduit_dir, arrow_dir) polls Conduit instead of running in-process Limen inference

Remove

  • Remove praxis/market_data_cache.py (MainCache / CacheScheduler) and praxis/market_data_poller.py (MarketDataPoller), the launcher's _start_poller bootstrap, _register_wired_kline_sizes, and _last_close_from_poller; and the vaquum_limen, binancial, and pandas dependencies (pandas was used only by the removed market-data modules)

v0.82.0 on 16th of June, 2026

Add

  • Add TestLauncherFeeRateWiring to tests/test_launcher.py asserting the launcher wires the outcome translator with _DEFAULT_FEE_RATE (and that the rate is positive)
  • Add TD-095 to docs/TechnicalDebt.md: the outcome translator re-derives actual_fees from the constant _DEFAULT_FEE_RATE rather than the venue-reported FillReceived.fee — exact for binsim's flat 10 bps, an approximation on a venue with a maker/taker split or fee discounts

Fix

  • Construct OutcomeTranslator with fee_rate=_DEFAULT_FEE_RATE in the launcher instead of the zero-fee default: settled-fill actual_fees forwarded to Nexus now match the venue charge and the reservation-time fee estimate (both already use _DEFAULT_FEE_RATE = 0.10%), so realized PnL and capital release account for fees instead of treating trading as fee-free. The previous zero default was a testnet-era assumption that no longer holds against a fee-charging venue. Resolves TD-030; with actual_fees non-zero, Nexus's existing realized_pnl = gross_pnl - actual_fees (TD-051) takes effect

Remove

  • Prune the technical-debt register in docs/TechnicalDebt.md: collapse code-verified-resolved (TD-009, TD-020, TD-030, TD-045) and Conduit-obsoleted (TD-019, TD-060, TD-061, TD-062) entries to heading-only status markers, and reframe TD-053 around the Conduit/Arrow feed-staleness path that replaced MarketDataPoller

v0.83.0 on 16th of June, 2026

Add

  • Add TestTradeClosedPositionSemantics to tests/test_execution_manager.py: an entry fill keeps the position and emits no TradeClosed; a reducing fill that closes the position emits TradeClosed and clears it. Update test_full_cycle_submit_fill_outcome_shutdown to assert the entry position survives a FILLED outcome (was asserting deletion)
  • Add TD-096 to docs/TechnicalDebt.md recording that close-detection is side-based, not full-close-aware (partial-exit refinement for future scale-out strategies)

Fix

  • Emit TradeClosed only when a fill closes the position, not on every terminal filled order. _build_outcome and _build_abort_outcome now gate TradeClosed on _closes_position (a reducing fill — side opposite the open position), so an entry fill no longer emits it. Previously an entry's TradeClosed deleted its own position on event replay, so a process restart rebuilt zero open positions and boot reconciliation evicted the live position (orphaning the venue holding). Entry positions now survive a restart, which the Nexus boot reconciliation depends on

Update

  • Bump the vaquum-nexus pin to v0.64.0 (5c63468), which keys boot reconciliation on pos.trade_id and preserves + fails closed on a Nexus-only position instead of silently evicting it. The two changes are coupled: this PR keeps Praxis from under-reporting open positions on replay, and the Nexus pin keeps reconciliation from deleting them

v0.83.1 on 16th of June, 2026

Update

  • Bump the vaquum-nexus pin to v0.65.0 (f0dec50): snaps sub-ULP Decimal residues in the capital aggregates to zero so a restart cannot brick recovery on a persisted -1E-27 working_order_notional. Required alongside the fee-aware settlement (v0.82.0), which made the residue non-zero; full suite passes against the upgraded pin

v0.84.0 on 18th of June, 2026

Add

  • Add test_boot_sweep_cancels_orphan_and_marks_account_ready, test_boot_sweep_cancel_failure_leaves_account_not_ready, test_boot_sweep_cancels_orphan_oco_via_cancel_order_list, test_boot_sweep_query_failure_leaves_account_not_ready, test_boot_sweep_no_open_orders_marks_account_ready, and test_boot_sweep_keeps_locally_known_open_order to tests/test_trading.py: a _SweepVenueAdapter surfaces venue open orders so start() exercises the boot sweep — an orphan is cancelled and the account becomes ready, an OCO-leg orphan is cancelled via cancel_order_list, a cancel failure and a query failure each leave the account not-ready, an empty open-order list and a locally-known open order both leave the account ready with no cancel

Fix

  • Sweep venue open orders at boot and cancel any order with no local record. _startup_account now calls _sweep_orphan_venue_orders for each managed symbol (active_symbols(account_id) ∪ bootstrap_filter_symbols): it queries query_open_orders and cancels any venue order whose client_order_id is absent from trading_state.orders / closed_orders, logging a high-severity orphan event and never adopting it (Praxis cannot reconstruct the command_id / trade_id / Nexus capital lineage from a venue order alone). The sweep runs after event replay populates the local record but before the venue user stream opens, so an orphan is cancelled before the stream could deliver — and _on_execution_report silently drop as unknown — its fill report. An OCO-leg orphan is cancelled via cancel_order_list (the venue rejects single-leg OCO cancellation), mirroring stop. The account is marked ready only when every orphan cancels; a cancel failure or a sweep query error that cannot confirm orphans leaves the account not-ready so it never trades alongside a live untracked venue order. Closes the gap where an open venue order whose OrderSubmitIntent never reached the spine (process kill between venue ACK and append) was invisible at restart. Narrows TD-042 to the mainnet/shared-account hardening that remains

v0.85.0 on 20th of June, 2026

Add

  • Add boot replay-from-spine for unacked outcomes (TD-052). At startup, before the Nexus loops, _plan_outcome_replay reads the spine, groups recorded delivery contexts / TradeOutcomeProduced / OutcomeAcked per account, rebuilds each command's OrderContext and Praxis TradeOutcome from their durable records, re-runs a fresh OutcomeTranslator per command to derive the deterministic Nexus outcome_ids, and re-routes any leg with no matching OutcomeAcked through the shared _process_nexus_outcome path. An outcome lost to a process kill between the spine append and the Nexus callback is now applied on restart; Nexus's durable dedup (vaquum-nexus 0.66.0) makes a re-delivered but already-applied leg a no-op, so replay is at-least-once delivery, not a second mutation
  • Add the OutcomeDeliveryContextRecorded spine event (praxis/core/domain/events.py) carrying the Nexus delivery OrderContext, appended in pre_register before the send_command handoff so the boot replay can rebuild the context after a restart (the in-memory command_contexts map does not survive one); the append raises on failure so the submission aborts rather than becoming un-replayable
  • Add the OutcomeReplayAbandoned spine event: when a boot-replayed leg fails irrecoverably (e.g. an entry fill whose CapitalController order was cleared by reconcile_at_boot, so order_fill returns order not found), the launcher records it so _plan_outcome_replay skips the leg on later boots instead of re-failing every restart (the underlying venue/Nexus divergence is owned by the boot capital reconcile)
  • Add filled_qty / cumulative_notional / target_qty to TradeOutcomeProduced (defaulted for back-compat) so the boot replay can reconstruct the Praxis outcome, and derive each translated leg's outcome_id deterministically as {account_id}:{command_id}:{leg}[:{idx}] instead of a random uuid
  • Add cached_filters(symbol) to the VenueAdapter protocol (implemented by BinanceAdapter over its loaded filter cache) for the dust threshold used by qty-aware close detection
  • Add tests/test_launcher_outcome_replay.py (reconstruction round-trips, reconstructed-equals-live ids, replay planning: fully-unacked replays, fully-acked skips, partial-ack replays only the missing leg, no-context skips, other-account ignored) and qty-aware close tests in tests/test_execution_manager.py (partial reducing fill emits no TradeClosed, sub-lot residue does)

Fix

  • Emit TradeClosed only when a reducing terminal fill leaves the post-fill position quantity at or below the symbol's LOT_SIZE.lot_step (dust), not on any reducing fill (TD-096). A genuine partial exit that leaves a tradeable remainder no longer closes the position projection early on replay; a full-close exit that lot-rounds to a sub-step residue still closes. Falls back to the prior side-only behaviour when the symbol's filters are not cached

Update

  • Bump the vaquum-nexus pin to v0.66.0 (689f5be), whose durable outcome dedup (processed_outcome_ids on InstanceState) is the paired-boundary requirement for the TD-052 boot replay: re-delivery is safe only because Nexus recognises an already-applied outcome_id and no-ops it. Full suite passes against the upgraded pin
  • Mark TD-052 and TD-096 RESOLVED in docs/TechnicalDebt.md (collapsed to heading-only tombstones), and record TD-097 (boot replay runs after the venue stream opens, not before), TD-098 (delivery-context recording is best-effort on the consumer-registration path), and TD-099 (replay cannot re-apply a never-applied entry fill whose capital order was cleared at boot) for the TD-052 deferrals

v0.86.0 on 22nd of June, 2026

Add

  • Add a deterministic replay engine that drives the live trading pipeline over historical bars at simulated time (praxis/replay/). run_replay boots an isolated Launcher (throwaway event spine, ReplayVenueAdapter, ReplayClock) with the real per-account wiring built but its realtime loops unstarted, then walks a scenario's settle-ordered bars — materialising the Conduit/OHLCV frames, advancing the clock to each bar's settle, running PredictLoop.tick_once, and settling the bar deterministically (ExecutionManager.quiesce + OutcomeLoop.tick_once) — and returns a results summary (fill counts and quantities from the spine, net realized PnL from the run's Nexus risk state). The same scenario yields the same fills and PnL
  • Add ReplayVenueAdapter: a VenueAdapter that fills market orders synchronously at the current bar's close and returns them via SubmitResult.immediate_fills (the live fill path; no network, no stream, no resting orders). Fees mirror the binsim paper venue (taker fraction of notional, debited in the quote asset) so a replay and a paper run book identical costs
  • Add ReplayClock, a monotonic cursor-driven UTC clock injected wherever live code reads the wall clock and advanced per bar settle
  • Add materialize_bar_frames (writes the per-bar OHLCV / prediction frames and serving manifest a replay step exposes to PredictLoop) and load_replay_bars (slices a [start, end] window out of the mounted prediction and OHLCV frames into ReplayBars, for both time and dollar families)
  • Add a loopback-only HTTP surface (build_replay_app): POST /replay schedules a run off the aiohttp loop and returns a run_id, GET /replay/{run_id} reports status then the result summary. A middleware rejects non-local peers because a request carries a strategy module the run executes
  • Add an injectable clock seam across ExecutionManager, Trading, the Launcher, and the validation intake hooks (wall-clock default, so the live path is unchanged) so a replay drives every event timestamp, staleness gate, reservation expiry, and signal-freshness check on simulated time
  • Add ExecutionManager.quiesce (awaits the per-account command queue's join, the loop now calling task_done after each command) so a replay settles a bar's submissions, fills, and outcomes deterministically before advancing the clock
  • Add the praxis/replay/ test suite (clock, adapter, materializer, loader, quiesce, run_replay end-to-end including dollar bars, and the loopback API)

Fix

  • Gate closed-bar selection in ArrowPriceStore on a per-family settle: dollar bars (carrying a start_ts open column) are closed once ts <= now since their ts is the settle, while time bars keep ts + interval_seconds <= now. The time-bar formula was previously applied to every family, gating dollar bars a full interval late and mis-scaling the staleness window — latent while the prod mark series is time_15m, surfaced the moment a dollar series drives pricing or replay

Update

  • Bump the vaquum-nexus pin to v0.67.0 (03620eb), whose injectable CapitalController clock the replay run drives on simulated time
  • Split the Launcher's per-account assembly: _build_nexus_runtime now builds the runtime without starting the realtime loops, and a new _start_nexus_loops starts them (the live path builds then starts, unchanged), so a replay can build the real pipeline and drive it via tick_once instead of the wall-clock scheduler
  • Accept conduit_dir / arrow_dir on the Launcher so a replay passes its run directories explicitly instead of mutating process env
  • Record TD-100 (the replay API enforces its bar cap only after loading the requested range, acceptable while the endpoint is loopback-only), TD-101 (run_replay drives the live pipeline through Launcher private members — track a public replay seam for when the assembly is refactored), TD-102 (replay deliberately does not run the Nexus ShutdownSequencer, since shutdown is an operational event outside the replayed market timeline), TD-103 (the replay API run registry is unbounded — add eviction before running it as a long-lived service), TD-104 (give each run per-run strategy-module isolation before raising the executor above one worker for parallel replays), and TD-105 (replay drops strategy on_startup actions — they drain before ACTIVE mode / price context is set; out of scope for phase one)

v0.87.0 on 26th of June, 2026

Add

  • Add a per-trade ledger and summary metrics to every replay result (ReplayResult.trades / ReplayResult.metrics). build_replay_report groups a run's FillReceived events by trade_id (the position key the venue and Nexus share), pairs each position's exits against its entries FIFO into Trades (entry and exit time and price, quantity, gross PnL, fees, net PnL, return percent, bars held), and reconstructs an equity curve from the fills and bar closes to derive ReplayMetrics: trade count, win and loss counts, win rate, gross PnL, net PnL, total fees, PnL percent, average win, average loss, profit factor, max drawdown percent, annualised Sharpe, exposure percent, final equity, and open-position quantity. Grouping by trade_id pairs concurrently open positions independently rather than against one another; a sell exceeding its position's open lots raises rather than fabricating a short
  • Net the report's net_pnl and total_fees of all fees (entry and exit), so ReplayMetrics.total_fees equals ReplayResult.fees and the equity curve; the Nexus realized_pnl already on ReplayResult keeps its exit-fee-only convention, and both are exposed
  • Expose the report over the replay HTTP surface: GET /replay/{run_id} now returns metrics and trades (replay_api), with Decimal fields serialised as strings and undefined metrics as null
  • Add tests/test_replay_report.py and extend the run_replay and replay-API suites to cover trade pairing (single position, scale-in, partial exit, concurrent positions, sell-without-position), metric edge cases (no trades, all wins, all losses, break-even, single bar, near-zero equity, non-positive interval), fill-cashflow reconciliation across time and dollar bars, and the report's JSON shape

v0.88.0 on 1st of July, 2026

Add

  • Add a shared backtest-metrics core matching Limen's definitions (praxis/metrics/), consumed by both replay and paper trading so their metrics are directly comparable to Limen and to each other. quantile_triple reproduces Limen's finite-only, NumPy linear-interpolation p5/p50/p95 convention; snapshot_metrics computes the distribution metrics over a MetricStep return series (per-signal edge, per-trade net PnL and cost drag, clock-window rolling return and return-on-exposure, drawdown depth and duration — each as a bps p5/p50/p95 triple — plus 95% CVaR); ledger_metrics computes the scalar ledger metrics Limen's BacktestSequential reports that the replay report lacked (expected_value as mean PnL per trade, and traded volume by side). The clock-window bucketing uses polars (keeping pandas out of the trading process's import path) and numpy — now declared in pyproject.toml — provides the quantile
  • Surface both a Limen-parity and a portfolio metric set on every replay result (ReplayMetrics.snapshot / ReplayMetrics.snapshot_portfolio). The Limen-parity set sources per-trade metrics on the trade-notional basis (fully-invested-equivalent, matching Limen) while the portfolio set measures return on total deployed capital; both are computed by the shared core fed two return bases. Adds expected_value and net_long/net_short/net_trade_volume to ReplayMetrics, all exposed over GET /replay/{run_id}
  • Add a paper-trading metrics path over the Event Spine. build_paper_metrics computes the shared metrics against the MtmLoop mark timeline (a (timestamp, mark_price) series) using build_metrics_from_timeline — the shared metric core extracted from build_replay_report so replay (bar closes) and paper (marks) run the same pipeline; build_paper_report reads a run's FillReceived and MarkSampled spine events and renders the same JSON payload the replay API emits, via the shared metrics_serialization module
  • Add a MarkSampled spine event (account, timestamp, symbol, positive mark price) as the durable per-sample record a paper run's equity series is built from, registered for spine round-trip and treated as a no-op by the TradingState projection
  • Add MarkSampler, started once per account on the launcher loop after healthz, which appends a MarkSampled each PRAXIS_MARK_SAMPLE_INTERVAL_SECONDS from the stateless ArrowPriceStore mark, skips ticks when no mark is available, and logs and continues on a tick failure so a transient append error cannot stop the loop; and a loopback-restricted GET /metrics on the launcher healthz server, which reads the account's spine events for the epoch and serves the shared paper report (dropping any non-increasing-timestamp mark first, so a clock step or a post-restart duplicate cannot fault the endpoint; non-loopback callers get 403 since it exposes PnL and fills). Sampler startup is best-effort so a failure never aborts trading, and the samplers stop first during shutdown so no sample races the spine teardown
  • Add the praxis/metrics/ and praxis/paper/ test suites plus launcher /metrics endpoint and mark-sampler wiring tests, covering the percentile and metric definitions against Limen's, the two replay return bases, the paper report from spine events, the MarkSampled round-trip, and the sampler append and price-unavailable paths

v0.89.0 on 2nd of July, 2026

Fix

  • Make return_on_exposure in snapshot_metrics exactly Limen-equivalent by excluding the first (execution-lag) step from the exposure denominator, matching Limen's backtest_snapshot — which drops its execution_lag_bars row from the eval mask — so all 22 distribution metrics now reproduce Limen's real backtest_snapshot bit-for-bit (verified against the Limen codebase across scenarios with 1, 3, and 6 leading flat bars). It was the only metric sensitive to the excluded row, since that row is flat and so neutral to the rolling-return, drawdown, and edge series

Add

  • Add return_on_exposure_full_p5/_p50/_p95 to the snapshot alongside the Limen-exact return_on_exposure, computing exposure over every step rather than excluding the lag row. Fill-based replay and paper runs have no execution lag, so this all-steps variant is the more complete return-on-exposure for them; both variants appear on ReplayMetrics.snapshot and snapshot_portfolio
  • Add snapshot tests pinning the Limen-exact-vs-full return-on-exposure split (exposure denominator over eligible vs all steps) and the all-flat None case

v0.90.0 on 3rd of July, 2026

NOTE

  • A Codex-supervised audit of the v0.88.0/v0.89.0 metrics upgrade found the replay/paper snapshot was Limen-shaped but not Limen-equal: it fed fill/mark-derived steps into a metric core that expects Limen's OHLC bar backtest, so entry-bar edge, per-trade return, and cost drag diverged, and return_on_exposure was internally inconsistent when a run entered on the first step. This release reworks the Limen-parity snapshot to a bit-exact bar backtest and retires the v0.89.0 return_on_exposure eligible-split approach and the return_on_exposure_full extension
  • ReplayMetrics.snapshot is now the Limen backtest over a run's bars (replay only). A paper run has no bar backtest, so its snapshot is {}; consumers of the paper /metrics endpoint read snapshot_portfolio instead

Add

  • Add limen_snapshot, a faithful numpy port of Limen's backtest_snapshot, so a replay over historical bars reproduces Limen's distribution metrics without a pandas/Limen runtime dependency. Pinned by golden fixtures generated from the real Limen across 11 scenarios (entry-on-first-bar, always/never in position, open-at-end, single/two-bar, execution_lag_bars > 1, non-default fee/slip, and a zero-close continuation that preserves the infinite return Limen produces), plus validation cases for non-binary/NaN predictions, non-finite prices, and mismatched lengths
  • Carry each bar's open price onto ReplayBar and read it in load_replay_bars, so the Limen entry-bar return close - open is available (the column already existed in the mounted OHLCV frames)

Fix

  • Compute the replay Limen-parity snapshot by running the limen_snapshot port over the run's bars, independent of the actual fills, so it is bit-for-bit equal to Limen; snapshot_portfolio stays the fill-based total-account-equity view
  • Make return_on_exposure in snapshot_metrics internally consistent by computing its numerator and denominator over the same steps, dropping the execution-lag eligible/first-step split; snapshot_metrics now serves the portfolio basis only
  • Validate a timezone-aware timestamp and finite returns on MetricStep; cancel the MarkSampler task on stop so a stuck spine append cannot block shutdown, and guard the sampler build against a duplicate start; wrap the launcher /metrics read and report build so malformed spine state returns a structured 500 rather than an unhandled error
  • Restate the ledger volume metric as Praxis's actual filled entry notional (entry_price * qty) rather than claiming exact parity with Limen's reinvestment-model volume; expected_value remains the Limen-parity scalar

v0.91.0 on 6th of July, 2026

NOTE

  • The Account sub-system is a per-account double-entry ledger — the authoritative books, distinct from Nexus which owns capital and PnL for decisions. AccountLedger is a projection rebuilt by replaying Event Spine events, like TradingState; it is a secondary projection, so a booking failure is logged and never propagated into the trading path
  • JournalEntry moves from the trade-specific trade_id/command_id fields to generic source_event_type/source_event_id, since each entry derives from exactly one spine event; CostBasisMethod moves to the shared enums module

Add

  • Add a RegisterAccount spine event that fixes each account's immutable cost_basis_method (FIFO default, validated). The ledger starts unregistered and is strict: a FillReceived or TradeClosed before registration is rejected, and re-registration raises
  • Wire AccountLedger.apply into the per-account spine-append path via a single projection helper, at replay and the live fill and trade-closed append sites. A genuinely new account durably emits RegisterAccount at startup; pre-feature spine history that carries no RegisterAccount is registered in memory with the FIFO default at replay and never written back
  • Add base-asset fee handling: a BTC fee on a buy is valued at the fill price, credits Crypto:BTC rather than Cash:USDT, and reduces the cost-basis lot to the net quantity received, so the ledger's base inventory and cost basis match the venue balance. Quote-asset (USDT) fees are unchanged; any other fee asset raises
  • Add a FundTransaction spine event (amount, a FundDirection of DEPOSIT or WITHDRAWAL, and a stable fund_transaction_id) booking a deposit as Dr Cash:USDT / Cr Equity:Contributions and a withdrawal as the reverse; the ledger records an over-withdrawal rather than rejecting it, since enforcement belongs upstream
  • Add balances and per-trade realized-P&L read accessors — read_balances/read_trade_pnls on AccountLedger and get_account_balances/get_account_trade_pnls on ExecutionManager — returning detached copies so a caller cannot mutate the projection

v0.92.0 on 12th of July, 2026

NOTE

  • WP-Praxis-0008 (Live operability & safety): the live-trading safety controls, pre-trade price/slippage gates, operator control surface, and alerting for the MVP. The operational-mode arbitration lands in Nexus (ModeController, halt holds, risk breakers, sole state.mode writer), pinned here at 0.70.0; Praxis wires it per account and adds the pre-trade caps, price stage, slippage guard, /ops endpoints, and alert sink

Add

  • Enforce a configurable pre-trade PRAXIS_MAX_ORDER_NOTIONAL cap (snapshot-free) and a context-aware PRAXIS_MAX_POSITION cap that projects current position plus the order delta, rejecting an order that would breach either before it reaches the venue
  • Wire a per-account ModeController into the health loop and configure its risk breakers from the account manifest's risk_controls — a live daily-loss or drawdown breach HALTS the account, and reconcile re-derives the mode on boot before startup actions drain so a halt that outlived a restart is in force first
  • Add a loopback + bearer-token (PRAXIS_OPS_TOKEN, constant-time compare) /ops operator surface — halt, resume, status, cancel-all, close-all — with durable holds (persisted through the state store) and OperatorHaltRequested / OperatorResumeRequested spine audit events
  • Add an order-book cache and poller that feed the pre-trade price stage: build_price_snapshot derives spread and staleness, gated by PRAXIS_MAX_SPREAD_BPS and PRAXIS_BOOK_STALENESS_SECONDS
  • Reject MARKET orders whose quote-denominated estimated slippage exceeds PRAXIS_MAX_SLIPPAGE_BPS, reusing the shared book-walk estimator (resolves TD-078)
  • Add a minimal AlertSink (structured log + optional PRAXIS_ALERT_WEBHOOK_URL webhook) and route alerts on any HALT transition and every operator action
  • Route shutdown through the Nexus ModeController shutdown hold: ShutdownSequencer places the dedicated hold (un-liftable by a concurrent health tick) instead of writing state.mode, so an in-flight outcome dispatched mid-shutdown cannot resume trading

Fix

  • Use a non-reserved LogRecord key for the nexus-thread-timeout warning in _shutdown; extra={'thread': ...} raised KeyError: Attempt to overwrite 'thread' in LogRecord whenever a nexus thread missed its join

v0.93.0 on 14th of July, 2026

NOTE

  • WP-Praxis-0005 (Event Spine integrity, secrets & reconnection): tamper-evident audit, key custody, and no-lost-fills connection integrity for the live-trading MVP. All changes are Praxis-only — the Event Spine, credential path, and venue adapter live here; Nexus consumes aggregate TradeOutcomes and needs no change. Introduces the first Event Spine schema-migration mechanism (PRAGMA user_version), advanced across this WP to version 3
  • Two changes alter runtime shape on the order-critical path and must be validated on the paper host before a tagged release: the EventSpine per-append asyncio.Lock (chain serialization) and the per-account submission gate plus projection fail-stop in ExecutionManager
  • The version 3 migration is fail-closed on a multi-symbol legacy spine: if a pre-existing fill_dedup table holds more than one symbol (or a row that cannot be matched to a proven symbol), ensure_schema raises and boot aborts rather than guessing the per-symbol dedup key. A spine that only ever traded one symbol migrates cleanly; a multi-symbol legacy database must be reconciled offline before upgrading

Add

  • Add a tamper-evident hash chain to the Event Spine: nullable prev_hash/hash columns and a SHA-256 chain over a length-framed preimage (domain marker, chain version, predecessor hash, event_seq, epoch_id, timestamp, event type, payload), serialized per append. verify_chain runs at boot before order capability and fails closed on a broken link, altered field, deletion, or a hashed-to-unhashed transition; legacy rows keep a NULL-hash prefix and are not backfilled
  • Add a versioned, transactional, fail-closed-on-newer schema migration in EventSpine.ensure_schema keyed on PRAGMA user_version
  • Add a SecretStore protocol with a frozen, redacted Credentials value object, a KeyringSecretStore (OS keyring, one JSON record per account under service praxis-binance), and a MappingSecretStore for paper and tests. Credentials replace bare (api_key, api_secret) tuples through TradingConfig, TradingInbound, the VenueAdapter protocol, and BinanceAdapter; main resolves them once at boot by TRADE_MODE — keyring-only under live, the env mapping under paper (adds the keyring dependency)
  • Add a boot-time API-key permission assertion: query_api_permissions reads the signed apiRestrictions endpoint, and the launcher rejects a key with withdrawals enabled or spot trading disabled before order-capable startup (live only — the endpoint is not served by the spot testnet)
  • Extend query_trades with from_id/end_time/limit and a durable per-(account, symbol) reconcile_cursor that outlives epochs; paginate_my_trades walks myTrades from the cursor (inclusive overlap, exclusive advance, short-page stop, page cap with a logged truncation), or from a bootstrap time window when no cursor exists yet
  • Add per-symbol fill deduplication: fill_dedup_v2 keys on (epoch, account, symbol, venue_trade_id), with an O(events) legacy-symbol discovery that records the one proven pre-migration symbol and dual-reads the legacy table only for it — failing closed when the legacy database spans multiple symbols or holds an unmatched row
  • Add full WebSocket reconnect handling to BinanceUserStream: async on_disconnect/on_reconnect lifecycle callbacks (the reconnect edge only), and a guard so a raw transport exception enters backoff rather than killing the reconnect task
  • Add reconnect reconciliation with a per-account submission gate: on reconnect Praxis backfills missed fills from the cursor and reconciles open orders while new-command submission is gated, then releases; a projection failure poisons the account (fail-stop until a restart replays the durable state), and a venue failure leaves the account gated

Fix

  • Tighten the per-account writer so a projection failure poisons the account (fail-stop) instead of being logged and swallowed, since a durable event that cannot be applied means the in-memory state has diverged and must not keep trading

v0.94.0 on 2nd of August, 2026

NOTE

  • WP-Praxis-0007 (Execution modes): six strategy-decided execution modes carried on the Nexus Action — Bracket, TWAP, Time DCA, Scheduled VWAP, Iceberg, and Ladder DCA — plus per-mode enablement and shutdown semantics for the live-trading MVP. Mode is decided by the strategy; the engine must support a mode before a strategy emitting it can deploy. TWAP, Time DCA, Scheduled VWAP, and Ladder DCA run on one shared scheme engine (per-child fill aggregation, finalize-on-all-settled, abort, deadline backstop, and boot resume from replay); Bracket and Iceberg have dedicated paths
  • The Bracket mode is cross-repo: Praxis executes the MARKET entry and places the protective OCO, and the launcher (which hosts the Nexus decision loops) pre-registers a deterministic protective-exit context so the OCO's fill reduces the position and releases capital through the standard outcome path. Both ends derive the same exit command id via bracket_exit_command_id
  • Two runtime-shape changes on the order-critical path must be validated on the paper host before a tagged release: the shutdown per-mode abort-and-drain in Trading.stop and the admission-control submission gate plus stale-command expiry in ExecutionManager
  • Deferred debt is recorded in docs/TechnicalDebt.md TD-120 through TD-133: static-curve VWAP without live-volume participation (TD-120), non-MARKET entry pricing (TD-121), a bracket naked position on definitive OCO failure (TD-130), and no post-submit deadline sweep for a resting single-order LIMIT / iceberg (TD-132)

Add

  • Add the shared multi-slice scheme engine: TWAP and Time DCA submit equal MARKET children at a fixed interval via plan_even_slices; Scheduled VWAP splits the quantity across a strategy-supplied volume curve via plan_weighted_slices. A child settles when its order projection reaches a terminal status; its immediate and WebSocket fills aggregate into the parent, which finalizes FILLED only once every slice is submitted and every child has settled
  • Add slice-failure freeze (RFC 5.13): a slice that cannot be placed appends SliceFailed, reports a non-terminal PARTIAL TradeOutcome, and freezes the scheme to await the Manager or its deadline; a SchemeInitialized deadline backstop terminalizes a scheme whose child never settles
  • Add boot resume for non-terminal schemes: SchemeInitialized persists the mode, slice count, interval, timeout, VWAP volume weights, and Ladder price levels, so replay_events rebuilds each running scheme's live state and re-registers it rather than terminalizing it on boot
  • Add Bracket mode: a MARKET entry then, on the entry settling, a protective OCO on the opposite side for the filled quantity, with take-profit / stop-loss as absolute prices or basis-point offsets from the average entry (side-aware, tick-snapped). A BracketInitialized event makes the bracket resumable so boot places or re-tracks protection; a protective-leg fill produces a position-closing exit outcome under the deterministic exit command id
  • Add Iceberg mode: work the quantity as a single native-iceberg LIMIT order carrying Binance's icebergQty, so the venue shows display_qty at a time and refills it from the hidden reserve; incremental WebSocket fills drive PARTIAL then FILLED outcomes
  • Add Ladder DCA mode: post, all at once, one resting LIMIT order per explicit price level, sized from the level allocation (weighted or equal, lot-floored); the ladder aggregates fills on the shared scheme engine and reconstructs its live rungs from durable order projections on resume so a crash mid-posting cannot falsely finalize
  • Add Binance REST support for Stop, Stop-Limit, Take Profit, and TP-Limit order types, OCO order-list status query (query_order_list) for crash recovery, and OCO-aware submit rescue that resolves a timed-out or duplicate OCO POST from the venue's order-list state
  • Add admission control: a bounded, fail-closed per-account command queue, stale-command expiry at dispatch, and a shared venue-operation rate budget (TokenBucket) across submit, cancel, query, and reconcile
  • Add a per-mode capability gate: ExecutionManager rejects a command whose execution mode is not enabled, and TradingConfig.enabled_execution_modes defaults to {SINGLE_SHOT} so a mode driven live is off until the deployment enables it via PRAXIS_ENABLED_EXECUTION_MODES
  • Add live-only mode classification (live_only_modes): Bracket, Iceberg, and Ladder DCA rest non-MARKET orders the binsim paper venue cannot simulate, so the launcher refuses enabling them against binsim while still allowing them on Binance testnet
  • Add per-mode shutdown cancel: in_flight_command_ids reports every non-terminal in-flight command — running schemes, brackets awaiting protection, resting single-order commands, and commands still queued — and Trading.stop aborts each so every mode reaches a terminal CANCELED outcome carrying its cumulative fills before teardown

Fix

  • Ignore ruff PLR0917 (too many positional arguments), matching the existing suppressions for its Pylint-complexity siblings PLR0913/PLR0912/PLR0915; the CI ruff runner promoted the preview rule to stable and flagged it across pre-existing modules

v0.95.0 on 22nd of August, 2026

Add

  • Add the TradeModify control path: TradeModify and per-mode ModifyParams amend dataclasses, validate_trade_modify inbound validation, a Trading/TradingInbound submit_modify facade, and priority-queue handling so an amend is applied ahead of new commands on the account writer
  • Add order-price amend for a resting single order (SingleShot LIMIT / Iceberg): cancel-then-query-then-place, sizing the replacement from the venue's post-cancel filled quantity so a fill racing the cancel can never over-order, with a durable OrderAmendInitiated that rebuilds the amend sequence on boot
  • Add scheme-plan amend for a running TWAP / Time DCA / Scheduled VWAP: the unfilled remainder is re-planned across the remaining slices and the cadence rescheduled in memory, with no venue cancel since the interval schemes rest no orders
  • Add the bracket protective-OCO amend: a versioned Protection* state machine drives a cancel-then-replace of the resting OCO — persist-before-cancel, reconcile the remaining exposure from venue truth, and place an idempotent replacement that resolves a timed-out or duplicate POST from the venue's order-list state, ending in ProtectionActive
  • Add the naked-protection failure response (per-account BracketProtectionFailureResponse sourced from the Nexus manifest): on a definitive amend failure the account's schemes freeze against adding exposure, the reconciled remainder is market-flattened for a FLATTEN_THEN_HALT account, and a durable remediation pushes a HALT / REDUCE_ONLY hold to Nexus
  • Add the STATE_UNKNOWN protection watchdog: an amend that cannot confirm its venue outcome holds in a durable STATE_UNKNOWN, and a reconcile-tick watchdog on the account writer re-queries it — re-tracking a still-working OCO ACTIVE, closing the bracket when a protective leg filled, and remediating a confirmed-naked position. A bracket whose venue state stays unconfirmable is held STATE_UNKNOWN until the bracket_protection_restore_deadline_seconds restore deadline elapses; past it, still unable to confirm, it is remediated as a fail-safe on the local fill projection (the flatten free-caps the sized quantity) rather than left unprotected indefinitely. All resolvable across a restart
  • Add naked-entry remediation for a failed initial protective-OCO placement (TD-130): a wrong-side, unsalvageable-timeout, or venue-error placement routes the filled entry through the same freeze / flatten / hold remediation instead of holding a naked position, delivering the entry outcome before the flatten and confirming no live leg before selling
  • Add the ladder-rung amend: a LadderDcaModify re-plans a resting Ladder DCA grid through a strict two-phase state machine — retire and venue-confirm every old-generation rung before placing the new grid at generation-qualified client ids — with generation-aware boot resume and a reconcile-tick watchdog that finishes an amend left STATE_UNKNOWN or caught mid-flight
  • Add the reconciliation engine: fund-transaction polling, periodic balance reconciliation against the live venue, and dispatch of a ReconciliationMismatch — with confirmed fund transactions and mismatches event-pushed to Nexus via the outcome processor
  • Add a cold-start policy that leaves venue positions and open orders Praxis did not create untouched, so a restart adopts only its own lineage rather than cancelling or reconciling foreign state
  • Add an amend exposure ceiling and a modify-params translator on the Nexus launcher path, and repin vaquum-nexus to the release carrying the bracket-protection hold, ProtectionRemediationHandler, and per-account manifest response policy

v0.96.0 on 28th of August, 2026

Add

  • Add a per-account writer-admission primitive: admit hands a fill, terminal, or fund transaction to the single account writer, which appends and projects it in turn with its own command work so the projection order can never diverge from the spine order, deduplicating fills on (epoch, account, symbol, venue_trade_id) so a trade delivered by both the WebSocket stream and reconnect backfill is booked once
  • Add a boot-ownership boundary so no account-writer task becomes runnable until startup recovery completes, letting replay and reconciliation finish before any live event competes for the writer
  • Add the fail-closed live-arm interlock: mainnet order routing requires PRAXIS_LIVE_ARM to match the expected token exactly, refused before any adapter, socket, or credential backend is built
  • Add the mandatory live limit-cap profile and account loss breakers: a live launch requires a complete _LiveLimitProfile (spread, staleness, order-rate, slippage, and account breaker thresholds) and fails closed if any cap is unset
  • Add the pre-trade price-deviation collar: each manifest strategy's max_price_deviation_bps projects into the Nexus instance config, both ENTER validation contexts carry the strategy's action.reference_price, and build_price_snapshot computes the book-mid deviation and tags the origo_mid source, so the validator PRICE stage rejects an ENTER whose market has moved past the per-strategy cap and fails closed when a capped strategy supplies no reference price; vaquum-nexus is repinned to the release carrying the per-strategy deviation cap and reference-price contract
  • Add the event-spine projection-replay parity harness (replay_parity): assert a recorded spine reconstructs an identical TradingState, hold the OCO bidirectional and open/closed-disjoint invariants, and confirm replay is deterministic

Fix

  • Fix reconnect fill backfill missing OCO leg fills: _reconcile_fills now remaps a protective-leg client_order_id to its parent so a leg fill arriving during a WebSocket gap updates the bracket instead of leaving a ghost open position
  • Fix a slippage guard that passed when the venue book had no usable depth: estimate_slippage returns None on partial depth and the guard rejects a single-shot MARKET order it cannot price
  • Split the reconcile-tick watchdogs into isolated failure domains so one detector's failure cannot stop the reconcile loop (TD-137)

Update

  • Update the TradingState projection and boot replay/reconcile, prune unused event types while retaining their hydrators, and classify MarkSampled and launcher audit/ack appends as telemetry outside the state-machine contract

v0.97.0 on 10th of September, 2026

BREAKING

  • Remove the unused TradeOutcome.missed_iterations and TradeOutcome.missed_reason constructor fields and attributes
  • Rename ExecutionManager.drain_ws_events to drain_external_events and has_pending_ws_events to has_pending_external_events to cover admission, legacy WebSocket, and dispatch queues
  • Replace TwapParams and TimeDcaParams with IntervalSliceParams, and TwapModify and TimeDcaModify with IntervalSliceModify, without compatibility aliases; TIME_DCA command and modify payloads must use num_slices instead of num_iterations, while the execution-mode identifiers and TIME_DCA BUY-only rule remain unchanged
  • Advance the event database to schema 4 by folding symbol-proven legacy fill_dedup rows into fill_dedup_v2, verifying coverage per key, and dropping the old table; migration resumes after interruption, and older builds refuse the upgraded database, so preserve a pre-upgrade backup for rollback. This is an on-disk contract break: the DROP commits on its own, and a 0.96 build cannot open a database whose legacy table is gone, so downgrade is the pre-upgrade copy only

NOTE

  • Refuse missing or incompatible stored chain identity before the schema-four fold; gate each migration on its introducing version so an already-proven database does not repeat the legacy single-symbol proof

Add

  • Add SchemeDraining and SchemeReplanned, the scheme transitions that had no durable representation. An abort or expiry appends SchemeDraining carrying the outcome it is waiting to emit; an amend appends SchemeReplanned carrying the slice quantities, count, interval and next-run timestamp it produced together with whether it cleared a slice-failure freeze. Replay rebuilds the hold a restart should see, the schedule that hold applies to, and the timer belonging to that schedule, rather than re-deriving any of them or pairing a new plan with the timer it replaced
  • Add regression coverage for abort during ladder cancel and placement phases, uncertain cancellation, replacement-generation fill backfill, and terminal replay
  • Add regression coverage for missing or foreign chain identity across schema versions, mutation-free rejection, intact upgrades, and interrupted unversioned initialization
  • Add regression coverage that an unusable scheme does not prevent a healthy scheme from replaying
  • Add regression coverage that scheme resume does not re-arm next_run_at while a child is still live

Fix

  • Fix aborting a protection-frozen ladder mid-amend to retire and confirm both rung generations without posting replacements, backfill cancellation-time fills, and emit one canceled outcome after confirmation
  • Fix boot recovery and stale-balance guards to cover every external-event queue and in-flight admissions, drain boot reactions to completion, and refuse readiness or flatten sizing after a projection fail-stop
  • Fix BracketInitialized hydration to validate complete protective-leg combinations through BracketParams
  • Fix confirmed-OPEN bracket protection replay to restore amendability, effective leg prices, and the list actually re-tracked by the watchdog
  • Fix ExecutionReport validation to require finite TRADE fills and commission, strip residual fill fields from non-TRADE reports, and log malformed frames with their order identity
  • Fix late fills on closed orders to update quantity and notional without reopening the order, keeping flatten remainder totals accurate
  • Fix missing chain identity on schema v1/v2 by validating versioned spines before schema writes and initializing identity only for unversioned databases
  • Fix re-entrant command registrations to retain the existing strategy attribution at both registration sites
  • Fix TradingState.apply to record CommandAccepted strategy attribution and preserve it in pure projection replay
  • Fix unexpected account-writer exits to poison the account and fail pending admission waiters
  • Fix scheme resume kicking next_run_at to now while a child order is still live
  • Fix an aborted or expired scheme replaying as a running one: the drain and the outcome it was waiting to emit lived only in memory, so a crash inside the drain window resumed a scheme with an empty child set and a due timer and re-armed a command that had already been aborted. _begin_scheme_drain appends the drain before setting it, and replay restores the hold and its pending outcome from that one event, so the two can no longer be derived apart (TD-153, TD-127 item 1)
  • Fix an amended scheme re-freezing on restart: clearing a slice-failure freeze was an in-memory write while SliceFailed stayed on the spine, so _resume_hold re-froze the scheme and the live and replayed holds disagreed. The clear is now durable, and a protection freeze — which no amend may clear — is still never thawed (TD-135, freeze half)
  • Fix an in-flight ladder amend posting replacement rungs for an aborted ladder after a crash: the driver already refused to place while draining, but replay could not reconstruct the drain, so the resumed amend ran on to placement
  • Fix a resumed drain never retiring the children the crash left working: the drain is durable before its cancels are sent, and deadline expiry deliberately skips a draining scheme, so a crash in that window left the rungs resting behind an abort that never took effect. A resumed drain re-drives its cancellations on the account writer ahead of the reconciling and poisoned gate, alongside the abort the priority queue already drains there, because a gated reconnect is the very window a crashed abort resumes into
  • Fix a confirmed-naked bracket raising before its remediation: an initial, never-amended OCO is revision zero, which ProtectionFailed refuses, so the durable marker, the market flatten and the Nexus hold were all skipped and every later scan repeated the failure with the position unprotected. The revision is normalized inside _remediate_naked_bracket rather than at each caller, two of which passed it raw
  • Fix the terminal-protection handoff being in-memory only: a restart between the terminal dispatch and the watchdog's resolution left no unresolved phase to restore, so an open position came back with neither a tracked bracket nor a pending remediation. ProtectionStateUnknown is appended before the in-memory transition, naming the terminalized list as the candidate to re-query
  • Fix replay choosing the resumed slice timer by wall clock: the replay clock is constant within a bar, so a progress event sharing a stamp with a later amend won and restored the schedule the amend replaced. Selection compares durable spine sequence, which is the order that actually happened
  • Fix a failed boot leaving the children of a durable drain resting at the venue: the writer parks for good and never reaches the re-drive, so boot failure retires them itself, at the point where recovery has finished and nothing else owns the account
  • Fix the resumed-drain re-drive re-cancelling on every pass of the account loop, and retry it on a bounded interval instead: children that are merely settling are not re-cancelled, while a cancel the venue refused is re-sent once the interval elapses rather than waiting for the account to become order-capable
  • Fix submit_command accepting work an account can never execute: a poisoned account, or one whose startup failed and parked its writer, never dequeues its command queue, so the caller was told a command was accepted that produced no order and no outcome. Both states are refused before any durable state is written, matching the sibling paths, and a command already queued when the account dies is terminalized REJECTED so the decision layer learns its fate — covering startup failure, the loop observing itself poisoned, the loop dying outright, and an account that dies across the durable accept's own append
  • Fix the abort refusal keying on the wrong condition: a failed boot parks its writer, but a writer that dies sets only poisoned, so its aborts were accepted and never drained. Refusal now asks whether a writer is still running; a poisoned writer that is still ticking still takes aborts, since draining a risk-reducing abort is what it is for
  • Fix shutdown cancelling a recovery flatten: refusing a failed boot's abort sent every one of its commands to the direct cancellation pass, including the one whose MARKET order was closing a naked position. A working flatten is left to fill, identified by the client order id its FlattenInitiated recorded — kept when the event is appended and rebuilt from the spine on replay. Neither the shape of a command id, which a caller may supply verbatim, nor the presence of a live bracket, which a failed protection does not leave behind, decides it (TD-155)
  • Fix a failed boot leaving its user stream connected with nobody to read it, so fills, partials and rejects no longer arrive at a consumer that cannot process them
  • Fix the protection watchdog querying the same order list twice when both of its candidate ids are the same list
  • Fix an amended scheme resuming onto the schedule it replaced: persisting only the permission to run again let replay clear the freeze while rebuilding the original plan from SchemeInitialized, which executed a stale slice and terminalized FILLED short of the target. The plan is carried with the permission, so the two cannot separate (TD-135)
  • Fix a bracket reporting live protection after its protective OCO reached a terminal state, by fill or by cancellation: the OCO carries the bracket's exit command id and a leg reports under its own, so neither resolved through the entry-keyed map and the bracket stayed ACTIVE and amendable with nothing resting at the venue. The list is now resolved through the leg-to-parent map and held STATE_UNKNOWN for the reconcile-tick watchdog, which re-queries the venue and re-tracks a list still working, closes the bracket when a leg filled, and remediates only a position it has confirmed naked — the local projection cannot size that flatten, since a cancellation can arrive before the sibling leg's fills project and would sell exposure the take-profit already closed
  • Fix shutdown skipping a failed-boot account's resting orders: submit_abort accepted an abort its parked writer would never drain, and shutdown then excluded those orders from the direct cancellation pass. The abort is refused, so the orders are cancelled directly
  • Fix a failed boot unparking the account writer in finally before cleanup, so a load-filters / reconcile / flatten failure cannot advance schemes or place protection
  • Fix a failed boot leaving its writer parked with no way to refuse work: the writer stays parked so a not-ready account still cannot advance schemes or place protection, but the account is marked boot-failed and admit refuses it, so the WebSocket reader and the reconcile tick learn the account is down instead of blocking forever on a future the parked writer will never resolve while the stream is up and a recovery flatten may already rest at the venue. The not-ready log now names the reason that actually applied rather than always blaming the orphan sweep
  • Fix _reconcile_fills swallowing a VenueError from query_trades, which let a reconnect pass report success and release the account to IDLE with venue fills it never recovered, oversizing a later flatten. It now propagates, matching the documented contract and the query_order path
  • Fix order-reconciliation swallowing VenueError from query_order, which let reconnect treat a failed pass as success and release IDLE
  • Fix repository-source links in TechnicalDebt.md so the documentation site passes strict link validation

Update

  • Refactor Binance request construction through _ORDER_TYPE_SPECS, preserving required-before-forbidden validation and rejecting a supplied MARKET price instead of silently dropping it
  • Refactor command and modify payload construction to derive accepted keys and tuple coercion from PARAMS_FOR_MODE and MODIFY_PARAMS_FOR_MODE
  • Refactor command registration into one _CommandRegistration record and run pre-registration failure cleanup through _PreRegisteredSubmission.rollback
  • Refactor reconciliation gates into ReconcilePhase, keeping disconnects, incomplete backfills, venue failures, and unexpected exits gated
  • Refactor replay inline fills to derive ImmediateFill from the recorded VenueTrade
  • Refactor scheme and ladder boot reconstruction to share one history fold while retaining separate initialization records
  • Refactor scheme holds into _Hold with explicit protection, slice-failure, and terminal-drain precedence
  • Refactor snapshot metric assembly into build_snapshot_result, sharing output keys, units, and rounding across the portfolio and Limen engines
  • Refactor the four Trading callback setters to share their startup guard and the launcher reconciliation routes to share runtime lookup
  • Refactor TWAP and Time DCA schedule construction and amendments to use the shared interval-slice parameter types
  • Update Event-Spine.md and Recovery-And-Reconciliation.md for schema 4 and record the pre-existing partial-OCO replay limitation as TD-152 in TechnicalDebt.md
  • Update Execution-Manager.md and Trade-Outcomes.md with the v0.97.0 API migration and add the shared metric assembler contract in Metric-Snapshots.md
  • Record TD-153 (hold vs pending_terminal) and TD-154 (ladder amend_phase strings) in TechnicalDebt.md

v0.98.0 on 13th of September, 2026

NOTE

  • Correcting binsim's buy commission to the received asset (#136) makes paper trading reproduce a live behaviour it previously masked: TradingState credits a position the gross fill quantity while AccountLedger nets the base commission out of its lots, so a fully-closed trade leaves a phantom position above the lot step. Recorded as #183; the divergence is in Praxis, not in the simulator

Add

  • Add execution_slippage_bps and arrival_slippage_bps to TradeOutcome, measuring the average fill price against the pre-submission mid and against the decision layer's reference price. Both were already computed per fill and written to two log lines and nowhere else, so nothing downstream could read what execution had cost. They are carried on the outcome and persisted on TradeOutcomeProduced, so a replayed outcome reports what the produced one reported — the inputs they derive from are not on the spine, so an outcome rebuilt from the record cannot recompute them. Absent rather than zero when their inputs are missing, since zero is a real reading. OutcomeTranslator does not forward them: the Nexus outcome has no field for either, and widening that shape is a change in that repository, tracked as Vaquum/Nexus#112 (#172)

Fix

  • Fix an overfilled command reporting a price several times the one that executed, or dropping its terminal outcome entirely. A venue can report more filled than was ordered, and the two producers that clamped it disagreed: capping the quantity while keeping the whole notional made the implied average the spend of every fill over the accepted size, while scaling the notional to match the capped quantity could land below a notional already published for an earlier partial, making the incremental delta negative so OutcomeTranslator rejected it and the terminal outcome was lost. Admission now happens once, per fill, as it projects: min(qty, target - accepted) at that fill's own price, with the excess discarded. The totals are a property of the fills themselves, so they are identical whether fills arrive singly, drain from the queue in one batch, settle immediately on submission, or come back from replay (#178)
  • Fix a quote-native command having no overfill bound at all, by capping it on spend rather than size, with the admitted quantity following at the price that executed
  • Fix replay rebuilding an amended command from its replacement order, whose quantity is only the remainder: the smaller quantity became the command target after a restart, so fills already admitted against the original target exceeded it and filled_qty >= cmd.qty decided completion against the wrong number. The first submit intent establishes the target, matching live, which never rewrites it
  • Fix a scheme's fills replaying uncapped, since replay holds scheme commands out of the command map until after every fill has projected. The budget is recorded when SchemeInitialized projects, in spine order, as live records it at initialization
  • Fix a fill arriving after its command terminalized being admitted uncapped, by recording the budget when the command's identity is established rather than at its first fill, and keeping it past the command's removal
  • Fix a position being credited the quantity a buy quoted rather than the quantity it delivered. A spot venue charges the taker commission in the asset received, so a buy delivers qty - fee base, and AccountLedger already netted it out of its lots while TradingState did not: the position sat above the wallet by the commission on every buy, compounding, so selling everything actually held left the commission behind as an open position above the lot step and a flatten sized from the position asked for more base than the account had. Command-level fill totals stay gross, since a command that ordered a quantity and received it is complete and the commission is a cost rather than a shortfall (#183)
  • Fix a flatten taking its remainder as the exit command's target: a flatten that follows a partly-filled protective exit is sized to what is left, while the fills accumulating under the exit id span both orders, so the outcome reported more filled than targeted and its construction was rejected. The exit command keeps the target it inherits
  • Fix an immediate iceberg reporting PENDING with no fills after filling completely, by reading the command's admitted totals rather than an order map a filled order has already left for closed_orders
  • Fix binsim charging a MARKET BUY commission in USDT, where the venue charges it in the asset the trade receives. A simulated buy left the whole filled quantity on the books while a real one leaves qty * (1 - rate), so the base balance diverged from live by the taker rate on every buy, silently, since both sides still balanced. Binance charges the taker commission in the received asset on a spot trade unless it is paid in BNB, so binsim was feeding Praxis a fill shape the venue does not produce; AccountLedger accepts either denomination, so nothing downstream objected. The fee is now charged in the received asset per side, commissionAsset reports it, both ledger entry points settle through one rule so neither can report a commission in an asset it did not deduct, and a BUY fee that is not smaller than the quantity it is charged on is rejected rather than settled into a negative balance (#136)
  • Fix binsim advertising LOT_SIZE and NOTIONAL filters in exchangeInfo and applying neither, so orders off the lot step, below the minimum quantity, or under the minimum notional were filled and reported at a precision the symbol does not trade at, where the venue answers -1013. Both filters are enforced on the order path — quantity before matching, and notional at the reference price rather than the executed one, so slippage cannot carry an order over a minimum it fails at the top of the book. A quote-denominated buy trims its fill ladder to the step, so the quantity executed, settled and reported agree. The advertised payload is built from the same constants the order path enforces, so the two cannot drift apart again, and those constants are verified against the venue's published BTCUSDT filters (#137)
  • Fix the register subcommand and a running server writing the same ledger snapshot with nothing ordering them. Both write it whole from their own in-memory state, so whichever wrote second discarded the other's work: register reverted every fill persisted since it loaded, and the server's next write dropped the account register had just minted. The atomic tempfile-and-rename guards one write from tearing, not two writers from racing. A state directory now carries an exclusive advisory lock, resolved so two spellings of one directory cannot each take their own, held by the server for its lifetime and by register across its read-modify-write, so the second to start exits naming the holder instead of silently reverting the first (#138)
  • Fix Trading.set_on_protection_remediation(None) recording deliveries that never happened: None was adapted into a no-op rather than passed through, so the drain's "nobody is listening" guard never fired and every pending remediation was handed to the no-op, counted as delivered, dropped, and given a durable ProtectionRemediationDelivered. Boot replay skips remediations with a recorded delivery, so a bracket protection that never reached Nexus was permanently marked as reported (#179)

Update

  • Update Trade-Outcomes.md for the admitted-fill contract: filled_qty, cumulative_notional and avg_fill_price now describe the same fills, so consumers may recompute the average from the totals rather than avoiding the division
  • Record TD-156 (an admitted overfill is invisible to Nexus's position and capital accounting) in TechnicalDebt.md
  • Record TD-158 (the spine persists slippage as a quotient rather than the prices it was derived from) in TechnicalDebt.md
  • Record TD-157 (a fill whose command recorded no budget is reported as nothing filled) in TechnicalDebt.md
  • Update every TradeOutcome producer to report the admitted totals — the single-shot submit path, both scheme terminal paths, the scheme partial, the three amend emissions, the bracket entry recovery, the bracket OCO exit, both flatten paths, and the immediate iceberg — replacing four separate notional-scaling clamps and three quantity-only caps. Raw totals are kept where they mean real exposure: position sizing, protection sizing, and flatten pricing all continue to act on the quantity actually held, including an overfilled excess, and the account ledger continues to book the full spend

v0.99.0 on 15th of September, 2026

Add

  • Add failure_class and venue_code to OrderSubmitFailed, distinguishing an order the venue refused from one the adapter refused before the venue saw it. The distinction already existed in the exception types — LocalOrderRejectedError exists to say the order never reached the venue, and OrderRejectedError carries the code the venue answered with — and the event flattened both into one free-text reason, so observed records concatenated a venue idempotency rejection and a local depth-walk rejection into a single sentence. Telemetry could only roll them into one bucket and an alerting rule could only branch on text, though the two want different responses: a duplicate client order id is an idempotency condition, insufficient depth is a market condition. Classified at the one construction site from the failure the caller caught, or stated outright where a caller knows the side without an exception to hand. Defaults to UNKNOWN so records written before the fields hydrate cleanly, and a failure whose type carries no side at all is left UNKNOWN rather than guessed into a bucket an alerting rule would then trust, which covers a caller with no exception to hand and the two transport failures — OrderSubmitTimeoutError and TransientError — that report a POST failing with the venue's acceptance undecided rather than a refusal. A VenueError of any other kind still classifies VENUE without a code, since reaching the venue adapter's error hierarchy is itself evidence the venue answered, and a ValueError classifies ADAPTER because rejected parameters never left the process. DuplicateClientOrderIdError is a venue refusal, and since the adapter raises it in place of the OrderRejectedError the venue sent, the code is recovered from the cause rather than lost. The bracket protective-OCO path caught its exception but did not pass it on, so threading error through the remediation is what lets that site classify like the rest rather than record an unattributed failure. The derivation lives in classify_submit_failure so every construction site records the same distinction (#182)

  • Forward execution_slippage_bps and arrival_slippage_bps through OutcomeTranslator now that the Nexus outcome has fields to receive them. Every fill-bearing outcome carries whatever its Praxis outcome held, each one a snapshot of the command to date rather than a measure of that increment: both are quotients against the cumulative avg_fill_price, and the prices behind them are not recoverable from the spine (TD-158), so no per-increment series exists to send. Forwarding on each fill is what makes them arrive at all — only the submitting path holds the pre-submission mid, so the measured outcome is typically the immediate response while the WebSocket-driven outcomes completing the command carry nothing, and holding the measure back for a later event assumes a later event will have one. A consumer wanting one number per command takes the latest measurement it received rather than the latest outcome, since an outcome carrying none says nothing was measured on it and not that the earlier measure was retracted; weighting each by its own outcome's fill_size double-counts. ACK and the terminal outcomes carry neither, the Nexus type refusing a measurement on an outcome with no fill

  • Record TD-159 (the launcher's per-account outcome queue is unbounded and has no consumer-stall policy) in TechnicalDebt.md. The queue is filled with put_nowait for every translated outcome and read at most one per tick by Nexus, and enqueueing offers no capacity backpressure, so the producer cannot learn how far behind the consumer is. Growth needs production to outrun consumption, and the sharpest case is a consumer that stops dequeuing altogether — a parked or retried outcome has already been taken off the queue and accumulates in Nexus instead, while a consumer that merely runs slower than a burst is a rate mismatch no capacity limit fixes; and the bound on command_queue covers queued commands and their admission reservations rather than the outcomes they produce. The entry separates the other runtime queues by how each is actually restrained, records that the cheapest close is making queue depth and the age of the oldest undelivered outcome visible, and notes that blocking the producer would stall the Praxis event loop while dropping is less absolute than it looks, since the spine already records every outcome and the TD-052 boot replay re-delivers unacknowledged ones

Change

  • Pin vaquum-nexus to 0afbd53 for the two new TradeOutcome fields

v0.100.0 on 4th of October, 2026

Add

  • Add a wiki under docs/wiki explaining how Praxis and Nexus work, in plain words, for a reader who cannot read execution_manager.py to find out. 115 articles, each named for its subject, opening with a sentence defining it, and listed in the index by what a reader will learn rather than by a count of it, covering the live path from a decision crossing into Praxis to an outcome crossing back; a host starting, stopping and what each leaves undone; the records kept of an order, a position and the money; replaying recorded bars and asking for a replay over HTTP; the standalone simulated venue; and the figures a run is summed up by. Terms link where they appear, and an article outgrowing its limit is split rather than lengthened, so some of them exist because another outgrew it while being made accurate

  • Add the machinery the wiki is checked against: a register carrying every topic and everything found while tracing, a ledger naming every Praxis module and marking it uncovered, partial or full, each row listing the register rows whose citations reach the file, so a module the wiki writes around rather than cites reads as uncovered, an article template, and the two commits every citation is resolved against — one for Praxis, one for Nexus. Every claim an article makes lives in its front matter with the lines it rests on — 2,372 line references across 1,247 claims, every one resolving in the tree its repository is pinned to — where the checker reads them and the reader does not

  • Add check_wiki.py, a gate that fails closed, each of its checks added after a defect of its kind had already reached a finished article. On citations: a range landing in a docstring, on a log call, or on nothing executable at all — a blank line, a comment, a signature with no body — before the first line or past the last, in a file that cannot be resolved, or in two citations sitting wholly inside opposite arms of one branch — both halves of an if/else, sibling except handlers, and a branch leaving the path against what follows it — unless the row names that pair as alternatives, the marker having to sit between them, before the row's first citation where the row declares its whole list alternative, or after the later citation where no other citation follows it, rather than anywhere in the row, so a marker in the gap ahead of a pair governs the pair it closes rather than the one it opens. A branch that only builds a message and raises is a guard rather than an arm; one that acts first is an arm, an act being any call, or an assignment to anything but a plain local. A statement holding others acts where one of those does, or where what it is given to work on does, so a guard wrapped in a try, a with, a loop or a match is still a guard while with reject(x): is not. A range holding nothing but logging, blank lines and comments is logging, whichever of them it opens on. A claim whose own subject is the logged message, or the docstring, may cite it, and that is read from the claim alone: a source calling the lines it cites a warning or a docstring exempts nothing beside it. And a reason the code does not state is refused in an article, a body never saying why. A continue reaches only to the end of its own loop. A range reaching past an arm cites the construct rather than the arm. A name carrying a directory is read as written, so a Praxis path whose last part is also a Nexus file name is read as the Praxis path it is rather than passed over as Nexus's. A source naming a file while citing no line of it is refused, unless it says in words that the file holds nothing — and the file must be in the tree either way; and a line cited with no file named before it is refused outright, there being no longer a default file for one to fall back on. A Protocol's stub signatures are exempt from the signature rule, since a Protocol states nothing else; that exemption is withheld wherever the Protocol name could have been rebound — by a replacement import, an unpacking, a loop or with or except target, an assignment expression, a match capture, a class or a function of that name, or a wildcard import. On voice: a missing lead paragraph, a lead opening with "This", a prompt heading such as ## What it is, a definition by negation, a double negative, written out or contracted, a heading naming what its section is not, a heading running on from the line above, and a heading sitting mid-line. On structure: the word limit counted over headings and prose but not navigation links, a table, a rule of dashes or the page's own stamp — each of those read as the whole thing it is rather than by what it opens on, so a paragraph opening on dashes or on the mark that parts a table's cells is prose and counted, a table's own rows counted like any other prose, no article carrying one and a reader given words inside a cell reading them as words, evidence appearing in the body, a missing metadata block, a term another article owns being first met in the prose without its link, a navigation link at the foot not counting, a broken link, a link asking for a heading in a target not written in text, a target being read only where a heading is asked of it, a name no path can hold, a name whose links lead back to where they started and a name the filesystem refuses being answered as absent rather than ending the run, a baseline that is not the pinned one, and a created stamp later than its modified one. On coverage: a ledger row naming a module absent from the pinned tree, a heading count disagreeing with that tree, a module neither named nor accounted for, and a ledger row naming rows that do not cite its file or omitting rows that do, a file no row cites having to be marked uncovered and a file some row cites having not to be. On the numbers written down: the full, partial and uncovered counts, the article count, the Nexus named and untouched counts, a file's length where one is stated, and the newest changelog entry's claim, line-reference, article and findings counts, older entries being left alone. On the set itself: a register row naming an article that does not exist, two rows naming one article, an article no row names, an article whose own row is not the row naming it, an article the index does not list, and an index entry with no article. On the metadata block itself: it is read by key and by position rather than searched, so a row identifier or a baseline standing under some other key, the keys written out of order, a key written as nothing, an evidence list written as one value, a list opening on something other than a claim, a line in it shaped as neither a claim nor a source, a claim quoting inside itself, holding a backslash, or holding a character outside the set YAML can carry — the controls at either end of Latin-1, a reversed mark, anything the standard leaves out — in a claim or in a source, a claim saying nothing, a claim carrying any number of sources but one, a claim holding the mark that parts a claim from its source, a source naming nothing, a claim or a source saying nothing in blanks of any kind, every character Unicode files as a format mark being taken off before anything is asked of what is left, rather than a list of the few such marks that had been met, a baseline that is not a commit, a row that is not a register row, and an indented line standing before the evidence, tabbed or spaced, are each refused rather than read as though they were in their place — a second source under one claim being a line the block shows and the YAML behind it does not. The row and the baseline are read from their own lines and weighed as a row identifier and a commit, so a row written anywhere else in the block, inside a claim say, is no longer taken for the one the page claims. On the stamps: a page whose last-modified runs behind its last commit, and a page holding an edit that is not yet committed while its stamp still reads what it read when committed, so a stamp left unbumped fails before the commit rather than after it. The committed stamp is what that is measured against, a file's own date counting a copy as an edit; a page committed and then edited is presented to the check in a repository of its own, so neither reading the edit nor reading the stamp it was committed with can be dropped. And a module the ledger calls full while a finding leaves a question on it — its disposition calling it a candidate, or naming a question the register still carries with nobody to answer it — the ledger reaching full only where nothing is left hanging over a module. A cited module must have a row of its own rather than sit in the grouped remainder, where its state would go unstated. A claim of a refusal whose range stops on the line before the raise that refuses is refused itself, the lines cited showing the condition and the message and not the refusal — unless the raise is cited elsewhere in the row, or the range ends on a raise of its own, the next raise after one being a second way out rather than the one cited. A register row naming an article that is not there cites nothing, rather than ending the run before the row can be reported. A row carrying an unanswered question is found by its last cell rather than matched whole, so a row written with any number of brackets is answered at once rather than holding the run up. Every cell of a finding after its claim is read for citations, a disposition carrying evidence included. On the index: an entry leaning on a term another article owns, or teasing a count it never spends — one thing as much as several, and a count written before what it counts as much as after, though one thing taken out of several is no count at all — an entry being read before the article that defines its words. On the baseline page: a commit written there that is not the commit citations are read at, the page being a reader's account of which source supports the wiki. The cases of a match statement are arms like the halves of an if, and an arm that never ends at all — an endless loop — leaves even a finally unrun, so that finally is an alternative to it, while a finally that never ends is itself running and is no alternative to what entered it; a finally that leaves takes a branch out its own way, so a return under a finally that breaks is a break — where the branch's own way out crosses that finally at all: a break or a continue bound for a loop inside the try stays in there, the loop it reaches having to hold the branch, a loop whose else holds the branch having finished already, and what follows the loop runs before the finally does. The nearest finally is read first, and the way it leaves by is what the one around it is asked about, that being the way the branch is on by then. A with leaves by the way its body does, save for a raise its context manager could swallow, and bounds a raise inside it for the same reason. A way out written inside a function of a block's own waits on a call and leaves that rather than the block, while a class body runs where it stands and the raise that is the only way out of one leaves the block, by that way and on every path the body leaves on; a loop leaves where a break cannot reach it and its else leaves, a break under a finally that always leaves without breaking itself being overridden by it and reaching nothing, whichever ways that finally leaves by, or where it is an endless while whose body leaves, a for over something that may be empty reaching what follows it; one written inside a loop of its own leaves the loop where it is a break or a continue, and the block where it is a raise or a return, though one in that loop's else carries on the loop outside it. Each row's citations and marker words are read once rather than again for every pair of them, and a row carrying more references than can be weighed in pairs is reported as that rather than weighed, so a row written with thousands of them is answered rather than left running. A range running backwards is refused before anything else is asked of it, and a line number of any length is read, one too long to turn into a number at all being answered with a line no file reaches, so it is refused for running past the end rather than passed over or ending the run. A count written with no number in it is no count, and is read as nothing rather than taken for one; one too long to turn into a number is answered with a figure nothing counted could match, so it is reported as wrong rather than ending the run, and a span of register rows beyond counting names nothing rather than every number up to it. An except* bounds a raise as an except does, but its handlers are not arms of each other: one exception group can carry several kinds and run several of them, so only the else is their alternative, and each of them is tried while anything can arrive, the kind it names being worked out against what is left of the group even after an earlier one has caught. A handler's arm is its body alone, its own kind being worked out while the handlers after it are still candidates. A block written on a line the heading runs to shares that line with what the heading works out — a condition, a kind, a pattern, read to the last line it reaches — which runs whether the block does or not, so the line is no part of the alternative, and an arm left with no line of its own is an alternative to nothing. A try's else runs where its body reaches the end, so a body that leaves skips the else and is the path itself. A handler's own ways stand beside the body's only where that body could raise at all, and a loop written so that its body never runs — a condition written out that never holds, not of one that does, an and or an or of such, or nothing written out to go over — is read for its else alone, nothing its body holds being read for a way out, though that else is read for a raise like any other block, as is whatever the loop goes over; one written so that its body runs at least once never finishes where that body always leaves; a condition or a case guard written out so that its answer is known leaves only the arm that runs to read, a case whose guard never holds being passed over and nothing after a case that always matches read at all; a comparison is weighed where each side is written out as a value of its own and the sign does not refuse the pair, chains included, stopping at the first pair that fails so that a side after it is never read; whether one thing is another is weighed only between what stands alone, two values written the same way being one object or two as the compiler settles it; what a loop goes over is read as the part an and or an or stands as, and handing each turn to anything but a plain name could raise; a value written out in full is read as that value, which leaves out a call, a name, and a set or a mapping holding what cannot be hashed, and going over what is written as something no turn can be taken from raises before any turn; an if or a match could raise only where working out what it is given could, or where the arm that runs could, a case a guard holds back and anything after a case that always matches being passed over there as well, a pattern being weighed before its guard is read, and weighing one could raise on a name it looks up; a loop written to go over what no turn can be taken from ends by the raise that takes, nothing in it running, while a loop that takes no turn hands nothing over to come apart, and an else the loop never reaches is read neither for a way out nor for a raise; an and or an or is read for raising in the parts that are worked out alone, and settles its answer only where every part before the settling one is written out; an assert is read where its test is written out so that its answer is known: a test that holds settles it, the message never being worked out, while one that fails raises the error it is for every time and leaves nothing after it to run, unless the message it carries could raise as it is worked out, which leaves the answer unknown; an arm that could raise where it stands reaches no further than such a raise would, a handler or a context manager between it and the end carrying that run on past it, and an ending that could raise as it runs bounds the arm the same way — a finally whose body could, or a with, whose own ending could whatever its body did — the handlers around such an ending being read as running after the arm whatever kind they name, since an ending that could raise without saying so names no kind to weigh them against, which loses the pair rather than inventing one — such a raise leaving the construct it came from rather than being caught by it, nothing inside that construct having a turn left either, and only where it stands inside the branch's own function; a with holding more than one manager keeps its place instead, an ending of one being swallowed by another in the same statement, which is also why such a statement can carry on whatever its body does; a return or a statement of nothing but a value written out could not raise at all, nor can such a value given to plain names, nor a raise of an error the language carries that any number of values will build and that is built as itself — a group and the errors about letters ask for an exact number, and the errors about the system around the program are chosen by the number they are given, so asking for one by name can hand back another — named plainly or called with values written out and nothing named by word, whose cause is nothing at all or such an error — the raise is then the way out it says it is and nothing more — nor a try nothing in which could raise: the kind each handler names is worked out as a raise arrives, in the order written until one catches what arrived, whether or not that handler then runs, every kind being weighed where the try takes errors in groups, and raises nothing of its own only where every kind named is an error the language itself carries, a handler of a try that takes errors in groups being refused where it names a group; a raise the handlers do not catch carries out, a handler that runs could raise of its own, and the else is asked only where the body reaches its end; names written out together take a value written out with a thing for each of them, whatever holds those things, and a starred name takes what is left over; a name given no value at all is still worked out where it is more than a name; and the handlers an arm could raise into are no alternative to it, however it leaves on its other paths, nor are the handlers around an ending that could raise as the arm leaves through it, that raise running them after the arm has gone; a handler naming a kind through anything but a plain name is read as able to run, nothing about it being weighable against the handlers before it; and a container something is unpacked into could hold anything, so it answers for nothing; a pattern naming a kind takes no more than that kind, whatever the kind is, the name being bound at the time the match runs, and weighing one could raise on that name — every alternative of an | is read for it, however wide the one after it; two arms inside one loop are alternatives for one turn, which a row citing both names as alternatives like any other pair; handlers are read in the order written: one whose every kind an earlier handler already catches cannot run, nor can one no raise of the body could arrive at — though a raise still looking for a handler arrives at any kind named through anything but a plain name, nothing about such a kind being weighable, and so does one naming no kind at all — a bare raise carries whatever is already being handled, which any handler could catch, so none of them is read as unable to run and no arm raising that way is an alternative to what follows it — and nothing after one naming every error can run either, though where the errors come in groups such a handler is still tried, the kind it names being worked out against what is left of one, so a kind that cannot be worked out raises there — and a handler of such a try naming a group of errors always does, the language refusing that pairing — a group being either of the two the language carries, unless the module gives that name something else, or a class the file writes on one of those — read by the name as written, since the class statement is the binding that makes it a group, and only where the module binds that name once: a class rebound afterwards holds whatever came last, and a scope of its own binding that name holds something else by then, so a handler inside it names no group, so its own body cannot run and nothing written after it is reached at all, while a body leaving on some paths only takes its own way out on those and the else on the rest and so names no single way; how a statement ends, and whether it could raise, is read once and kept against that statement, a nest of try statements otherwise being read again at every level and the gate stalling rather than answering; how a block ends is read as the set of ways out it has — a return, a raise, a continue, a break, or carrying on — gathered from every statement of it and from every block each of those holds, so a branch leaving two ways names neither and nothing is paired against it, while a one-sided if that returns before a later return names the return they agree on. A kind is weighed only where it is written as a plain name the file binds just once, by an import that brought the error itself — each alias an import writes counting as a binding of its own, so one name written twice in an import holds what came last, while an annotation with no value beside it binds nothing where the module carries it, though one written inside a function makes the name that function's own throughout as a deletion does, a type written out as a name of its own binds that name as a function or a class written to take a type binds it, while a class body's names are the class's own, so nothing written straight into one is counted — its methods and its own classes included, and a second import of the same thing displaces nothing: a parameter, an import, an assignment or a deletion of that name, or any name at all bound more than once — read against the scopes reaching the line it stands on, so a name one function or one class body binds leaves another scope's reading of it alone, an if, a try or a loop belonging to the scope around it while a function or a class written inside one starts a scope of its own — a deletion making it the function's own name throughout, reachable or not — leaves a handler naming it read as able to run and naming nothing another handler can be weighed against, since what it holds is not the error the language carries — and working that name out could raise as the handler is matched, so the handlers around it stand. A file holding a wildcard import has every such name kept, anything it brought in being unknowable. A raise is held with the kind it names, and a handler catches it only where it names no kind or names a kind that covers the one raised — a KeyError caught by LookupError as well as by its own name, the covering read off the errors the language itself carries, so Exception and BaseException catch whatever stands under each of them — a raise no handler of its own covers standing as a way out beside the handlers' own ways, and a kind named nowhere the language carries being left uncaught; the covering is read the same way wherever a handler is weighed — in what it catches, in what a try's handlers catch between them, and in what an earlier handler has already caught — so a citation inside a handler nothing can arrive at, one every kind of which an earlier handler covers or one of a try whose body raises nothing at all, is refused as lines no input reaches, blank lines and comments padding such a citation answering for nothing — and its own line goes with its body only where no raise reaches it at all, a handler tried and missed having the kind it names worked out even though its body never runs, a body written on that same line being kept with the kind — a citation taking in one such handler whole, its own line and a line of its body, being refused with the body, while one spanning the whole try stands — and nothing written after a handler naming every error is reached at all, neither its body nor the kind it names; a context manager may swallow a raise or may not, so both stand — and a raise the body could take without saying so, out of a call or a name or a sum, is swallowed the same way, so carrying on stands beside the body's own ways for it. A raise reaches the handlers of the try holding it even where a finally takes the way out over, the handlers being weighed by the way the branch itself leaves rather than the way it is left on. A break need not be taken, so a loop holding one can still finish and run its else, and an endless while with no way out of it at all ends by nothing and reaches what a return would, and a return, a continue or a break in the body of a try leaves as it would anywhere, whatever its handlers catch. A logging call spread over several lines is logging on all of them. The register's own findings are read as evidence rows are, so a finding citing a docstring for behaviour, a line past the end of a file, a line with no file named before it, or two lines in opposite arms fails the same way an article would; a finding whose subject is the docstring may cite it, saying so, and a figure a finding means as a figure is written in words. Each is locked by test_check_wiki.py, which presents the defect and asserts the refusal, so a check that stops refusing fails there — and the gate is read for a name nothing in it reaches, so a check left behind by the one that replaced it fails there too rather than reading as live code — and every rule the page walk runs is presented a page breaking that one rule alone, so a rule left unwired fails too. Beside those, every pair the gate offers is weighed against what a pass through the code really runs: shapes are written out from the grammar the gate reasons about, run under a line trace once for each input, and a pair one pass reaches both sides of is reported — exhaustively over the small shapes a finding has ever come from — an arm in the body, a handler, an else or a finally of each construct, two handlers of one try over every pair of kinds, two cases of one match over every pair of patterns, an arm raising a kind its own handler covers, an arm leaving under an ending that could raise into the handlers around it, an arm whose own try raises with no kind named, an arm raising a name the shape itself has taken over, and an arm holding a try that takes its errors in groups — and over two thousand written at random besides, by reachable_pairs. The gate runs on a Praxis-only checkout, where a citation into Nexus is passed over as unread rather than failed and the ledger's Nexus half is left unchecked, so every Praxis-side check still blocks on a clone that has no Nexus beside it — and such a run says so in a note of its own, so a reader is told which half went unread rather than left to assume both were read

  • Record U-03 in the register: a ladder cancelled before its first rung, reaching _start_ladder before its deadline, passes a zero slice total into the terminal emitter, TradeOutcome refuses a non-positive total, and the ValueError is caught and logged. No outcome is produced at the time. The command survives as an accepted command with no intent, so the next start classes it a boot orphan and reports it REJECTED — the caller is told, but only after a restart, and as a rejection rather than a cancellation

  • Record what the wiki is not sure about in the register rather than asserting it: that the venue feed repairs a record written off after an unanswerable lookup appears in a docstring and in no body, and is marked unverified with the docstring named. The docstring saying a schedule change is lost on restart was traced to the contrary: the change is written down, read back on resume, and the amended slice plan and gap are what the run restarts on, so the docstring is recorded as stale against the debt entry that already records the fix

  • Record 70 findings in the register that tracing turned up, each carrying where it went: into the article that states it, or into a row of its own. Among them: an endless reference_price or price passes every check on the way in and breaks later — the first in the arrival-slippage division, the second at the venue call, where the exception is logged rather than turned into an outcome, so the command has no ending until the next start rejects it as an orphan. A timeout that is a floating-point NaN or infinity passes the same way. _require_str rejects only falsey values, so a list or an integer reaches a stored command's trade_id or symbol intact. A Scheduled VWAP amend naming weights is refused at the handler before its interval is read, losing both. A fill whose commission was charged in a third asset leaves the order record and the ledger disagreeing. And a replay's starting capital is truncated to a whole number for sizing while the report scores against the exact figure

Change

  • Pin polars below 2.0 in pyproject.toml. polars 2.0 drops the memory_map argument from read_ipc, which arrow_price_store.py and load_replay_bars.py both pass, so a resolver free to take 2.0 fails 27 tests and the type check on code written against 1.x. The pin states what the call sites already assume; moving them to 2.0 is its own change

  • Group the wiki index for a reader rather than by the order it was written in. Two thirds of the articles sat under one heading taken from a register package name, so that group held whatever had been written at the time — starting a host, credentials, logging and the event spine were all filed as vocabulary — while real groups starved at one or two entries. The index now opens by saying what Praxis and Nexus each do and names five articles to read first, groups every entry under a heading a reader would look under, and closes by saying the wiki is about Praxis and where to look for a subject it has no article for. Articles filed where nobody would find them moved: a part-shown order is one send rather than several, an abandonment is a request a caller makes beside a change, a deadline covers a single order as well as one spread out, and the bars a strategy is priced against have nothing to do with a replay. The two groups that had grown to twelve and thirteen entries split by subject, and the pass that takes work off the queues now follows placement, which is where it happens. Thirty-seven entries that read as a sentence lifted from the article — "one ground", "nought", "step series", "the gap it works out for itself" — say what the reader will learn instead

  • Refuse an index section named after a register package. The register sorts the work into packages, which is the order it was written in rather than anything a reader wants, and a package name standing over a group of entries is that order leaking into the index — the group under it then holds whatever was written at the time

v0.101.0 on 13th of October, 2026

Add

  • Make the stale-disposition class a blocking check in the wiki gate, the class having now been corrected twice: a harvest row's disposition is the row's own note about what became of it and the merge table of the same package supersedes that note, so _settled_candidates reads both and fails on any row still reading candidate where its merge row says promoted, merged, folded or declined, while leaving alone a row that agrees with a merge row queueing it as its own candidate — the line between a contradiction a check may judge and a judgement it may not. Survey it against the register as it stands first: one thousand six hundred and fifty-three harvest rows, one thousand five hundred and sixty-one merge rows, one thousand five hundred and sixty in both, and none reading candidate against a settling merge row, so the check fires nowhere on clean text. Fix three tests the two corrections had broken: one took a row settled by the hundred and eighty-seventh package as its example of an open candidate and had been failing since, and two borrowed a real open row through a helper that skips when none exists, so both began to skip once the hundred and eighty-ninth package left none — leaving the check they exercise untested while reading as passing. All three now build the open row they need in a copy of the register, and the borrowing helper is gone. 710 articles, 11,576 line references across 5,128 claims

  • Correct the last four harvest rows whose own disposition had been superseded by the merge table a few hundred lines above them, each reading candidate since the first Nexus package although that package records one merged into the article on the checks a decision passes, one split out to the article on what a check must answer with, one promoted as the reason a refusal has something to give back, and the fourth — a genuine candidate when it was written — since covered twice over by the article on the roads around the checks, which cites its lines line for line. They survived because the check that refuses a module reading fully accounted for while a candidate stands on it reads only the Praxis side of the ledger, so nothing ever objected to a Nexus row. No row of the register's one thousand six hundred and fifty-three is now open, and no question is left unassigned. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles that answer the last two open questions as far as the wiki can, and with them every Praxis module reads fully accounted for: the one asset a commission is netted in, a buy's commission taken out of the holdings it adds only where the fill is a buy and the fee was charged in one named asset so a buy of any other symbol is credited at its gross size and the holdings would sit above the wallet by the commission on every such buy — the compounding gap the netting exists to close — reachable only past the money record's own refusal of any symbol but one, which is raised where a fill is booked and swallowed there, so a second symbol would show as a quiet drift rather than a stop; and the call-off a ladder hears as a refusal, a ladder whose cancellation arrives before its first rung ending there with a report built on a count of parts of nought, which the outcome's own type refuses, the raise travelling out of the instruction's handling and being swallowed so no report goes out at the time, the instruction left accepted with no intent and no work standing for it — exactly the shape the next boot reads as an orphan — and refused there, so the caller hears the call-off late and carrying the wrong word. Both questions now name the article that states their path, and what remains of each is a decision for Praxis rather than a gap in the wiki. 710 articles, 11,576 line references across 5,128 claims

  • Close the last ledger cell the wiki's own work can close, which needed no article at all: the harvest row recording that the checks a decision passes run in a configured order rather than a fixed sequence had carried candidate as its disposition since the first Nexus package, although that package's own merge table records it promoted and the article it was promoted into cites the same lines line for line. The stale word held a cell: the stage list has every one of its seventy statements cited and stood partly accounted for only because a check reads the harvest rows and will not let a file with a candidate on it stand as fully accounted for. All sixty-four Nexus modules that carry a row are now accounted for in full, and the three Praxis modules left are held by two questions rather than by any missing article. 710 articles, 11,576 line references across 5,128 claims

  • Write out the part that drives orders, the largest module on either side, which has been marked partly accounted for since the ledger existed: of its two thousand five hundred and four statements, two thousand four hundred and twenty-two are now cited by a claim in an article, and the eighty-two that are not are the three kinds no claim may name — sixty-seven log calls, since a log message is a claim about what happens rather than the happening; thirteen insistences, since a reader cannot tell a believed invariant from an enforced one; and two bare re-raises, each already accounted for by the claim covering the guard it sits in — recorded as an exclusion with its counts so a later reader can test it by counting. The cell stays partly accounted for all the same, and the ledger now says which kind of partly: a question hangs over it, as over the two other Praxis modules left, and none of the three waits on an article. Widen the claims of twenty-six articles over the module's last three thousand lines, and record what the sweep's six packages turned up besides: the two constructors, the draining of an account's outside events, the target a closing instruction is given, how a remediation reaches Nexus, and what a part that cannot be sent does to the work. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on telling Nexus about a position left uncovered and on a part that will not go out, with the fourth package of the sweep: how a remediation reaches Nexus, nothing handed on at all where the manager was built with no way of handing one on, the remediations waiting for that one account gathered and the rest left where they are, each handed on in turn with a failure leaving it waiting while the walk goes on so one unreachable Nexus does not hold up the others, and a success recorded as a delivery with the remediation dropped from those waiting — the record being what survives a restart, since a replay gathers the deliveries already recorded and remembers again only the failures none answers for; and what a slice that cannot be sent does to the work, the failure recorded against the instruction and naming the order that could not be sent, the work frozen only where no hold stands on it already so work already held keeps the hold it has, its next run time forgotten whatever hold it carries which is what stops another part being due, and a partial report then going out carrying the reason while the instruction stays live for a call-off, a change or its deadline to end. Widen the claims of fifteen articles, so that no statement in the module's first eight thousand lines is left uncited that a claim may name. 710 articles, 11,576 line references across 5,128 claims

  • Add an article on what target the closing command is given, with the third package of the sweep: the instruction a hand-placed close settles under carrying the whole position as its target even where the close goes out for a part of it, because both the protective pair's fills and the close's own are counted under that one instruction and an outcome whose filled figure stands above its target is refused outright — so a closing instruction targeting only the remainder could not have its report built at all — the target read from the budget already recorded for that instruction where one stands and from the size being closed where none does, and the instruction itself a plain market order carrying the entry's trade and timeout and nothing of its way of working. Widen the claims of sixteen articles over the module's next two and a half thousand lines, so that no statement in its first six thousand six hundred is left uncited that a claim may name. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the prices a protective pair goes out with: the test both protective prices must pass, a long's take-profit having to sit above the price the entry actually filled at and its stop below it with a short's the other way about, so a pair that was sensible when the trade was asked for can fail here because the entry filled somewhere else, and failing it closing the entry out as unprotected at first placement while on a change it answers nothing and the change is refused with the pair already resting left where it is; and what the venue's tick does to a protective price, a price named outright used as named, one given as an offset worked out from the entry's average and floored to a whole number of the venue's ticks with the direction of the offset turning on the side of the entry, a symbol whose venue sizes are not held having its price left exactly as it was — the one road by which an unfloored price reaches a venue — and the stop's own limit price passed through as given at first placement but floored on a change, so the same figure can reach the venue raw the first time and floored the second. 710 articles, 11,576 line references across 5,128 claims

  • Add an article on draining an account's outside events, the second package of the sweep closing the part that drives orders: three queues drained in turn — the events waiting to be taken in, the news from outside, then the work to be reacted to, since an event taken in is recorded before it is reacted to so draining one and not the others leaves a picture that lags what the account has been handed — one round being all the account's worker asks for while a boot asks for empty and the round then repeats until none of the three holds anything, because reacting to one event can hand in another a single round would leave behind, and the call a boot makes draining only for an account marked as booting, a mark that is an ask of its own and is cleared when the boot finishes. Widen the claims of twenty articles over the module's first four thousand lines, so that no statement there is left uncited that a claim may name. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the two constructors of the part that drives orders, beginning the sweep that will close it: what the manager is built holding, ten things handed in — the record of events and the epoch it writes under, the venue's adapter, the slippage cap, the modes it may drive, the ways an outcome and a remediation are handed on, the clock, the answer to a lost protection and the deadline a restore waits out — each kept as handed over except the modes, which are kept with the plain single order always added and not kept at all where none are named, the host handing in all ten, two of them replaceable after the building so a host can exist before the thing that listens to it, nine stores made empty beside them and the remembered loop thread starting absent; and what an account's runtime is built holding, six things handed over — its name, its three queues, its trading record and its money record — two further queues made fresh so no two accounts share them, the live work, live trades, change counts and changes still owing all starting empty, two counts starting at nothing with a wake-up unset and a protection scan unrequested, and four marks about where the account stands all starting false. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on taking an instruction in and on the closing half of a bracketed trade: what a command's acceptance leaves behind if the queue is full, a place reserved before the acceptance is built, the acceptance recorded durably and the instruction only then put on the queue, a full queue having the acceptance and any call-off standing against it forgotten and the instruction refused, the reservation given back whatever happens, the instruction otherwise installed with its trade remembered, the acceptance applied to the trading record directly rather than by the routing that poisons an account on failure so a failure there fails one instruction and leaves the account able to take others, and an account parked by a failed startup refused before any of it; and what the closing side of a bracket is given, a command name of its own worked out from the entry's, an order name for the pair with a fixed place, an instruction of its own built for the protective side and a budget recorded against it, the intent naming the closing command rather than the entry's which keeps the pair's fills out of the entry's totals, the protective side being the opposite of the entry's with the three prices worked out from the entry's average, and the trade marked as having had its protection placed before anything is sent — the mark the boot's own pass reads to pass one over. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on reading a change back and on the order of a remediation's writes: how a replay works out where a ladder's change had got to, a change that started remembered with its phase at cancelling, a plan recorded for it moving that phase to placing and keeping the start beside it, a state-unknown setting the phase to whichever the record carried so a halted change comes back at the step it halted on, a completed change recording the generation with the settings from its own start and the size from its plan — and only where that start was found in the window read, a completion whose start fell outside it leaving no completed grid so the resuming falls back to the first grid — the size standing at nought where no plan was found, and a completed change and an abandoned one both forgetting the change in flight; and what happens before a lost protection's close is attempted, the version lifted to the first where it stands below it, the account's other work frozen, the failure then recorded, the trade's standing then moved to failed, the remediation remembered against the account, the close attempted only where the account's settings answer flatten-then-halt, and the remembered remediations drained last. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on an account that can no longer be trusted and on a change that stopped halfway: what poisons an account, four failures setting the mark — applying a piece of outside news, applying an event a recovery owner admitted, the account's own loop dying, and a failure while ending an instruction left on a dead account's queue — each a failure of the machinery that keeps the account's picture of itself true, which is why none is retried, the task being stopped let through on all four roads so shutting an account down does not poison it, a poisoned account refusing an event, refusing to record and apply one, refusing an instruction and no longer counted able to carry orders, its waiting news taken off the queue and dropped unapplied, and the mark only ever set and never cleared so the account comes back only with the process; and what picks a stalled ladder change up again, the pass ending for an account the manager does not hold, a copy of the account's live work walked, work with no phase written or no context held passed over so both marks have to be there, and the driving the scan calls doing nothing where the context is gone — the context read once by the scan and once by the driving. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on advancing a schedule and on reporting a call-off: what moves a scheme on to its next part, the part at the cursor sent with its size taken from the plan at that place, a send that answers nothing freezing the work and ending the pass with the cursor where it was, an order not already ended joining the live list the settling reads, the cursor then moving on by one with nothing about the fill consulted so a part that filled nothing advances the schedule exactly as one that filled in full, the next run time set a gap ahead and progress recorded where parts remain, the next run time forgotten where none do with progress recorded only while live children stand so a last part whose order has already ended writes none, and the settling attempted at the end of every turn; and when a call-off goes unreported, the call-off recorded and applied with its reason before any report is worked out, the figures taken from the admitted totals with an average price only where something has filled, and the trade's name looked up to carry the report so an instruction with none remembered reports nothing at all — the order called off at the venue and in the record, with Nexus hearing none of it. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on a protective pair that cannot be confirmed: what rescuing a protective pair by its list name answers, the list asked after by the name it was sent under with three roads answering nothing — the venue not knowing the list, the asking failing, and the list reported refused — so the caller cannot tell a pair the venue turned away from one it could not ask about and remediates the entry as unprotected either way, a list reported as having all its halves done having its standing worked out from those halves, anything else standing as open, and the answer carrying the venue's own list name, the standing just settled and the halves' names but no placement fills since whatever the pair filled arrives by the halves' names instead; and what hearing a protection has ended does, a state-unknown recorded under the standing version or the first whichever is greater, naming the pair's current name as both the old one and the new, and only after that record goes down is the trade's standing moved to unknown and the moment stamped — the record being what a restart reads to rebuild a trade in doubt — with a scan over protection then asked for. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on what a restart rebuilds and what it owes: what a scheme's settings are rebuilt from, an equal-slice schedule rebuilt from the count of parts and the gap between them which are the whole of such a schedule, a weighted one rebuilt from the gap and the weights the start recorded and taking no count of parts at all since the weights are one per part, any other mode refused as not resumable with the mode named in the refusal, and all three figures having been recorded on the start itself so the instruction that asked for the work can be gone and the schedule still come back as it was; and the entry report a restart makes good, the replay putting an entry's fill back into the record without sending the report that fill would have caused, so the restart sends it — only where the entry order has ended and filled above nothing, an instruction already marked ended passed over since its report went out before the crash, the trade taken off the live list before the report is made so a second pass finds nothing to make good, and the status filled where the target is reached and part-filled otherwise with no third arm, since nothing-filled cannot arise on a road reached only once something has filled. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on stopping the parts of work fed out over time and on reporting an instruction a restart cannot carry out: what calling off a scheme's children leaves behind, a copy of the live list walked so the set itself can change as the walk goes, a name the record holds no order for coming off at once, a name whose cancel the venue confirmed coming off once the call-off is written, and a name the venue does not know or whose cancel failed any other way staying on the list to settle through its own fill or expiry — the list standing non-empty being what keeps the work from being settled, since the settling runs straight after the calling off and does nothing while a name remains; and what a boot's rejection of an orphan says, one moment taken and carried into both the record and the report so the two agree about when, the record saying refused with the boot's own reason and the instruction marked ended as it goes down which keeps every later report for it from being made, and the report naming a stand-in target of one, nothing filled, no average price and nought parts done of one, because the instruction's own size, side and manner were never read. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on bringing ladders back after a restart, written as two because one ran past the word cap: which ladders a restart passes over, an instruction with an ending already recorded passed over since the ending is the last word, one whose latest state is anything but running passed over with a state the replay never saw read as running so a ladder that only ever started is resumed, a start naming fewer price levels than the least a grid may have passed over, a start that will not rebuild into an instruction passed over with the malformed start named, and the deadline worked out from the start's own moment plus the timeout it carried with none at all where that timeout is nought or less; and what a resumed ladder's grid is taken from, the generation, settings and size of the live grid coming from the last change that completed and from the start itself where none did, a ladder with a change in flight resumed through the change's own resumption instead, the resting rungs found by walking that generation's grid by name — which is why the generation has to be right, a walk of the wrong one finding none of them — the place in the plan set to how many were posted, and an ending still owing and a drain still owing its call-offs carried onto the rebuilt work. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on what the venue's news reaches and on a restart's second attempt at a close: which news makes a report, only four kinds considered at all — a fill, a call-off, an expiry and a refusal — the order looked for among the live orders and then the closed ones so news arriving after its order closed is still found, news neither set holds making no report, news whose instruction has already ended making none, news whose instruction belongs to live work fed out over time making none since that work reports for itself and a report per part would say the whole instruction had done what one part did, news naming an order the instruction no longer points at making none since an instruction points at one order at a time, and what survives reported from the admitted totals with an average price only where something has filled; and what a boot's re-flatten does before it sizes, the trade rebuilt in memory with the entry's name worked out and the account's waiting news drained to empty before anything is sized so news that was waiting counts towards the figure rather than arriving after the close was sized, an account poisoned by that draining abandoning the recovery, and the close re-attempted with the names the pair could still rest under and held to the same test as a live one, asking after each before placing anything. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on answering a caller and on sending one rung: what a caller waiting on an admitted event is told, the event recorded and applied with a place given having it queued for reacting to and the caller told that place, which can be nothing at all where the record took the event as one it already holds so that nothing means admitted before rather than turned away, the writer being stopped mid-drain telling the caller the writer stopped and letting the stop travel even where the recording already took so the event stands for a restart to find, any other failure told to the caller as it stands with the drain going on, and a caller who has stopped waiting told nothing while the count of events in flight is lowered on every road; and what sending a ladder's rung writes, the rung's name carrying its place in the grid and the generation it belongs to so a rung of a new grid never wears a cancelled rung's name, one moment taken before the send and carried into the intent which is recorded and applied before the venue is called, a second taken after the venue answers and carried into the record of the send so the pair measures the call, three ways of answering nothing — a rescue that found nothing, a venue failure, and params the adapter refused — each recording the failure, and each fill given as the rung was taken recorded with only one the record answered with a place carried into the figures. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the beginning and the end of work fed out over time: what stops a scheme before its first slice, the count of parts and the gap between them read from the settings first, a call-off standing against the instruction taken off the waiting list as it is read — which is what keeps it from being applied twice — and ending the work as cancelled with nothing filled, the venue's lot step used only where the venue's sizes are held so a host without them plans parts not snapped to the venue's steps, a planning that refuses ending the work as rejected and carrying the refusal's own words so what it objected to reaches Nexus, and the start once recorded naming the number of parts actually planned where both refusals report the number asked for; and what is cleared before a scheme's ending is written, the next run time forgotten, the live children cleared and the work taken off the account's live set — that last being what stops another part firing, since the live set is what a pass over due work walks — all three before the ending is recorded, the figures then gathered from the admitted totals and the terminal report made, so a failure in any of that writing leaves work that fires nothing and reports nothing with its ending unwritten. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on asking the venue about a protective pair and on an order that hides most of itself: when a protective pair counts as still protecting, the list asked after by its name with a list the venue no longer knows, one it reports as refused and one whose halves are all done each answering that nothing is protecting, a working list answered with rather than merely confirmed so its halves can be followed again by the names the venue gives them, and only the venue's not knowing the list caught there so any other failure travels to the watchdog that asked, which remembers it and tries the next name; and what a hidden-size order shows the venue, the display size carried only where it falls below the whole size and left out otherwise so the order rests as a plain limit, the order's name worked out with a place of nought since the instruction has one order and no more, and the intent naming the whole size and no spend, recorded, applied and mapped to the order's name before anything is sent, so the record holds the order under the name it will be sent with before the venue knows of it. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on reacting to news and on reporting a changed instruction: what a failure reacting to an event costs, an event taken at a time for as long as any remain with an account marked poisoned having every remaining one taken off and dropped unreacted-to so the queue empties either way and only the reacting is skipped, each event driving three reactions inside one guard — the report Nexus hears, the owning scheme's advance and the owning bracket's drive — the task being stopped let through while every other failure is swallowed and the drain goes on, so a report that cannot be sent takes the advance and the drive down with it for that one event, nothing retries them, and what they would have done is reached, if at all, by whatever the next event drives; and what status a changed command reports, worked out from how much the instruction has filled in all across the order superseded and the one replacing it since the replacement's placement fills are recorded under the same instruction, the target reached reporting filled, something filled reporting partial and nothing filled reporting pending, an average price worked out only where something has filled, and the report carrying no reason at all. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the end of a protection change: what a finished protection change leaves on the bracket, the fills the venue gave as it took the pair recorded against the closing command with only one the record answered with a place carried into the figures, the pair recorded active and then the trade's live pair name and its three current prices written over and the standing moved to active, the four figures the change was parked with having been cleared earlier so that between the clearing and the writing over the trade still names the old pair and carries its prices, and a replacement the venue reports as already ended stopping short of all of it with the new name written and the standing left unknown while the prices stay as the old pair's; and what a failed protection replacement is looked for, a send that fails for any of three reasons followed by asking after the pair by the name it was sent under, an asking that cannot be answered leaving the standing unknown and remembering that name as one still owing, an answer saying the pair is nowhere having the trade closed out as unprotected with both names handed over as candidates, and an answer finding the pair treating it as the send's own under the venue's list name and the halves it reports — carrying no fills given at placement, where a send that answered carries whatever the venue gave. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on protection the venue will not confirm: when protection in doubt is remediated rather than waited on, a trade carrying no moment the doubt began at left alone since nothing on that road stamps one, the wait measured from that moment against the restore deadline with a wait short of it ending the pass so the trade is looked at again until the deadline passes or the asking settles it, what is left open being the entry's delivered figure less what the closing command has filled with nothing left open meaning nothing done, and both figures being the record's own because this is the road taken when the venue could not be asked; and how much a cancelled protection pair filled, the list asked for by its name with each half asked after in turn and the halves' figures summed, nothing there catching a venue failure so one reaches the caller and becomes the pair's standing turning unknown with the change halted for the watch, so the figure is either the venue's in full or there is no figure and no change — the same two questions asked to find out whether a half is still working answering a failure as a half still working instead, each answer going on to a different use. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the one thread work may be handed in from and on writing a command's budget: which thread the manager will take work from, the thread remembered the first time an account is registered and only the first time, both ways in — handing news to an account and admitting an event — refusing a call from any other thread and refusing an account the manager does not hold, news that passes both readings put on the account's own queue without waiting, which is the reason the rule exists since that queue is safe to put to from one thread only, and the window before the first registration in which a reading against nothing refuses nothing and both ways in stand open to any thread; and what a second budget offered for a command does, a budget naming neither a size nor a spend not recorded at all, one offered where none is held written under the command's name, and one offered where a budget already stands dropped with the first kept — the budget being read back by the figure that caps a fill before the fill is counted and the recording revising no total it finds already counted — with a differing second budget reported only where the caller asked for conflicts, which one road of the four does, so a replay offering a second budget keeps the first without a word. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on giving up a change and on the figures a replacement carries: which way a ladder's change is given up, one reading settling it — whether a cancel has ever been committed to the venue — where none has the abandonment recorded and the phase and context both forgotten so the old rungs stand whole and the ladder carries on as though no change had been asked for, and where one has a state-unknown recorded instead with the phase written back and the context left standing, which is what keeps the change on the road a later pass drives, the commitment itself marked the moment a resting rung is found and before any cancel is sent, and a change that survives a restart coming back with it already made; and what figures a changed order's replacement is given, read against the instruction figure by figure so that what the change names is used and what it leaves out is taken from the instruction as it stands, an order showing part of itself settling its price and its shown size that way and answering with both, a plain resting order settling its price the same way and answering with no shown size at all rather than leaving the placing to work one out, and each road insisting the instruction's own settings are of the kind the change is. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on changing a ladder's grid: how a ladder's change moves from one phase to the next, a change with no context left on the work doing nothing at all and one held for draining handed to the draining, the new grid's settings rebuilt from the context on every pass, the retiring phase taking the old rungs down with a retiring that answers nothing ending the pass and leaving the phase as it was, the remainder worked out from the figures the retiring answered with and the new grid planned against it, a plan with no rungs in it finishing the change there, and the placing phase tested after the retiring one rather than instead of it so a pass that has just retired goes straight on to place while a work held for protection places nothing and leaves the phase where it is; and what finishing a ladder's change adopts, the completion recorded before anything is adopted, a fresh instruction made carrying the new grid and installed under the name the old one had so anything still holding the instruction as it was keeps the old grid, the generation promoted to the one just placed, and the phase and the context both forgotten — the forgetting of the context being what takes the change off the road a later pass drives, since that pass does nothing for work whose context is gone. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on where an event is written and on a report that changes nothing: which record an event is booked into, a registration or a movement of funds reaching the money record and going no further while an alert that the venue's figures and Praxis's disagree is booked nowhere and advances neither picture, every other event advancing the record of the orders with a fill also reaching the admitted totals kept for its command and the money record and a closed trade the money record, and a failure booking into the money record swallowed where it happens so that record can fall behind while the orders carry on and nothing on the trading side is stopped or told; and what a partial report of a scheme leaves standing, its figures the admitted totals kept for the command rather than what the venue filled with an average price only where something has filled, the count of parts reported being the scheme's own place in its plan, one moment taken and carried into both the report and the record of it, and the terminal report of the same scheme marking the command ended, dropping it from the live commands and from the aborted ones and recording the trade closed where the fill closes the position — none of which the partial report does, so a scheme can report over and over as it fills and leave the command exactly as live as each report found it. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the event that fixes how an account's costs are counted: when an account's registration is written, attempted on every startup straight after the replay with one reading deciding the whole of it — whether the account's money record already names a method — a name the manager does not hold refused outright, the registration otherwise going down in the record of events and reaching the money record only where that write answered with a place, and the reading mattering because the money record refuses a second registration while a refusal raised as an event is applied there is swallowed, so without the reading a duplicate would go down and the only sign would be a line in the log; and the registration a pre-account history is given, the replayed events sifted for the four kinds that book into the money record and a registration naming the default method applied there where any were found and none of them is a registration, applied to the money record alone with nothing written to the record of events so it lives in memory and is made again on the next replay, which is how such a history ends up with a registered money record and no registration recorded. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the questions put to the venue between taking an order down and putting another up, and on the record a hand-placed close leaves: what an amend asks the venue before it replaces, the cancel going out first with nothing of its answer kept, a cancel the venue has no record of passed over and one failing any other way answering nothing, the order then asked after with that answer being what comes back and the figure the replacement is sized against read off it, an asking that cannot be answered answering nothing too, and the same nothing stopping one caller — the change abandoned and the order left resting — while the other passes it over for a later pass; and what is written down when a flatten goes out, the intent recorded and applied before the send so the order exists in the record before it exists at the venue, a venue failure first put to a rescue by the order's own name with one that finds nothing recording the failure and ending there and one that finds the order standing in for the send's answer, the closing command installed with its trade and its order's name only once an answer is in hand so a recorded failure installs no command at all, and each fill the venue gives as it takes the order recorded against the closing command with only one the record answered with a place carried into the figures. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on closing the gap in a cancelled protection's count and on the marks a change to one leaves behind: how a protection's fills are brought up to the venue's figure, nothing asked where that figure is at or below what is already counted, the names of the pair's own halves taken as the set a trade has to match and the venue's whole trade list for the symbol asked for with a failure to answer holding the change, a trade outside that set passed over and a matching one written down against the name the record keeps locally rather than the half's own so both halves' fills land under a single name, only a fill the record answered with a place counted towards a total that starts at what was already counted, and the answer being whether that total reaches the venue's figure, falling short holding the change exactly as a failed question does; and what a protection change writes on the bracket, the version it carries one past the version standing with the replacement's name worked out from it as a retry number, the request recorded before the version goes on the trade and the standing moves, the cancel's refusal leaving the standing unknown with the moment stamped and its confirmation moving the standing on, the replacement's name and three prices then parked on the trade and read back off it by the driving rather than handed to it, and those four cleared on one road only, once the replacement's send has been recorded, so every ending short of that send leaves them standing. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the question asked before a position is closed by hand and on the scan that drives a halfway protection change on: how a cancelled protection pair is judged still working, the pair asked after by its list name and each half that list names asked after in turn with the first found at an unended standing ending the asking, a list the venue has no record of answering that nothing of the pair is working as every half at an ended standing does, a venue failure anywhere in the asking answering the opposite so that a question the venue will not answer stops the close exactly as a half found resting does, and the asking being done before the position's remainder is even counted; and what picks a held protection change up again, the pass ending for an account the manager does not hold and otherwise walking a copy of that account's trades, a trade carrying no stamped moment passed over so that the stamp alone decides which are picked up and how far the change got is never read, each one driven again with nothing given for the cancelled pair's venue name and the name recorded against the old pair standing in for it, and the stamp going on the first time the old pair's fills will not reconcile, coming off once they do, and cleared by the one road that leaves the change halfway, which hands that trade to the watch instead. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the order a protection in doubt is asked after in and on numbering a new grid: which order the watchdog asks about first, the replacement still owing asked about before the protection the bracket holds because an amend that placed its replacement leaves that name the likelier of the two to be working, a name standing in both lists asked about once, each candidate asked after in turn with the first found working ending the asking and re-activating the protection, a venue failure on one candidate remembered and the next tried all the same with that memory consulted only where no candidate was found working and deciding between remediating the bracket as unconfirmable and resolving it as confirmed finished; and how a new ladder grid is renumbered, each planned level that clears the venue's least amount and least sum at its own price numbered by how many cleared before it so the numbers run without gaps however many were dropped, which matters because a rung's name is worked out from its number and the walk that finds the rungs again runs from nothing upwards, so a gap would end that walk early, with a remainder at or below nothing planning no levels at all and a host holding no venue rules letting every level through. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on replanning a schedule and on a protection that fills as it is placed: what a scheme's change replans, a scheme held for protection or draining reported and the change dropped, one already owing a terminal answer dropped, a volume-weighted change carrying weights dropped, what is left to fill taken as the command's amount less the raw projected fills and what is left to do as the new count less the cursor — either able to drop the change, so a scheme that has filled its whole amount cannot be given a new schedule even with slices unfinished — a changed slice count replanning the remaining amount over the remaining slices against the venue's lot step with a replan that refuses leaving the schedule as it was rather than failing, and the replanned amounts replacing only the part of the plan the cursor has not reached so slices already run keep the amounts they ran with; and when a protection fills as it is placed, each fill carried back by the venue's answer written and applied only where the write answered with a place, the protective order then read back from the account's own state so that what it says reflects those fills, an order found already terminal having filled something having the exit's outcome built from the admitted totals, and the prices, the entry price and the word active all set before that read — so a protection filling at once is recorded live and then given an outcome. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on settling an entry and planning a grid: which figures settle a bracket's entry, two sets read — the order's own raw fills and the admitted totals — with the raw figure deciding whether the entry filled at all and supplying the average entry price the protection's legs rest on, and the admitted figure deciding whether it counts as filled or part filled against the command's amount and supplying what the outcome carries, so one entry can be reported part filled while its protection is sized from a larger figure, an entry that filled nothing ending with its order's status turned into a trade status and a rejection standing in for any the mapping does not hold, and the bracket taken off the books before anything is weighed with the protection placed only once the outcome has been built so a failure placing it cannot unsay the entry's outcome; and what a ladder's start plans before it posts, every level worked out from the parameters, the whole amount and the venue's lot step — nothing standing in for the step where no rules are held — a planning that refuses ending the command as rejected and naming the count of prices asked for as its slice total since there is no planned count to name, and the start recording the planned count and nought as its interval, written and applied before the live ladder is built. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on recovering a flatten and naming a change: which failed protections a boot re-flattens, the pass ending for an account the manager does not hold and for one whose settings answer anything but flatten-then-halt so that a deployment answering otherwise never re-flattens whatever its record holds, one walk gathering the bracket starts and the protections reported failed, each failed one having its flatten's name worked out from the mode, the command and the flatten's own place, a flatten already ended having filled something passed over, a failed protection with no bracket start recorded reported and passed over, the venue asked about the flatten with a name it is unaware of read as nothing and any other failure left for a later reconcile, and a flatten the venue says filled something reconciled rather than re-sent; and how a single order's amend is named, a command with no order or whose order is anything but a resting limit reported and the change dropped, the new price and part-shown amount worked out from the command and the change together so that naming one keeps the other, a change yielding no price dropped, and the replacement order's name worked out from the mode, the command and a count of that command's amends raised by one — the count being what makes the names of a twice-amended order differ. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on hearing news and on ending a fed-out order: how a bracket's news is told apart, news of the wrong kind dropped, news naming an order found in neither the live nor the closed orders dropped — looking in the closed ones too being what lets news arrive after an order has been moved aside — an order whose status is not terminal dropped so that only an ended order reaches anything, a leg's news turned into its parent list's name and the brackets searched for one whose protection carries that name and reports itself active so the protection is tried before the entry is considered at all, and the bracket taken out of the account's brackets before its entry is settled so that placing the protection puts it back and a failure in between leaves none at all; and what ending a scheme forgets, one moment taken and carried by the outcome handed on, any closing record and the outcome written down, the command's whole amount carried as the target whatever was filled, and the command marked terminal, dropped from the held commands and cleared of any abort noted against it — all before the outcome is written down, so that in between it is finished and held nowhere with nothing yet recorded about how it ended — while a scheme that filled something and closes its position has that closing recorded ahead of the outcome causing it. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on settling a protection and retiring a grid: how a protection in doubt is re-confirmed, an order the account's own state holds nothing for reported and the re-confirming abandoned so the bracket stays in doubt for the next pass — a submission written for an order absent from the state would apply to nothing and leave the legs' fills with nowhere to route — the exit command pointed at the confirmed list before the submission is written down, the bracket itself pointed at it only after the record says the protection is active, and the version recorded being the one already held so that whichever candidate turned out to be working is filed under the version it belonged to; and what retiring a ladder's old grid counts, each rung reached by working its name out again from the mode, the command, the rung's place and the old generation, a name the account holds no order for passed over, a terminal rung's fills added to both running totals and its name taken off the live children, both a cancelled rung and a resting one marking the change as having committed its cancel — the resting one before anything is sent, so the commitment rests on what is about to be attempted rather than on what the venue confirms — a rung the venue has never heard of passed over in silence, any other venue failure halting the change in its cancelling phase rather than aborting it, and a cancellation recorded only where the state holds the rung. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on carrying a change through: how an amend's replacement order goes out, a part-shown amount carried only where it was given and stands below the remainder, one moment taken for the intent which is recorded before the send, and every failure reporting the change as failed as well as the send — a rescue that finds nothing recording both, and a venue failure and a parameter the adapter will not take handled as one branch doing the same where a fresh slice keeps those two apart and reports only the send — with the submission recorded under the answer's own moment and the command's own description rewritten to the amended price and part-shown amount only once the venue has taken the new order; and what a parked amend is retried against, the parked changes walked over a copy so entries can be dropped as the walk goes, one whose command the manager no longer holds dropped and passed over, the old order cancelled and asked after in one step, an order the venue answers nothing for or whose status is not terminal leaving the change parked so that it waits on the venue agreeing the old order is finished however many passes that takes, and a change dropped from the parked ones only where driving it on answers that it finished. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on changing a ladder and on activating a bracket's protection: what a ladder's change is refused for, three refusals reading the ladder's own state — an amend already in flight with the phase named, a ladder held for any reason at all, and a command whose own parameters are not a ladder's although the change's were, which can only arise because a change is routed by its own shape rather than by the command's mode — and a fourth found by taking the new prices and weights from the change where it gave them and from the command where it did not, so a change naming only prices keeps the weights it had, then building that pair once purely to see whether it would be refused and throwing the result away; and when a bracket's protection becomes active, the submission written to the record and applied before the bracket is told anything about it so that the record holds the protective order while the bracket still names none, the order's name, the average entry price and the three protective prices all set before the protection is called active, so nothing reading the bracket mid-way sees it active with its prices missing, and the mark saying its protection was placed having been set long before the pair was even built. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on admitting a command: what a queue reservation is for, the queue's capacity weighed as what it already holds plus the reservations standing against it so that two commands admitted at the same moment cannot both be told there is room, a reservation taken past that test and given back whatever happens afterwards, the acceptance recorded while it stands with a failure writing that record undoing both the acceptance and any abort noted against the command before passing the failure on, an account that fail-stopped or failed its startup during the write having its command ended as refused while the name is answered all the same, the put itself still able to refuse with the same full-queue failure the first test raises, and the command installed and given its trade only once the reservation has gone back; and what a caller-supplied command name must be, refused first for an unregistered, fail-stopped or parked account, then held to three demands — not empty, something a client order id can be built from, and neither already accepted nor already held as a live command — where a made-up name meets none of them, being trusted by the way it is made rather than by being checked. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on what is settled before a routine's work begins: which child news a fed-out order acts on, three kinds dropped first — news of the wrong kind, news naming an order the account does not hold, and news whose order belongs to no running scheme, which is what silences news about a finished one since finishing removes it from the running ones — a terminal child taken off the live children before anything is decided so that one ending mid-change is forgotten as live with nothing else done about it, a child ending in anything but a full fill while the order is open treated as a failed slice, and everything else reaching the question of whether the order can now be finished; and what starting a bracket writes before its entry, the parameters and amount insisted upon rather than tested so a command arriving without them stops the worker, the whole shape of the bracket — both protective prices, both offsets, the stop's limit price, the amount and the timeout — recorded and applied before the entry is sent so that a crash in between leaves a record of a bracket whose entry never went out, an entry whose send answered with no order ending the command with nothing filled while that record stays, and a bracket still working answering from the admitted totals. 710 articles, 11,576 line references across 5,128 claims

  • Add one article on sending a slice of a fed-out order, written twice over — once placing at market and once resting at a price — and identical through all four of its endings: the four roads out of a slice's send, a send that timed out or whose name the venue says it already knows sent to be rescued by that name, with a rescue that finds the order using it as the answer and one that finds nothing recording the send as failed, where a venue refusal and a parameter the adapter will not take are both recorded as failed with no rescue attempted at all — so the failures that might have left an order sitting at the venue ask again and those that could not have do not — the moment stamped only once the venue has answered so that the record's time for a send is when the answer came back rather than when it went out, and the submission and every fill the answer already carried both recorded under that same moment. The two routines differ on the kind of order and the price, and on nothing else. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on what a boot does with work the record leaves unfinished: the three kinds of orphan a boot finds, one walk gathering the accepted commands, the scheme starts, the submitted intents and the names their orders were given, a command counted as finished where a send of its order answered either way — found through that order's name — or where an outcome of a terminal status was recorded, so that a failed send finishes a command just as a successful one does and what makes an orphan is silence rather than failure, and the three kinds being an accepted command whose order was never even meant, a command whose order may have gone out, and a scheme that was running and could not be brought back, with the first two both excluding commands that began a scheme so that none is refused as an orphan and ended as a scheme both; and why a flatten is recovered only once, a closing order already carrying fills reported and left for the live reconcile because fills are projected by adding amounts rather than by matching the trade they came from, so writing the venue's trades again would count them twice, with the exit command otherwise built from the venue's own amount, an intent and a submission both recorded where no local order stands at all, each venue trade naming that order written as a fill and applied only where the write answered with a place, and an outcome built only where the order then carries fills. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on changes and on a bracket's first protection: how a change is routed to its handler, which handler it reaches settled by the shape of the change's own parameters rather than the mode of the command it names, the protective road taken before the tests the other roads make so that a protective change is never turned away here for naming a terminal command, an unheld one, or one with an amend already pending — the protective handler making three different tests of its own instead — a scheme routed by its parameter shape with an unmatched shape reported as unsupported for the command's mode although what failed to match was the shape, anything but a single-order or part-shown change unsupported, and a single-order change carrying either stop field unsupported too since the limit price alone is amendable; and what placing a bracket's protection writes first, an entry holding nothing still having its bracket registered with no protection placed, the bracket marked as having its protection placed before the pair is built or sent so that a failure after that leaves it claiming a protection which may never have reached the venue, what the exit may fill recorded by amount alone with no money figure, legs on the wrong side of the entry's fill refused as an adapter failure before the venue is reached, and the exit command installed and mapped to its order only once the send has answered. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on resolving a bracket whose protection the venue has confirmed finished: what the venue is asked when no protection is working, both candidate list names gathered — the pair held and any replacement still owing, an absent name left out — each asked after at the venue with its list and then every leg and the legs' fills summed, a list the venue does not know passed over while any other venue failure abandons the whole resolving and a failure to reconcile a candidate's legs abandons it too, so three separate ways of giving up each leave the bracket exactly as it was for a later pass, and the two endings being an exit outcome built as filled from the admitted totals with the bracket dropped, or a remainder sent to be remediated as unprotected; and the remainder subtraction written twice, the entry's delivered amount less the exit's projected fills with the candidates' own projections taken back out — which is what stops a fill counting twice, once as projected and once as reported — less what the venue said those candidates filled, written in two places that differ only in whether the figures are gathered over both candidate lists or the old list alone, and whose shared arithmetic leads to closing the holding out on the one road and to protecting it afresh on the other. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the longest routine the wiki had left uncited, the one finishing an amend whose call-off the venue confirmed: how a protection amend is driven to its end, the amend's figures taken off the bracket with four of them insisted upon, what the entry delivered read net of its base-asset fees, the venue asked what the called-off pair actually filled, a venue failure there recording the protection's state as unknown and abandoning the amend while fills that will not reconcile park it as cancel-confirmed for the scan to retry — two parkings kept in deliberately different states because the watchdog for the unknown one would treat a merely under-projected position as unprotected — and the replacement placed on the venue's word alone once the restore deadline has passed, a gap in the books being preferred to a position left unprotected; and when an amend places no replacement, what is left to protect worked out as the entry's delivered amount less the exit's projected fills with the old pair's own taken back out so they cannot count twice, less what the venue said that pair filled, with nothing left dropping the bracket, a remainder below the venue's least tradable amount or sum treated as closed dust, both minimums reading as nothing where the venue's rules are absent, and the replacement recorded as submitted before any order goes out. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on how much a command is said to have filled: two ways of asking what a command filled, the admitted totals read from a mapping the account keeps and answered as they stand, with the raw projected totals read where none are held and either of them standing above nothing weighed — a fill having reached the ledger without passing the admission that caps it — and nothing filled answered regardless, so that road fails closed, while the delivered amount is worked out from exactly those raw totals less the base-asset fee of every order of that command, live and closed alike, leaving one figure capped and able to read as nothing while fills exist and the other uncapped and net of fees, with only one of the two telling a caller that something is wrong; and what a boot ends an unfinished scheme with, the scheme's own projection read first and the ending abandoned where there is none, one moment taken for every record written, the admitted figures used so that a scheme whose fills never passed admission is ended as having filled nothing, a state change and an outcome each written to the record and then applied with the command marked terminal between them, and the slices done trimmed to the total so that nothing downstream sees more slices done than the scheme had. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the order manager's edges: the active-protection test written twice, a bracket's protection counting as live where it is placed, carries a name and reports itself active — three conditions tested together in two places two thousand lines apart, settling in the one whether a bracket entry is amendable at all and in the other which brackets the weighing of a change is given to work from, so a bracket cannot be amendable on one road and invisible on the other — with a change for an unregistered account refused before either is reached and a weighing that answers against queueing reporting it and returning, leaving the request neither queued nor refused to its caller; and what unregistering an account does in order, the account taken out of the manager's own mapping first by a removal that answers with what it removed so that finding nothing there refuses the whole call, the published amendable set dropped, every admission still waiting failed carrying the same words a fresh call would have been refused with, and only then the worker's task cancelled and waited for with the interruption that raises swallowed — the removal coming first being what lets an admission already under way find a different account under that name and refuse. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the one road by which anything reaches an account's record: what admitting an event refuses, turning away a call from a thread other than the loop's — tested only where a loop thread was recorded at all, so a manager that never recorded one accepts any thread — an account that is not registered, one that has fail-stopped, and one parked after a failed startup, with an admission made during recovery refused unless the account is parked, which is the very state that turns an ordinary admission away, and the two roads parting there: a recovery admission appending and projecting there and then while any other makes a promise, queues it with the event, wakes the account's worker and waits on it; and the two checks around an append, whether the account has fail-stopped asked before the write and again after it because the write is awaited and an account can fail-stop while it is in progress, what the manager now holds under that name compared against the account in hand by identity so that one which left and came back under the same name is turned away with its event already durable and due to project when the record is read back, and the projection wrapped so that the interruption a cancelled task raises passes straight on while any other failure marks the account fail-stopped rather than leaving it holding a record it has not applied. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the rest of the order manager's read-only roads: which readings hand back a copy, the positions coming back as a snapshot and the balances, per-asset balances and per-trade results each as what the ledger's own reading gives — freshly made under the ledger's lock — and the open orders as a copy of each, where reading the trading state hands back the account's own object, the same one the account's work writes its orders and positions into, so a caller holding it holds the account's state itself, while asking which trade a command belongs to reads one mapping spanning every account with no account named or checked; and the three questions asked of an account's condition, whether it has fail-stopped answered true only where it is registered and carries that mark, whether it can send orders answered false where unregistered and otherwise only where it is neither reconciling nor fail-stopped — so a reconciling account is answered false by both for different reasons and only a caller asking both can tell a gate that will lift from one that will not — and whether anything still awaits handling answered false for an unregistered account so that a drained account and an absent one answer alike, beside the asking for a protection sweep that sets a flag, answers nothing, and does nothing at all for an account it does not know. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the last of the rebuilds a restart runs and on a rule written in two places: what a protection of unknown fate is rebuilt as, only a command whose latest protection record is neither active nor failed reaching that road since either clears the unresolved phase, coming back with its protection placed and its state in doubt, carrying the old list as its protection and the new as a replacement still owing along with the moment it became unknown, its three protective prices read from the latest amend request or from the start itself, and an entry that filled nothing simply leaving the average price empty where the ordinary bracket rebuild would have stopped — two roads rebuilding one thing and parting on exactly those two choices; and the one precedence written twice, the five steps reducing a protective pair's legs to a single status — a fill, a part fill, an expiry, a rejection, then a cancellation — written once over the venue's own words when it answers a freshly placed pair and once over statuses already read when each leg is asked after separately, the first reached only where the pair reports itself all done with any other list status sent through a mapping that refuses an unknown one, and the second reached with no such gate but protected instead by a leg whose asking fails answering that the whole pair is live. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the third of the rebuilds a restart runs: what stops a bracket being resumed, one pass gathering the starts, the latest protection reported active, the amends under their versions and two marks — amend unresolved, and put right already — where an active record clears both and a failed one sets the second, so a protection that failed and was then restored comes back active, and six tests each passing a bracket over: either mark, a command that will not rebuild, an entry name the account holds no order for, a resting protection whose entry filled nothing which is left to reconciliation rather than resumed with legs that cannot be worked out, an active protection no longer resting which is passed over rather than falling to the road that would place protection afresh, and a protection order doing anything but submitting; and what a resumed bracket's protection is taken from, the name and version read off the latest active record or worked out at version nought, the amend whose legs are restored found by matching the name of the list the venue is actually resting rather than by taking the newest version — so a change whose call-off never landed restores the legs belonging to the list that is really there — and the three protective prices worked out from the command and the average entry price where no recorded amend matches. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the second of the rebuilds a restart runs: how a ladder's rungs are found again, only the ladder starts walked and four tests each passing one over, with each rung's name worked out again from the mode, the command, the rung's place in the grid and the generation and the account asked whether it holds that order — a name with no order counting as a rung never posted, one with an order as posted and one whose status is not terminal as still working, so the cursor a ladder comes back with is a count of what was found rather than a figure read from the record, which finds a rung the venue accepted but the record never saw and misses one the record saw but the venue lost — and a ladder coming back with no slice plan and no interval at all; and what a ladder amend caught mid-flight resumes as, the ladder returning at the generation before the one initiated and on the last completed amend's parameters, carrying the phase the history last recorded, holding the rungs still working from both the old grid and the new with the new one's grid sized from the highest place its plan names, and its context rebuilt from the initiation and marked as having committed its cancel, so the watchdog drives the change on from where it stopped rather than starting it again. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the first of the rebuilds a restart runs: what stops a scheme being resumed, five tests each passing a scheme start over rather than ending the walk — a command with a terminal outcome, a latest state that is anything but running with an absent state read as running so a scheme recording only its start is treated as still going, a mode that is not a scheme mode or a slice count below the minimum or an interval at or below nought, a volume-weighted scheme whose stored weights number fewer than that minimum, and a rebuild or replan that refuses — the last reported as left for the boot cleanup, so a scheme whose plan can no longer be worked out is neither resumed nor ended here; and what a resumed scheme comes back holding, its command rebuilt as a market order with a replay timeout, its live children the replayed active names narrowed to orders still there and not terminal, its deadline the start's moment plus its timeout, a replan replacing the slice plan outright and supplying the interval, its timer settled by which of the state and the replan stands later in the history, its hold following one precedence of draining, protection, a failed slice and open so it cannot come back looser than the running one would have been, and a scheme with nothing left to wake it handed the present moment as its timer. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on how an account's live work is rebuilt after a restart: how a restart reads its record back, refusing where the account is not registered, bridging an older registration shape and folding the scheme history before any event is read so the walk already knows which commands began a scheme, then projecting every event in order — a flatten record adding its order's name to the account's own set of them, a scheme start and a submitted intent each recording what was asked for, an accepted command noted against the account and a terminal outcome marking the command terminal and dropping it — with a command rebuilt from its intent only where it stands unmarked as terminal, began no scheme and has nothing held for it already, coming back as a single order whatever it was, so the modes spanning several events are left to the rebuilds that run after the walk in a fixed order; and what one pass gathers for the schemes, the scheme starts and the ladder starts kept apart so neither takes the other's, the latest state and any replan each kept with the place in the history they arrived at, a failed slice freezing the command where a protection freeze marks it twice and only the slice-failure mark is ever lifted, a draining record keeping the status, state and reason the command is to end with, and a ladder's amend followed as a machine whose completion builds the new grid from the initiation and plan kept under that generation and records nothing where no initiation was kept. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the order manager's own answers: what the manager tells you about an unknown account, seven ways of asking about one account dividing on what an unregistered account gets — three raising and four answering with nothing — so a caller asking more than one must be ready for both and neither answer says the account went, with one of the three testing for the account rather than reading it and so raising without ever holding what it would have read, the symbols gathered from the open orders and a copy of the positions where the open orders are handed back as a copy of each; and which commands count as amendable, the running schemes, the commands whose order is live and the brackets gathered together less the derived names of the brackets' protective exits, a command counting as having a live order where the order its name points at is there and its status is not terminal, then the terminal commands, the commands already waiting on an amend and any scheme held for protection, mid-amend or draining taken out, a scheme held in any other way taken out only where it is a ladder, and each bracket entry settled last — added where its protection is placed, named and active — by a loop that runs after every removal and asks nothing about what those removals concluded. 710 articles, 11,576 line references across 5,128 claims

  • Sweep the host, closing it: every one of the hundred and three citable statements left uncited is now cited, by widening the claim that already covered each routine to name what it hands back, where its wrapping begins, what it insists on past a refusal, what each background set takes off the host before building and reads back before stopping, what the synchronous accounting reads under the registry's lock and answers on a reported failure, and the two settings that fix how the host reports about itself. Add one article the sweep turned up, what a host keeps as it is built: the settings, the record or the path to one, the venue, the port, the two folders and whether permissions are enforced each kept as handed in, the accounts alone copied into a list of the host's own, and a stop of its own, a cache for the book and a sink for alerts built rather than handed in, the sink reading the address to post to from the environment so that where an alert goes is settled while the host is built rather than when one is raised, and a posting opening a session of its own under a total deadline and raising on an answer that is not a success. Move what a scan reads from the watch's scheduling article to the article about what a pass finds. Forty-five statements are left as an exclusion: sixteen signature lines of routines declared inside other routines, and twenty-nine log calls. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the two open roads on the host's listener: what the health road reports unhealthy for, four things weighed about the host — whether its own stop has been set, whether there is a trading stack and whether it has started, whether the loop's thread is there and alive, and which account threads are no longer alive — each adding a name to a list and all four weighed before anything is answered, so one ask names every part that has stopped rather than the first, an empty list answering that all is well, and nothing at all weighed about the caller where the figures road beside it demands a loopback address and the operator roads demand three things; and which accounts the figures road knows, a loopback address demanded and no token, the road answering that it is not ready where the host has no record of its own, its accounts coming from a mapping built once from the settings and kept so the settings are read from disk on the first ask and never again, each carrying the one standing symbol, the pool from its settings and the series and width its settings settle, a single configured account used where none is named, and that mapping standing over the accounts the settings name where the operator roads resolve over the accounts whose runtimes are published — so the same name reaches two different answers depending on the road it arrives on. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the roads an operator can take: what every operator road weighs first, a caller from any address but the two loopback ones refused as forbidden, an unset token answering that the roads are not configured so that they stay off entirely until one is set, the header required to carry that token after the word Bearer under a comparison whose timing does not vary with the answer, the read-only status road held to the same three, and the account resolved from a copy of the published runtimes taken under their lock with a single running one used where none is named, several refused as needing a name with the known ones listed, and both an absent named account and no account named while none runs answered as unknown; and what an operator's halt and resume do, one routine told which it is by a flag, the reason read from the body with a default standing in for an empty body, a body that will not parse, a body that is not a mapping and a reason absent or blank, the mode changed before the state is written down so that a failure writing answers an error at five hundred while the account has already been halted in memory, the record of the ask appended after and only where the host has a record at all with a failure there reported and no more, the alert sink told at warning, and the answer being the same body the status road gives. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on what carries a request across the host and what the last word on a command takes away: what a submission remembers between its halves, a mapping made fresh for every call to the submitter holding each built request under its command's name and read back by the registering through a lookup that demands the entry, three of the account's loops each given that same submitter to call while the registry of commands is made once for the account and guarded by a lock, a request carrying no command name handed to the checks and remembered nowhere, an action whose strategy the settings do not name dropped, and the venue's adapter passed through only where the trading stack stands so a host without one builds requests that are never snapped to the venue's steps; and what a terminal outcome removes, the command's registration dropped under the registry's lock whatever the outcome says so that a refusal and a whole fill are forgotten alike, the holding looked up under the positions lock where the command was an entry carrying a trade name and deleted only where nothing is left of it, that deletion remembered and the memory the only thing that drops the bracket's protective record — so the record is kept exactly while there is a position for the protection to fill against — and whether the command still stands marked as unsaved read under the registry's lock again after all three removals. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the step between an account's thread starting and its loops running: what the build refuses before an account runs, turning away a missing trading stack or host loop, a startup sequence that answered without producing settings or state — so that the sequence returning is not by itself proof it produced anything — and a risk record with no slot able to hold a lock, past which the lock guarding holdings is installed in that slot so one lock stands under both names while a separate lock is made for the registry of commands, with the mode controller built over that lock and reconciled at once and two handlers built over the one controller, each taking its own answer from the settings; and what runs before an account's loops do, the accounting wiring published part way through the build, then the outcomes a previous run recorded but never acknowledged re-delivered, then the actions the startup sequence held over drained, and only then the loops built and the runtime handed back — so that through the replay and the drain the account is one whose figures can be moved and not one anything can be asked of, which is the window the two mappings are kept apart for, the wiring being published earlier than the runtime because the replay's own working-through reads it. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on how the trading side reports back and how an account's own loops run: which roads out wait for an account to be ready, four roads set as the trading side starts with money moving, a disagreement found and a protection to put right each resolving the account's runtime first and refusing where none stands so that each is held and offered again rather than lost, the road an outcome takes resolving no runtime at all and reading the account's queue and its wiring instead, which makes it the one road able to act on an account the other three would refuse, a caller's own road awaited after the host's routing so it can neither stop it nor precede it, and the trading side started only once all four are set and refused outright where the host's loop has not been started; and the order an account's loops start and stop in, the predicting loop first and a timer loop after it where the account has one, then the outcome loop, the health loop, the saving timer, the marking loop and the watch over timed-out handovers each in turn, so the loop producing work starts before the loop consuming its outcomes, and on the way down four stopped by hand while the predicting, timing and consuming loops are handed to the stopping sequence instead, the four stopped by hand being exactly the four the sequence is not given. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on how a host is built and where an account is written down: what a host refuses to be built as, being handed both a record and a path to one failing the same line as being handed neither, every deployment cap demanded where the key's permissions are to be enforced with the unset ones gathered and named together in order, the caps chosen from the caller or built from the environment twice over so that a host given none reads the six settings twice, the same demand written again where that set is built for a live host with a failure of another kind and the names unsorted, and whether the host owns the record it writes to remembered as whether none was handed in; and the two mappings an account lives in, its accounting wiring written from inside its own build and its runtime written only once that build has answered, the runtime taken out again on both ways out where nothing in the host takes an account out of the wiring, an arriving report reading the wiring by the account it names where reaching an account reads the runtime and refuses where none stands, and the two kept apart because they are published and withdrawn on different edges, so one mapping would have to pick an edge and answer the other question wrongly between them. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the roads into a running host and the window an account is reachable in: what the one listener serves, a single application carrying the health road a container polls, the figures road, a status read and four asks that change something, bound to every address the host has, so that the credentials each ask weighs are the only thing between an outside caller and an account, its build waited on for ten seconds with nothing wrapped around the wait so a port that cannot be bound stops the host where a sampler that cannot be built does not, and the listener forgotten after a failed stop where the background work keeps what it could not stop; and when an account can be delivered to, one daemon thread made per account and named after it, starting them refusing where the trading stack or the loop is missing while a thread that finds the same thing returns without a word, the account's runtime published under a lock of its own once its build has answered and read back under that same lock by each of the roads that deliver, a refusal meaning the account is still building and the thing held undelivered rather than dropped, an ordinary stop unpublishing the runtime before any of the account's loops is stopped, and a failure unpublishing it after the failure is reported and then setting the host's own stop. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the work the host runs beside its trading: how the mark samplers are started and stopped, nothing happening where the loop or the host's record is missing and the building doing nothing where samplers already stand so that starting twice builds one set, where the bars are kept read from the environment with a standing folder where none is given, the cadence and the epoch each read once before any sampler is built so that every sampler in a set shares one cadence whatever each account asked for, one sampler built per account with a price reader bound to that account and started as it is built, a failure part way stopping every sampler already started and raising past the line that would record the set so that a later build begins from an empty one, and a stop waiting ten seconds for the whole walk and keeping the list where the walk fails; and where the host's two sets of background work differ, the samplers and the book pollers built from one pattern that shares the handover to the loop, the ten-second wait, the stopping of everything already started on a failed build and the keeping of the list on a failed stop, departing on how many of each are made — one per account against one per distinct symbol — on what settles the cadence, a setting against a figure standing in the module, on where each writes, the host's record against a cache that nothing outside the run survives, and on what each needs before it will start at all. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on what an operator can ask of one account: what the operator's two sweeps answer with, each weighing the operator's credentials and then resolving the account's runtime and answering with whatever refusal either gives, the account's name read off that runtime rather than off the request, any failure reported and answered as a named error at five hundred, the alert sink told only where a sweep answered and then at warning with its counts, and closing everything running the cancelling and the closing inside one wrapping so that a failure closing discards the cancelling's own answer although those aborts have already gone out; and what a sweep does to each item, each walk answering an empty list where the trading stack is missing, the cancelling gathering the command names off the open orders and walking them in order with an abort naming the operator and stamped with the host's clock, the closing passing over a position whose amount stands at or below nothing and taking the opposite side by testing the position for a buy before sending one market order for the whole amount under a deadline of its own, and both walks carrying on past a failure on one item where only the closing says so in its answer, the cancelling leaving a failed command out of its list instead. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the host's own writing to the record it keeps: which of the host's appends can stop the work, the record opened only where a path was given with its folder made where absent and its shape made sure of before use, and three kinds of event appended in one shape — stopping where the loop or the trading stack is missing, building the event with the host's clock, reading the epoch and the record off the stack, handing the append to the Praxis loop from whatever thread is running and waiting ten seconds — where the acknowledgement and the abandonment report and return and wrap both the handover and the wait, and the record of what an order was sent as raises instead and wraps nothing, so a failure there reaches the caller's own rollback and the order is never sent; and what a delivery record carries, nine fields written before the order goes out and taken back one for one after a restart with nothing worked out and nothing defaulted, beside an outcome rebuilt from its own record that is not one for one — its average fill price worked out from the sum and the amount filled or nothing where nothing filled, its slice counts set to one rather than read, its moment taken from the record, and its two slippage measures carried rather than worked out again because the figures they came from were never written down. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on what the host writes for a protected entry and what it tells a strategy: what a bracket's protective exit is registered as, a record written the moment the entry is registered and long before any protection is placed, its side the opposite of the entry's settled by testing the entry for a buy so that anything else is protected by a buy, its size, sum and fees the entry's planned figures rather than what it filled, marked as not an entry and as meaning the whole remainder whatever the entry was, written durably and then in memory under the registry's lock, with that in-memory write replacing whatever stood under its name where the entry's own write fills a gap, a rollback dropping the entry's registration only where that pass put one in and the exit's wherever a bracket name was recorded, and an entry that ends leaving no position having the exit's registration dropped by a name-based drop that asks nothing about brackets; and what a strategy is told about the account, no positions, no money and a halted mode where there is no state, no settings or no named strategy, its money the pool at its share less what it has deployed and held at nothing at the least, every holding the account has copied under the positions lock before being narrowed to the strategy's own, and the mode its own where it has one and the account's where it has none. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on what is written before an order goes out and what is built once it has: the empty position an entry is given first, a holding of no size written under the command's own name as the entry is registered so that the first fill has something to grow, carrying the action's price or a provider's, with an entry sized by amount reported and left without a holding where neither gives one while one sized in money takes a price of one, that price thrown away by the first fill because the fill's own price is taken wherever the size standing is nought, the side the action's own or a buy and the symbol the one standing default, and the write made only where nothing stands under that name already; and what rebuilding an order's record is given, the record built from a request fetched through whatever the caller handed in with a missing side refusing and a missing size refusing only for an action that is not an entry, a refusal from the record's own demands reported and nothing built so a malformed record is never registered, and the two callers handing over two different things — one the request the checks already read and the other a way to build one again — settled by whether the road out carries a command name of Praxis's own, the first of them unable to rebuild because it has just raised the pending amount that decides whether a close takes the whole remainder. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on how a strategy's action becomes a request the checks can read: how an action is routed into a request, the kind of it looked up in a fixed mapping with one the mapping does not hold reported and dropped before any check sees it, a change answered inside its own branch carrying no sum, no fee and no budget with a placeholder size and the name of the command it amends, an abort answered with nothing at all, the strategy's budget worked out only after both of those have answered so that neither ever reaches the money, an entry sent to a builder given a price to fall back on and a symbol where an exit's is given the thing that turns a scrap to dust, which is why only an exit can end that way, and a change's symbol being the one an entry would use whatever the command it amends was placed against; and where the two request builders part, both dropping an action that carries no size, both letting a snapped amount replace the action's own once a refusal has been weighed, every road estimating the fee as the sum times the rate, an entry taking a buy and an exit a sell where the action names no side, an entry's size staying the action's own where no adapter was given, and the level an exit's refusal is reported at being chosen by whether the whole remainder was meant, so a full close turned away for being too small is reported as news rather than as a problem. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the host's own building: what each check a decision passes is built holding, four sets of limits and the first check's hooks made once as the walk is built with three of the four empty and the platform caps alone taken from the caller, three of the six checks reading nothing beyond what they hold and so unable to see a figure change while the host is up, the other three calling a provider as each decision arrives, two of those handed the decision's own context where the health one is handed nothing, and the readings used where a caller supplies none being a fixed set of health figures, an empty platform reading and no price reading at all; and how the watch over timed-out handovers keeps itself going, a lock of its own apart from the one over the registry it scans guarding only its flag and its timer, that flag read as a tick begins and again as the next scan is scheduled so a stop during a scan is caught at the scheduling rather than cutting the scan short, a failure out of a scan caught and reported with the next scan scheduled all the same, the timer marked a daemon before it is started, and a scan taking the moment once so every record it weighs is judged against the same instant. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the host's own settings: what a timing setting is held to, the five saying how often the whole state is saved, how often holdings are marked, how long an unclear send waits before a warning, how often such sends are looked over and how often a mark is sampled, each falling back to a figure standing behind it where the setting is absent or holds nothing, and each refusing the start where it holds something unreadable, endless, or at or below nought, with the sampling cadence alone then refused unless it is a whole number of seconds, where a cap read from the same environment answers nothing for an empty setting rather than a figure and refuses with a failure of another kind; and how the mark-price series is settled, every strategy the manifest declares walked for the run of bars it names and the width of them, a run declared twice with widths that disagree refusing the start, a run named in the environment taking the manifest's width where the manifest declares it and a second setting's width where it does not, under three tests written out in place rather than taken from the reader that already makes them and with nothing weighing the given width against the manifest, and with nothing named at all one gathered run used while several or none refuse the start. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles closing the Praxis side's venue adapter, written from what the packages before it left over rather than from a subject scoped in advance: how a venue answer becomes a record, the four readings that turn a reply into something Praxis keeps taking their fields by name so a reply leaving one out stops the reading, with fills on a submitted order and legs on an order list the two exceptions, each read with an empty list standing in for one absent, which refuses an order list outright and lets a submitted order through carrying none, and every fill read off a submitted order marked a taker where a venue trade reads its own maker flag; which health figures are read under the lock, which is held for finding the account's record and reading the clock gap together and let go before the share of the venue's allowance in use is worked out, so one answer carries two figures read at two moments, an account the adapter holds no record for being answered with those two alone and the rest at the nought each defaults to, and the same lock standing between a reading and an account arriving or leaving; and which askings make their own request, the asking after a symbol's trading rules and the asking after how deep the market stands each building and sending their own request on the session instead of handing one to the code that sends again, so each takes one slot of the allowance where a retried call takes one for every attempt, and a passing failure in either goes back to the caller rather than being tried a second time. Widen five existing articles onto the statements left over around them: the wait a rate-limited attempt takes, the send inside the order wrap, fund history handed back in order of the moment each movement happened, the asking after what a key may do, and the two lines the headroom warning is weighed under. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the hundred and fifteenth package, what the allowance headers are trusted for and which stated limits are adopted: what the allowance headers are trusted for, storing the request figure restarting its expiry window where storing the order figure restarts nothing; and which stated limits the adapter adopts, only those matching an exact kind, span and span-count. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the hundred and fourteenth package, what the trading rules asking insists on and what the rules are read as: what the trading rules asking insists on, the allowance headers read before the reply is checked for failure; and what the rules are read as, three limits demanded with every missing one named together and each figure turned into an exact decimal. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the hundred and thirteenth package, when a request is signed afresh and what an asking reads back: when a request is signed afresh, the retry handed a way to build the request so each attempt signs with its own timestamp; and what an asking sends and what it reads back, the balance request sending nothing and filtering the reply on this side. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the hundred and twelfth package, what the asking calls share and how fund history is paged: what the four asking calls share, a caller-supplied name for a paired order going out under one key when cancelling and another when asking; and how fund history is paged, the walk stopping only on a short page so an exact multiple costs one empty request. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the hundred and eleventh package, the two roads a submitted order can take: what a money-sized order is refused for, a cash amount picking a road that then accepts only a market buy; and what an amount-sized order goes through, the amount rounded to the venue's step before any check so what is judged is the figure the venue will see. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the hundred and tenth package, how a venue failure is sorted and which one counts as healthy: how a venue failure is sorted, the status alone deciding most kinds so a helpful message on a server error is discarded; and which failures a retry counts as healthy, a not-found recorded as a healthy exchange and only one rate-limit status ever retried. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the hundred and ninth package, what signing adds and what an order type decides: what signing a request adds, the query built once and signed over exactly that text so the sent and signed forms cannot differ; and what an order type decides about its parameters, each kind recording what it must and must not include so an unnecessary price is an error. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the hundred and eighth package, what the venue adapter reckons, refuses and closes: how the adapter reckons its headroom, the used request allowance dropping to zero all at once rather than fading; what the adapter refuses to be told, a permission it cannot read counting as denied; and what closing the adapter does first, the closed mark set before the connection is touched. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the hundred and seventh package, what a submitting road refuses and which orders a reconcile asks about: what a submitting road refuses first, a shutdown reported before an unready account so a caller is told the facade is closing; and which orders a reconcile asks about, only those this side still believes are open, over a copy so the walk can close them as it goes. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the hundred and sixth package, what the stray-order sweep looks for and what an account's startup does: what the sweep for stray venue orders looks for, completed orders counted as known so finished work is not mistaken for a stray; and what an account's startup does in order, trading rules loaded for coins named by old bracket records as well as current ones. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the hundred and fifth package, what a failed start undoes and what a stop will not leave running: what a failed start undoes, the event loop claimed on the first line of the work and every collection cleared whether each cleanup succeeded or not; and what a stop will not leave running, the facade reporting itself both started and stopping during a stop because only one flag is lowered no matter what. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the hundred and fourth package, where a fund pass starts and what holds its cursor back: where a fund pass starts looking, a deliberate overlap with a floor that stops it reaching into history; and what holds a fund cursor back, the marker advancing past movements it ignored and stopping behind ones it handled because it records the round rather than the movements. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the hundred and third package, what a balance comparison weighs and what becomes of a mismatch: what a balance comparison weighs, a shortage reported where a surplus never is and the round abandoned when the expected figures moved mid-ask; and what becomes of a mismatch nobody took, the discrepancy recorded before anyone is told so a record is no evidence anybody heard. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the hundred and second package, what a backfill asks for, records and admits: what a backfill asks the venue for, one truncated coin making the whole answer incomplete; what a backfill records as confirmed, the marker landing on a trade actually read; and what a backfilled trade becomes, a missing link to the original request discarded in silence where the live path logs a warning. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the hundred and first package, what the venue's socket reports and what becomes of it: the five reasons a report is discarded, the logging level being the only thing that says which drops were expected; and what a report becomes, the fill being the one conversion that can fail because it needs a trade name this side may have forgotten. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the hundredth package, how the reconciliation loop stops and what its phase map agrees with: how the reconciliation loop is stopped, the stop flag checked before each account as well as each round; and what the phase map and the gate agree on, the switch that holds an account's orders back computed from the phase in the same call so the two cannot drift apart. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the ninety-ninth package, what the facade is built with, hands out and registers: what the facade is built with, settings callbacks wrapped at building where later ones are wrapped as they arrive; what the facade hands out, the event loop throwing rather than answering before a start; and what registering an account touches, the removal reaching further than the addition. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the ninety-eighth package, what the facade refuses, wraps and drops: what the facade refuses once a start has begun, the setters closed partway through starting rather than at the end; how a caller's callback is wrapped, one setter passing an absent callback through unwrapped because its far side reads absence as nobody listening; and what routing an outcome drops, the lock covering the lookup and not the handover. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the ninety-seventh package, what an append seals and what a caller reads back: what an append does in one transaction, the duplicate guard and the record unable to disagree because they are the same insert; what sealing an appended event takes, one record taking two writes because the row's own number is part of what the seal covers; and what a caller can read back from the spine, an epoch read collecting everything before returning any of it. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the ninety-sixth package, what the spine reads and how it closes a write: what the spine's four readings insist on, the old and new deduplication rows read under different conversion rules and then compared; and how the spine closes a write, a failed save raised where a failed undo is only logged. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the ninety-fifth package, what the spine's migrations add, prove and drop: what the first migrations add and prove, no seal filled in for older records and a refusal rather than a guess where a leftover row cannot be attributed; and what the last migration drops, every row counted across before the old table is removed because removing it is the one step a repeat run cannot undo. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the ninety-fourth package, what opening the spine's file asks of it: what opening the spine does to its schema, a file written by a later build refused rather than read and an up-to-date one left untouched; and what the spine asks of its own identity, a missing chain setting answered differently from one that disagrees. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the ninety-third package, how the spine writes a value and reads it back: how a value is written out and read back, exact figures stored as text and rebuilt from it; the three shapes a coercion looks inside, a list turning every item into the first type it names; and how an event is rebuilt from what was stored, a missing type stopping the read where a missing field is dropped without a word. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the ninety-second package, what binsim does with a submitted order: what a submitted order is weighed against, the book's staleness measured from the last successful fetch rather than the last change; and what a fill's fee is charged in, a buy charged in coin and a sale in cash at every level so a round trip's two fees are in different assets. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the ninety-first package, the sockets binsim accepts: the two sockets binsim accepts, one replying and one discarding on the same keepalive so a caller cannot tell them apart; and what a subscription frame is answered with, an unparsable message dropped without reply where anything parsable always gets one. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the ninetieth package, what binsim's server holds and what it is handed: what binsim's server holds and when, a failed start leaving it holding neither of the pieces that serve requests; what the application is handed and what it serves, one path answering about an order or submitting one by method; and what an order's figures are put through, the smallest-value check returning at once when the book has no price. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the eighty-ninth package, what binsim answers when it is only asked: what binsim's read endpoints answer, a missing symbol reported under a different code from an unrecognised one; what asking for a signature buys, an unknown account coming back as a refused signature; and the two shapes a refusal takes, the error builder returning one to throw for two statuses and throwing one itself for the rest. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the eighty-eighth package, how the projection routes an event and closes an order: how an event finds its way through the projection, two kinds leaving an order in the same final state; what closing an order moves it to, the order kept readable under the same name in the closed book; the lookup every handler shares, one handler quiet on a repeat where the rest warn; and what the projection copies under its lock, the holdings guarded where the orders and schemes are not. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the eighty-seventh package, how the ledger posts and what it hands back: how a journal entry moves the balances, the entry written before any balance moves and each line shifting an account in the direction that account dictates; what the ledger refuses, a fill in any other coin treated as something it was never built to do; and what a reading of the ledger hands back, each per-trade record copied rather than just the mapping. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the eighty-sixth package, what a replay's report counts: what the replay report counts a trade as, every trade filed as a buy-and-hold one and a trade finishing exactly even left out of both the winners and the losers; and how the replay report places a fill in a bar, a fill earlier than the first bar moved into it with nothing recording the move. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the eighty-fifth package, what binsim's feed asks for and what it keeps: what the feed demands of a depth payload, a missing field reported by name where a wrong shape is reported by what arrived; and what the feed keeps and what it waits on, the poll interval being a ceiling on a wait for the stop signal rather than a sleep. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the eighty-fourth package, what the keeper of a host's money weighs: what a strategy's budget is worked out from, the realized figure going in signed so a losing strategy gets less; what a fill against a reservation refuses, unreadable figures throwing where mismatched ones come back as failures; how a rejection and a cancel mark the same failure, one as a broken rule and the other as expected; and what the money keeper is built with, one figure checked three ways and the clock that times the rest. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the eighty-third package, what a stopping host builds, sends and waits on: what a sequencer refuses to be built with, one combination refused out of four; what the wait for outcomes takes off the pending set, a partly filled command keeping the wait open; the same absence in the two exit builders, quietly skipped by one and thrown by the other; and what each shutdown submission records, the sending silent where the giving up is not. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the eighty-second package, what the first stage holds its hooks to: what the intake stage holds its hooks to, three raises all about the shape of a check's reply rather than the request; what an intake hook keeps between calls, a tally and its lock built once and shared by every call; and what the reference check asks of a change or a stop, a changeable-order list that can be fetched fresh against a stoppable-order list fixed when the check was built. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the eighty-first package, the two actions that go out without a command: what an abort and a modify answer with, one refused for a single missing piece and the other for any of three, both answering a failed send with the failure's own text; and how the walk over a strategy's actions ends each one, every route carrying its own reply to a list made before the walk and nothing given back until the walk is done. 710 articles, 11,576 line references across 5,128 claims

  • Widen five citations on the eightieth package, the road out to Praxis, swept: every one of the module's fifteen uncited statements was the inside of a statement an article already accounted for, so the cell moves to accounted-for in full with no article written and five log calls recorded as an exclusion. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the seventy-ninth package, how the loop that values positions paces itself: how the mark loop paces itself, the next round scheduled only once the last has returned so the gap runs end to end; what a mark works out for each position, the paper figure signed by the trade's direction and three tallies built over one walk; and what the mark loop leaves unguarded, a round askable on a loop never started and a round that throws costing one valuation. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the seventy-eighth package, what an outcome's answer records and what a position change checks: what each outcome's answer records, a cancelled or refused sale able to answer that it worked while recording that the money did not move, and an acceptance marking the money only for an entry; what a dust close refuses before it touches anything, three names weighed before any lock is taken; what a position change checks, a missing figure in the arriving record asserted where a missing holding is refused; and where the locks sit on a position change, the sums worked out before the hold and one routine holding before it looks. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the seventy-seventh package, a pass over the parked outcomes and what a tick answers: what one pass over the parked outcomes does, one clock reading serving both the weighing of every deadline and the setting of every new one, and a copy of the names walked so that dropping a command partway through is safe; and what a tick of the outcome loop answers, one answer covering a report that reached its strategy, one set aside, and one filed behind an earlier report without being tried. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the seventy-sixth package, the walks over the log and what a recovery fills in: what a recovery inserts for a strategy the state forgot, an empty risk record put in for a strategy the log has events for, without which the rebuilding that follows never reaches it; what packs a record and what forces a folder, a record's place in the order travelling inside the record itself; how a record is taken off the file, the shape all three walks share and the truncation scan's answer that cannot be reached; and what a refresh of the loss windows reads, the log read afresh from inside the lock with a moment taken off the clock. 710 articles, 11,576 line references across 5,128 claims

  • Add six articles on the seventy-fifth package, the venue a replay trades against: what it refuses before it fills, five refusals ahead of the figures and four behind them; how it settles a fill, the fee landing on the quote balance either way against the other simulated venue's charging by side; what it snaps a quantity to, one reason covering a quantity too small and one the flooring made too small; what it answers when asked, the same absence giving none in one place and raising in another; how it narrows its trades, a limit keeping the earliest recorded and a removed account still answering with its trades; and what it will not do, several methods answering by declining. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the seventy-fourth package, the venue interface and the records its answers arrive in: what a venue must offer, twenty-one declarations with a placeholder where a body would be; what an execution report is held to, a trade required to carry the numbers proving it with the fee's sign unasked and an empty trade name passing; what a non-trade report loses quietly, the cleared fields and the complained-about fields being two lists that differ by one; and what the venue's own records are held to, a trade checked for its moment alone. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the Nexus side's seventy-third package, the records and routing around a price check: what the price records refuse, every field of the market reading able to be absent and neither record trimming a named source the checking trims itself; the per-strategy caps trimmed and sealed, a collision made by trimming refused rather than resolved; how the limits are built from the configuration, one field converted from seconds and nothing weighed here; and who is told about a price refusal, three groups of reasons with a fall-through sorting anything added later. 710 articles, 11,576 line references across 5,128 claims

  • Add seven articles on the Nexus side's seventy-second package, what starting a host asks of its strategies: what a strategy's startup answer does, an empty run of holdings handed over and the same failure fatal from one side of a few lines and logged from the other; what the buffer of startup answers is for, emptied before anything is submitted and tried nothing twice; which saved events a strategy is handed, names trimmed both sides and one strategy's failure survivable; the mode a start begins with, reduce-only where health is unknown and written into the health reading alone; what a start hands the loops, descriptions built from the manifest with no loop made here; how the strategies are built, one attempt around all of them naming the step rather than the strategy; and what a start wraps and what it lets through, one step passing a shaped complaint straight out. 710 articles, 11,576 line references across 5,128 claims

  • Add seven articles on the Nexus side's seventy-first package, what a turn of the prediction loop reads and writes: which prediction row is used, unusable rows dropped and the latest survivor taken with the prediction cut to a whole number before it is weighed; what the manifest must be, a wrong-shaped file warned about and a malformed one raising; how a close is found, an exact match on the moment with the frame read before the guard that reports a miss; what the cohort line records, written only on turns that reach it and reporting a change only against something remembered; what a failure partway through leaves behind, the recorded moment sitting between the hand-over and the submission; how a value is made safe to log, with the signals this loop builds reaching one branch of the run; and starting the loop and one turn by hand, nothing served at the moment of starting and a failure handed over on one road and logged on the other. 710 articles, 11,576 line references across 5,128 claims

  • Add six articles on the seventieth package, what the door weighs and what it never reaches: the order a command's checks stand in, four that always run and two behind venue rules nobody hands in; what a command sized in money is held to, a buy and a market order with the rule split across three places; which modes the money refusal reaches, unreachable for the hidden order and the ladder which earlier checks stop; what a mode command refuses of itself, one rule for all and three narrow ones with three modes meeting none of them; the venue rules that are never applied, the admitting path handing in none so that half runs only under test; and what the per-child rules would weigh, one thing for a spread slice and four for a hidden order's shown amount. 710 articles, 11,576 line references across 5,128 claims

  • Add eight articles on the Nexus side's sixty-ninth package, how an account's mode is settled: how the mode is recomputed, a hold only ever making it worse than the health reading and the answer reporting a changed mode rather than a rewritten record; which hold it is blamed on, by rank and not by arrival with two risk holds sharing one name; what setting a hold that already stands does, keeping the first reason and moment; what the two risk breakers do, the loss one lifting itself at or below its limit and the drawdown one never lifting; the two reduce-only holds, outranked by every halting one; why the health tick commits in one hold of the lock, comparing the mode before and after because each breaker recomputes as it goes; the halt notification that is dropped, a note taken and discarded where the halt lifted first; and what a restart re-derives, throwing away the shutdown hold and keeping the rest. 710 articles, 11,576 line references across 5,128 claims

  • Add seven articles on the sixty-eighth package, the connection the venue speaks over: what opening it does and does not do, answering at once for either of two reasons and starting the reconnect loop only where a handler is set; what setting up tears down first, letting go of the held socket before the address is weighed; the address it will accept, secured always and unsecured only where the simulator setting holds more than blank space; how a subscription is signed and acknowledged, the values sorted before signing and the signature added after; the order closing does things in, the loop stopped and the fields cleared before anything is sent; what a closing can raise, each step passing over the kind it expects and any other stopping it partway; and the failures the reconnect loop swallows, surviving an unreachable venue indefinitely while a cancelling is what ends it. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the Nexus side's sixty-seventh package, the record a strategy's answer arrives in: what it is checked for, thirteen fields each weighed on its own with absence never refused there; what each kind of action requires, the missing fields gathered into one complaint per kind and an abandonment naming its one directly; when an entry may name a sum instead of a size, allowed for a market buy alone with two assertions resting on the gathering above; and the two mappings an action reseals, copied behind a read-only view with only the change's fields refused for being empty. 710 articles, 11,576 line references across 5,128 claims

  • Add five articles on the sixty-sixth package, how the simulated venue is started: what its settings must be, two required and seven defaulted with bounds that differ per setting; the order it starts and stops in, signal handlers before anything else, the feed started without waiting for its first reading so the server can answer from an empty book, and the stopping in reverse; registering an account from the command line, the folder lock held across the read and the write and the key printed once; what running it plainly does, the service being the default road with the lock held for its lifetime; and which failures give a sentence and which a stack, the guard around the run catching only the ordinary kind so every road that ends with a message passes it untouched. 710 articles, 11,576 line references across 5,128 claims

  • Add six articles on the sixty-fifth package, what a fill and an order do to the simulated venue's balances: what settling a fill moves, a buy debiting the whole notional in quote and crediting the quantity less the fee in base with both balances weighed after the fact and nought itself allowed; the asset a fee is taken in, chosen by side to match a real venue while the file's own description says otherwise; the order a fill's refusals stand in, seven checks before the books are touched and the account found after all of them; the guard a sell does not get, a buy whose fee swallows the quantity refused where a sell whose fee exceeds the notional settles and takes both balances down; what an order settles as one, every fill's movement added up and weighed once so a dip partway through passes; and the three readings the ledger offers, each taken under the lock and handed back as a copy or sealed. 710 articles, 11,576 line references across 5,128 claims

  • Add eight articles on the sixty-fourth package, the state directory of the simulated venue: the lock one writer holds, opened for appending so the holder's number survives a refusal; what a refused writer is told, one message for every ground with a holder it may name wrongly; what registering an account refuses and the key it mints, four checks outside the lock and a key minted once and never again; how a key names an account, trimmed then hashed with three grounds answering alike; what an interrupted save does, the write finished before the cancellation is passed on and one narrow case where a failed write reaches the log alone; how the snapshot is written and read back, a temporary file moved into place; what reading the saved ledger requires, a missing file answered and a damaged one refused with the key index rebuilt from the accounts; and what a restart loses, the balances outlasting it while the fills behind them do not. 710 articles, 11,576 line references across 5,128 claims

  • Add ten articles on the Nexus side's sixty-third package, the codec that turns an account's state and its events into bytes: the version a saved record is read at, one arriving without a version read as the oldest; what happens to an event's version on the way in, cut down to a whole number so a fraction reads as the first and a figure too large escapes undressed; which version an event is written at, decided by whether an outcome name is in hand; what a malformed record is refused as, one catch over five grounds with the original failure kept as the cause; the complaint folded into another, a careful message about a bad name swallowed by the catch around it and never reached for the absent case; the figures a risk record falls back to, one figure standing for five; what a snapshot from an earlier host is read as, a missing health mode read as the running one; the small negative snapped to nought, five of six money figures nudged back as they are read; the copies taken before a record is written, each collection caught at its own moment; and what two writings of one state give, matching bytes for two fields and not the rest. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the sixty-second package, what the event records do beyond their checks: the records that reseal their own fields, seven of them rewriting eleven run fields as they are built so the caller's list cannot reach in, with the sealing reaching one level only and an already-sealed run kept rather than copied; the floors a count is held to, a replan refusing a slice count below one and a beginning refusing one below nought under the same field names, with neither asking for a whole number; the fields asked to be a true-or-false, demanded of two, refused in four places because it answers as a number, and unweighed in two more; and the mode a scheme may not begin with, one way of working refused by name where every similar test names what it allows. 710 articles, 11,576 line references across 5,128 claims

  • Add seven articles on the sixty-first package, the forty-two records the trading side keeps its facts in: what every event is held to, all forty-two building on one shared record and each running its account-name and timezone checks before their own; the names a record may leave out, a flag letting a name be absent while an empty one is still refused; the grounds a figure is weighed on, kind, finiteness and sign, with two records dropping the kind and eighteen fields keeping the sign alone; the two noughts a figure is compared with, a decimal nought and a plain one deciding whether a floating-point not-a-number passes or raises; the records that weigh their own fields against each other, five of the forty-two, among them a reported balance disagreement whose figures agree; the rule a bracket borrows, building a protective-settings record from its own fields and keeping nothing of it; and what the shared checks pass over, an empty run of figures passing and one question about named values answered three disagreeing ways. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the Nexus side's sixtieth package, the manifest's records and its file: what the three kinds of record a strategy entry becomes refuse, the signal's and the timer's intervals held above nought by the record where the reading asked only their kind, a true-or-false refused by a test of its own, and the share, collar and timer names held by the strategy's own; what the risk-controls block is held to, an absent, bare or empty block all becoming the same thing, three keys read and every other passed over in silence, and its helper refusing only what will not convert while wording the complaint under this block's name even for a strategy's collar; and what a manifest file must be, a file rather than a folder with the one missing-file refusal written here, bytes that UTF-8 has a reading for, and a mapping rather than a list or a bare value; and the complaint that names the wrong block, one helper stamping the risk-controls block's name on every complaint it makes so that a strategy's own collar is objected to under a block it was never in. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the Nexus side's fifty-ninth package, the reading of an account's manifest: the two refusals the record built from it adds, every other check it makes being already settled by the loader so that only a strategy name used twice or shares adding above a hundred can reach it; what a money figure loses on the way in, the conversion being made from the YAML reader's rendering so a bare decimal longer than a machine fraction arrives rounded unless quoted; the order a strategy entry is read in, its name and file asked only to be present while the record asks them to be text, with a timer's interval asked its kind before the timer's own name; and what a strategy file must be, relative, resolving inside the manifest's own folder, present, decodable as UTF-8 and parseable as Python, none of it reached until every other check has passed. 710 articles, 11,576 line references across 5,128 claims

  • Add the fifty-eighth package, a review of sixteen modules the file ledger marked partial with no statement of theirs left uncited: each read against the claims that cite it, every one found to have its behaviour accounted for, and its cell moved to full — ten on the Praxis side and six on the Nexus side, leaving the outcome record and the validator's inter-stage records partial on findings still called candidates. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Nexus side's fifty-seventh package, the stage weighing a health report: the order its three records check their own fields in, a threshold level skipped where unset then refused for its kind and only past that for its sign, the policy refusing a field's shape before any figure in it is read and bounding its two shares before reaching any ordering, and the snapshot holding all five figures to being finite in one pass before bounding three at or above nought and two between nought and one; and the orderings its policy insists on, four measures held to levels that rise and the share of the venue's allowance held to levels that fall, each comparison reached only where both levels it names are set, so a policy leaving the acting level out has the alerting and halting ones never put side by side. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Nexus side's fifty-sixth package, the first of the checks a decision passes: the order its hooks stand in, a mode check running before any of them, the duplicate-window hook built first and the reference hook second with a resolved rate cap inserted ahead of both, each rejecting a non-integer or non-positive figure as it is built and each ignoring anything but an entry; and what intake asks of an exit, five things in order — a sell, a trade with an open position, that position belonging to the strategy asking, a size above nought, and a size within what remains after exits already pending. 710 articles, 11,576 line references across 5,128 claims

  • Add one article on the Nexus side's fifty-fifth package, the figures a fill is assumed to carry: its size, price, notional and fees checked by assertion rather than by a test that could answer, the record's own validation having already required all four, the capital call running before any position is read on both the entry and the exit road so a failing call is answered as a failure there, and a missing trade or missing position raising only past it. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Praxis side's fifty-fourth package, the ledger booking one account's money: what it refuses to apply and in what order, an event for another account rejected before the lock is taken, then a registration answered first inside it, anything arriving before one rejected, a repeat registration rejected, and only past those a fill meeting the symbol test, with a close for an unknown trade silently ignored; and what a rebuilt ledger carries, its resumable state holding balances, per-trade realized and fee figures and open lots but no journal, so the posting behind each figure is gone, the lots returning in the snapshot's order and under average costing numbering one per trade. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Nexus side's fifty-third package, the submitting of a strategy's actions: what each action is submitted inside, a bound context carrying the strategy id and action type with trade and command ids where present and nothing naming the action itself, an abort forking away first, and a context builder raising an ordinary failure costing that action alone; and when a submission does not become a tracked order, skipped for a non-submitted status, a missing command id or no reservation — the ordinary course for aborts, exits and amendments — while the reservation is taken before the send, so a skip never means the account was left alone. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Nexus side's fifty-second package, the loop marking positions to the market: the lock it insists on, which must be the same object the risk record holds or construction is refused, a record holding none failing the same test while a loop given no lock is built with the question unasked; and the mark that ends a turn, symbols read inside whatever guard the loop was given and marks fetched outside it, a mark that is missing or not a finite exact figure ending the whole turn at that point so the later symbols go unasked and every position's unrealized figure stands as it was. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Praxis side's fifty-first package, the poller fetching the real venue's depth: what it is built with, its two spans compared against nought, its address and token tested for truthiness alone, its depth floor asked only for finiteness and positivity with no type checked, and its stuck-poll threshold required to be at least two while counting the first poll as one of its own, so a floor of two turns a snapshot away on the first repeat — and a not-a-number threshold passing and leaving that check unreachable; and starting and stopping it, a start raising while it already runs and otherwise clearing the flag, opening a session and spawning the loop, a stop setting the flag and awaiting the task while suppressing a cancellation alone, so another failure escapes with the task still held and the session still open. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Praxis side's fiftieth package, the whole-account basis beside the bar basis: what a trade is here, a run of consecutive in-position steps closed by the first step out and recorded as it stands where the steps end first, its returns compounded and reported as the run's gain rather than a sum; and how its windows are cut, by truncating each timestamp to a caller-named span defaulting to a day where the bar basis offers no choice, each window reporting its compounded return and that return over the fraction of steps in position, absent where no step held one. Move the module's cell to full, leaving the Praxis side at 60 full against 28 partial. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Praxis side's forty-ninth package, the translator turning a decision into a command: the five re-keyings, each one call into a shared re-keying handed the field's name so a rejection says which field it concerned, with a missing maker preference and a missing self-trade setting answered beforehand and one field carrying a table of equivalent words; and the builder that stands apart, the single-order mode's parameters going to their own builder before the per-mode table is consulted, both roads handing back an already-correct object unexamined, and the testing of an arriving mapping's values happening in that builder on one road and in the record filled on the other. Move the module's cell to full, leaving the Praxis side at 59 full against 29 partial. 710 articles, 11,576 line references across 5,128 claims

  • Add one article on the Nexus side's forty-eighth package, the two ways the account's signed figures change: each having a call that rejects a non-finite value, sets it and recomputes the drawdowns, while the record is a plain mutable one whose fields can be written straight — which a restore from the log does, leaving the drawdowns answering to the last such call and explaining why a recovery ends by handing the realized total back through one. Also state that the configuration record checks its protection-response mapping as it checks its credentials mapping, and move both modules' cells to full, leaving the Praxis side at 58 full against 30 partial and the Nexus side at 47 against 23. 710 articles, 11,576 line references across 5,128 claims

  • Add one article on the Nexus side's forty-seventh package, how a call across the seam is made: each refused outright where its function was never wired, four bridged onto Praxis's own loop from Nexus's threads and awaited for one shared span, the span running out asking for cancellation without waiting for it or reading whether it took so the far side may still be working on a call its caller gave up on, and registering an account and pulling its positions crossing directly with no span at all. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Praxis side's forty-sixth package, the two figures a replay works out itself: the worst fall, its peak seeded from the series' own first value rather than from the stake so a run starting below its stake reports nothing of that, the worst drop kept as a fraction of the running peak, a peak at or below nought skipped rather than divided by, and an empty series answering nought; and when the risk-adjusted figure is absent, left empty for a non-positive interval, for fewer than two returns and for a variance of nought, with a step whose previous equity is at or below nought forming no return at all and so able to starve the count, the answer otherwise being the mean over the square root of the variance scaled by the square root of the intervals in a year. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Nexus side's forty-fifth package, the records of how far down an account and its strategies are: what they refuse, sorting their figures into those that must be finite and at or above nought — the high marks, the falls, the worst falls, and the starting capital — and those held to being finite alone, the signed profit figures and the account's equity, which is the starting capital plus both; and the figures the account does not store, the three rolling-loss totals and the realized total summed over the strategies on each read, each reading one field so a change moves one total, and the sums moving when a strategy is added or dropped with no record changed. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Nexus side's forty-fourth package, the write-ahead log: its two readings, agreeing on a missing file, an unreadably short header and a torn tail while a header present and wrong raises on the strict read and reads as no records on the tolerant one, as do an over-cap length and a mismatched check, with the cap tested before the tear; and the check that stands apart, raising where the file is large enough to hold the marker and does not, made as the store is built and again before each tolerant read while the strict read tests the marker itself. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Praxis side's forty-third package, the record a host's settings are gathered into: what it refuses, three venue URLs tested for truthiness alone so a whitespace one is kept, three timeouts compared against nought with no type asked so a not-a-number passes while something that is no number raises from the comparison, and the credentials mapping's keys and the keys and secrets inside its values all truthiness-tested; and what it holds afterwards, frozen from the moment it is made so its own construction writes through the one call that goes round that, sealing copies of its two mappings and freezing its mode set, where the seal stops a caller mutating the mapping it handed in while the same bypass stays open for replacing a field entirely. 710 articles, 11,576 line references across 5,128 claims

  • State that a freshly built host state checks the capital pool for being a finite exact figure and then for being above nought before handing it to the record that checks both again — a fifth pair of rules standing in two places — and that what a tracked order locks in all is its amount plus its fee estimate. Record the two modules' remainder as an exclusion and move both cells to full, leaving the Nexus side at 44 full against 26 partial. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Nexus side's forty-first package, the loop reading outcomes back from Praxis: starting and stopping it, a start returning at once while a live worker is held and otherwise clearing the stop flag and spawning one, a stop taking the worker under the lock, setting the flag, releasing the lock and waiting five seconds unless told otherwise, and a stop with no worker held returning before the flag is set; and the stop that blocks a restart, a worker still alive at the join keeping its slot for exactly as long as it runs, the slot cleared only where it still holds that same worker, and one shared stop flag meaning a stop entering after a restart signals the new worker instead. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Nexus side's fortieth package: the keys that must match what they hold, the positions and per-strategy-mode mappings each rejecting a value of the wrong type and a key disagreeing with the identifier inside its value while the dust mapping and the two processed-id sets are checked for shape alone and the remaining fields arrive already self-checked; and what a tracked order must be, its three identifiers strings with content after stripping though stored unstripped, its three amounts finite non-negative exact figures with the unfilled part never exceeding the whole, its state one of the two live ones, and its timestamp carrying the UTC marker itself. 710 articles, 11,576 line references across 5,128 claims

  • Record as an exclusion the remainder of three Nexus modules whose uncited statements are now plumbing around checks already written — the capital record's walk over its own mapping, the platform stage's helper for a figure it needed and lacked, and the health loop's countdown stores, mark property, countdown construction, transition report and unread return — and move all three cells to full, leaving the Nexus side at 42 full against 28 partial. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Nexus side's thirty-eighth package, the store a host's state is written to and read back from: what a recovery takes before it rebuilds, the log's marker checked ahead of either road into it, the next record's number continuing from the last record the log still holds rather than the last written so a checkpoint's cut can set it far back or start it over, and the rolling-loss windows measured from the clock as recovery runs; and what a recovery writes at the end, setting the cumulative realized figure from the risk record's own total, which recomputes the current fall while the high-water mark and the worst fall ever are each kept at whichever is larger of restored and recomputed. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Nexus side's thirty-seventh package, the record of what an account's money is doing: what it refuses, its pool finite and above nought, five further figures finite and nought or more, its per-strategy mapping required to be a mapping of non-blank string keys to finite non-negative exact figures, rebuilt and written back over the field it arrived in; and the key it will not trim, a padded strategy id being refused here and by the strategy declaration, stripped and kept by the strategy base and the router, and carried as supplied by a command crossing the seam, so which record a padded name meets first decides its fate. 710 articles, 11,576 line references across 5,128 claims

  • Add one article on the Praxis side's thirty-sixth package, how a settings field is known to want a tuple: classed as wanting one where its annotation is a tuple or a union holding one, with wrappers stripped first and no other generic walked into so a list-of-tuples field keeps its list, the classification running over both settings tables at import with a record both name read twice and one answer kept, and every field's declaration resolved before the filter that keeps only the ones a record is built with. Also state that a change's settings come from a table of their own, a mode with no entry there refusing the change. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Nexus side's thirty-fifth package, the loop that reads health and moves the mode: its interval, held to being an int or float and compared against nought without finiteness ever being asked so a not-a-number interval is stored, with the running flag read three times per tick — at entry, again before anything is written, and again before the next countdown — which is one place further in than the checkpoint timer reads it; and the turn that ignores the mark, a hand-driven turn skipping that flag and scheduling nothing so a stopped loop still reads and applies, the reading handed to a wired mode controller and arbitrated against holds and risk rather than written, and the comparison closing a turn suppressing only the transition record. 710 articles, 11,576 line references across 5,128 claims

  • Add one article on the Nexus side's thirty-fourth package, what the platform's ceilings and the figures weighed against them must be: both records walking their own fields with every one optional and any supplied one required to be a finite non-negative Decimal, the utilization field in each held to a further ceiling of one by a test that runs after the walk so a finite share above one is turned back there while one without end never reaches it, and a refusal kept rather than answered with as it is found. 710 articles, 11,576 line references across 5,128 claims

  • State that a replacement of binsim's book with an empty side is refused before any level is examined, record the remainder of that module and of the credential store as an exclusion — properties handing back a snapshot's own number and moment, the choice of side, the walks' running totals, an empty protocol body, and the attempts around failures already named — and move both cells to full, leaving the Praxis side at 57 full against 31 partial. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Praxis side's thirty-second package, the store credentials are read from: what a record read as text must hold, parsing as JSON and being an object with api_key and api_secret each a truthy string, so an empty one is rejected while a whitespace-only one is kept and used, every other field ignored, and the road handed ready-made credentials parsing nothing at all; and the records a file is read into, parsed and decoded on the first request and cached only where the whole file passes, so a failed read is retried and a corrected file picked up while a successful one is never re-read, the decoding walking the file's own accounts and stopping at the first it rejects. 710 articles, 11,576 line references across 5,128 claims

  • Add one article on the Praxis side's thirty-first package, what a simulated walk refuses: both walks over binsim's book rejecting a non-finite or non-positive figure, an empty side answered with a different error naming the book as never filled, the spend walk's second return value reporting the unspent budget only where the book ran out and being forced to zero where a partial level was taken, so the rounding's sliver goes unreported, and the two sides handed out as copies. The package was re-scoped mid-flight: the walks themselves turned out to be written already, which the uncited-line map had not shown. 710 articles, 11,576 line references across 5,128 claims

  • Record as an exclusion the remainder of two modules whose uncited statements are now all declaration or pass-through — the way in to the trading side, whose nine protocol members stand empty and whose four routing calls hand straight on, and the replay runner's two calls into behaviour already written — and move both cells to full, leaving the Praxis side at 55 full against 33 partial. 710 articles, 11,576 line references across 5,128 claims

  • Add one article on the Praxis side's twenty-ninth package, the way in to the trading side: an empty account id and an account with no configured credentials both refused, the configuration copied as the way in is built, an already-registered account having only its venue credentials reapplied, and a new one registered at the venue before the trading side with that registration rolled back for two named failure kinds and left standing for any other. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Praxis side's twenty-eighth package, the module that runs a replay end to end: how a bar is settled, each round waiting for the account's command queue to empty and then draining outcomes until a round drains none, eight rounds allowed before it raises even where the eighth drained the last outcome there was, and the wait covering the queue alone so a scheme whose next slice is due later has already left it; and the mode a replay gives itself, writing ACTIVE into the account state under the positions lock before the first bar because no health loop runs to move it, with the replay recorded as the trigger and the moment taken from the replay's own clock. 710 articles, 11,576 line references across 5,128 claims

  • Add one article on the Praxis side's twenty-seventh package, the command that ends twice, which answers the oldest question the register carries: a venue cancellation of a bracket's protective order ends that bracket's exit command and drops it, the exit command id is derived from the bracket's own the same way every time, and the flatten following an unprotected remainder derives it again, reinstalls the command and reports its fill with nothing consulted about the id having ended. Answer the question row as far as the wiki can — the path is written; whether the second report is intended is a decision for Praxis — and move the outcome translator's cell to full now that nothing hangs over it, leaving the Praxis side at 53 full against 35 partial. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Praxis side's twenty-sixth package, the translator turning a Praxis outcome into the shape Nexus reads: what it remembers, its ceiling on finished command ids having to be a positive integer which a boolean true passes, finishing a command filing its id and evicting the oldest past the ceiling while discarding its own record, and an outcome for an evicted id treated as a brand-new command; and the words an ending carries, a rejection given a stock word where Praxis recorded nothing or an empty string while a whitespace-only reason is passed through to a record requiring something after stripping, so building it raises, an expiry crossing with no reason and any other ending carrying whatever Praxis had. The cell stays partial: a question the register has carried since the first package still hangs over this module, and the next package answers it. 710 articles, 11,576 line references across 5,128 claims

  • Add one article on the Nexus side's twenty-fifth package, the interval the checkpoint timer takes: rejected unless it is an int or float above nought with a boolean caught by a test of its own, never required to be finite so a not-a-number interval is stored, which narrows the pair across the seam to its one real difference against the mark sampler; starting ignored while the timer already runs; and the running flag read again at each tick and at each rescheduling, so a stop reaches the chain three ways. Move the cell to full, leaving the Nexus side at 39 against 31. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Praxis side's twenty-fourth package, the sampler recording what a paper account's holding is worth: what it is built with, its account and pair tested for truthiness alone so a whitespace name is kept, and its interval rejected at or below nought by comparison with no check of its type, so a not-a-number interval makes the wait between samples expire at once and leaves the loop sampling without pause while an exact-kind interval makes that wait raise outside the catch covering a sample, ending the task; and starting and stopping it, starting raising while a task is still running and otherwise clearing the stop flag and launching the loop, stopping setting the flag, cancelling and awaiting while suppressing the cancellation alone, so a task that failed another way re-raises out of the stop and is still held afterwards. Move the cell to full, leaving the Praxis side at 52 full against 36 partial. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Nexus side's twenty-third package: starting and stopping the timers, where starting is ignored while the loop already runs and otherwise schedules one countdown per declared timer from a mapping copied at construction, stopping clears the flag and cancels every pending countdown while a countdown already firing is never cancelled and reads the flag itself before calling the strategy, and a stopped loop can be started again; and what the walk that runs the checks is built from, its stage order having to be a tuple holding every stage exactly once and its checks a mapping with a callable entry for each stage the order names, entries the order does not name being neither rejected nor retained. Move both cells to full, leaving the Nexus side at 38 against 32. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Nexus side's twenty-second package, three records the file ledger marked partial with a tail of declarations each: what the capital stage refuses, a reservation lifetime held to being an integer above nought with a boolean caught by a test of its own, an omitted lifetime passing nothing on so the controller's default stands, and an empty denial reason replaced by a standing message; and the name a strategy answers to, kept stripped of surrounding blank space and refused where the stripping empties it, unlike the shared helper Praxis names its records by, with the router stripping both when filing a wrapper and when looking one up so a padded name still finds it. Record the remaining declarations as an exclusion and move the three cells to full, leaving the Nexus side at 36 against 34. 710 articles, 11,576 line references across 5,128 claims

  • State the last statements in the two modules the file ledger marked partial whose remainder was either a statement already written on the other side of the seam or a wrapper handing straight through to a library: the Nexus logging arrangement's stamping in universal time, its writer on standard output, its plain binding of context and its serializer rendering to text are the same statements as the Praxis side's, and neither price estimator walks the book at all where the book has no middle. Record the rest as an exclusion and move both cells to full, leaving the Praxis side at 51 full against 37 partial and the Nexus side at 33 against 37. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Praxis side's twentieth package, the inbound check on a change, which the file ledger marked partial with thirteen of its fifty-one statements uncited, almost all of them in the deciding that two articles already name without describing: what counts as raising what a buy commits, a sell cleared at once, a ladder routed elsewhere, everything else judged on the commitment prices listed for its mode where only a single order and an iceberg list any, a named price above its original or with no original to bound it refused, and two listed paths that nothing can reach; and how a ladder's change is weighed, a buy's compared as one quantity-weighted price total against another, each side taking amended values where amended and original ones otherwise, a side with no shares giving every rung an equal share so two sides of different rung counts compare as averages, and shares that do not match the new price count refused outright. Move the module's cell to full, its three remaining lines recorded as an exclusion, leaving the Praxis side at 50 full against 38 partial. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Nexus side's nineteenth package, the stage weighing the account's losses, which the file ledger marked partial with eleven of its seventeen statements uncited: what a risk limit must be, each of the seven being optional while one supplied must be a finite exact figure at or above nought, an omitted limit skipping only its own comparison since every figure is worked out and paired beforehand, and the comparison being strictly above so a figure sitting exactly on its limit passes; and the levels the stage never reaches, the walk answering with a breach or with nothing and never with a warning or a halt, so the branch turning a breach or a halt into a refusal has one arm that cannot fire here while the identically written branch in the health stage has both live. Move the stage's cell to full, leaving the Nexus side at 32 full against 38 partial. 710 articles, 11,576 line references across 5,128 claims

  • Correct two more articles against a second reader's pass, over the statements the first pass did not cover: the moment behind the rolling loss windows is required to carry a zone that yields an offset for it rather than merely a zone, and the article split out during the first round's corrections is rewritten, the weights being used rather than merely counted, a weight below zero being caught only among those actually read, and no such weight being able to reach the split at all because both parameter records that supply weights already require finite positive exact figures summing to one. Its subject is now what the split asks of its weights — nothing — where that is asked instead, and why the final weight is never read. 710 articles, 11,576 line references across 5,128 claims

  • Correct eight articles from the thirteenth to the eighteenth packages against an external reader's pass, the first such pass since the readers became unavailable fourteen packages earlier. Two corrections are claims that held of a function and not of the one path reaching it: the day grouping's dependence on a caller's timezone, which the sole caller fixes to UTC before the figures see it, and an unknown price being left out of everything, where in fact the bar keeps its place and splits a position spanning it into two separately costed trades. The rest narrow a statement to what its citation carries: cancelling at shutdown reaching only what is still queued then, a reversed pair of naive timestamps being refused by the ordering rather than by the frame reader, a backfill sending a start timestamp only where it was given one and setting a cursor only from a full page of parseable ids, an even split's fractional count being refused by the arithmetic rather than the division alone and a whole-number lot size not being refused at all, the children of a lot-free split not dividing a total exactly where it carries more digits than the exact kind's precision, and a comparison with zero raising rather than admitting a non-finite figure of the exact kind. Rewrite two of the eight around what survives, and record the pass and its classes in the register. Split what a weighted split refuses into its own article, the corrections having carried its host past the word cap, and take the chance to state what the weights are not asked and what a weight below nought does on each road. Sweep the same precision correction through the one other article claiming an even split comes to its total exactly. 710 articles, 11,576 line references across 5,128 claims

  • State the last uncited statements in the six modules the file ledger marked partial with the fewest left after the previous pass — a start reading no snapshot file answering nothing rather than failing, the strategy wrapper refusing anything that is not a strategy and answering to the wrapped strategy's own name, the moment the rolling loss windows are measured back from having to carry a zone, a command carrying the name of the money set aside for it where any was, and the weighted split making the same two checks as the even one over the number of weights — extend one citation that stopped at a call without reaching what it does, record the remaining lines in the strategy loader, the translation, the loss figures and the weighted split as an exclusion, being lines that carry a value along to the line that uses it, and move the six cells to full, leaving the Praxis side at 49 full against 39 partial and the Nexus side at 31 against 39. Split what a start reads back from a checkpoint into its own article, the parent having outgrown the word cap, and settle one register row whose disposition held the weighted split short of full by carrying a suggested Praxis check as an open question. 710 articles, 11,576 line references across 5,128 claims

  • State the last uncited statements in the five modules the file ledger marked partial with the fewest left — an entry's moment having to carry a zone, how the four closed-trade figures are reached, a health evaluator built with no policy weighing against built-in thresholds, and the execution-quality measures being checked ahead of the split between a fill's list and any other outcome's — extend one citation that stopped on the line before its raise, and move the five cells to full, leaving the Praxis side at 48 full against 40 partial and the Nexus side at 26 against 44. Also correct the ledger's Nexus summary, which still said no module on that side was accounted for in full. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Praxis side's sixteenth package, two small modules the file ledger marked full with a handful of uncited statements each: the window a backfill opens, where a pass holding no cursor asks by whatever start timestamp it was given and never sends an end timestamp, so the asking is open-ended at the far side rather than covering a day, only a full page of parseable ids setting a cursor that every later page is then asked by, and the venue's reader refusing a cursor and a timestamp together; and what an even split refuses, the quantity held to being an exact finite figure above nought while the child count is held only to being at least two, so a count carrying a fraction reaches the division and the division refuses it by kind, and the road with no lot size taking the quantity over the count with no smallest child at all, its final child carrying the remainder of what the division produced rather than restoring digits the division dropped. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the Praxis side's fifteenth package, the module reproducing the training side's distribution figures, which the file ledger marked full with sixteen of its hundred statements uncited: what the four series are read as, every one converted to floating-point numbers before a single check runs, so a true-or-false and the character for one both satisfy the test that a prediction be one or nought while a value with no numeric form refuses the whole call as a prediction and, as a price, makes that bar untradable and splits a position spanning it into two separately costed trades; where the peak a fall is measured against begins, seeded at the stake the curve starts from rather than at the curve's own first value, so a first evaluated bar below the stake is already in a fall, and the opening moment set beside it that no walk can read; and the day a bar is filed under, the UTC calendar day of each bar's own opening stamp as the sole caller supplies it, where the window those bars were chosen by was filtered on their closing stamps, so a bar opening before midnight and closing after it is filed under the earlier day. Also correct a candidate the twelfth package left open, which claimed a trade counted before the first entry mark: the marks are derived from the held bars themselves, so the first held bar is always a mark. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Praxis side's fourteenth package, the service that takes a replay request over HTTP, which the file ledger marked full with seventeen of its seventy-three statements uncited and which was the widest such module left: the moments a request names, where a trailing capital Z is rewritten to an explicit zero offset and every other form goes to the standard reader untouched, so a lower-case z is refused and a bare date is taken as midnight with no zone, and where a missing zone is caught by the ordering comparison when the other edge carries one and by the frame reader when neither does, each refusal reaching the asker as the raiser's own words rather than a message written for the field; and what stopping the listener does, the shutdown attached to the server's cleanup waiting for the run already under way while cancelling everything queued behind it, and a cancelled run's record, written once where the work was queued and never again, still answering as running for as long as the service can be asked. 710 articles, 11,576 line references across 5,128 claims

  • Add two articles on the Praxis side's thirteenth package, the tracker the health figures are made from, which the file ledger marked full with sixteen of its thirty-three statements uncited: what recording one request refuses, a latency held to being a finite number at or above nought with a true-or-false refused outright, so an infinity and a figure that is not a number are both turned back where five records elsewhere on these two sides only compare with nought, and a success flag asked for its type so a whole number of one is refused where another record turns on a flag it never asks about; and what the lock covers, the run of failures and the lock made together, recording taking the lock to append both stores and move the run, and a report taking it only to copy the two stores and the run before letting it go, so the slow-end latency and the failed share are worked out outside the lock from copies taken inside it and a request recorded meanwhile lands in the stores rather than in that report. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the Praxis side's twelfth package, the three helpers inside the module reproducing the training side's distribution figures, which the file ledger marked full with forty-eight of its hundred statements uncited: what counts as one trade, the bars numbered into runs by a running count of the entry marks with one trade being the held bars sharing a number, no trade counted at all where no bar is marked, and a trade's return reached by multiplying its bars' returns rather than adding them so two bars of a tenth give just over a fifth; how the same bars are cut into days, filed by the day each moment falls in and walked oldest first, each day carrying its compounded return in basis points and that return over the share of its bars holding a position, the second given as nothing at all where no bar of the day held one, so a reader averaging the days must decide what to do with the gap; how a fall from a peak is recorded, a running peak that only rises measuring each fall and one test with three arms opening an episode on the first fall, deepening it while the fall worsens, and closing it on recovery with a depth in basis points and a length in days; and the falls that never ended, an episode still open when the walk finishes recording its depth and no length, so the list of depths and the list of lengths need not come to the same size and cannot be paired off position by position past that point. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the Praxis side's eleventh package, the poller keeping the kept prices fresh and the path the host takes to stop its pollers: what the poller refuses and answers, an empty symbol and an interval at or below nought turned back by comparison and not by type so a figure that is not a number is kept and then waited on, an answer that it is running while its task exists and has not finished, a second start refused by reading that answer, and the stop signal cleared before the task is made so a stopped poller can be started again; the gap between polls, written as a wait on the stop signal bounded by the interval rather than as a sleep, so the interval is the longest the gap can be and a stop is noticed at once instead of after it, which is how this loop differs in shape from the others that set a timer and cancel it; and the stop that waits, one poller's stop waiting for the turn in hand and swallowing the interruption it caused itself before forgetting the task, with the host walking all of its pollers and waiting for each under a single ten-second limit shared between them rather than given to each, keeping the list where the walk fails or runs out of that time and emptying it only where the walk finishes. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the Praxis side's tenth package, the settings for orders spread across several prices and one consequence of how an even split rounds: what a ladder's prices must be, each a positive finite decimal and all of them rising throughout or falling throughout, which allows a descending ladder and turns back a repeated price without any check looking for one, since a repeated pair fails the rising test and the falling test alike; what a ladder's weights must come to, optional with the checking stopping where they are absent, and otherwise matching the prices in count, each a positive finite decimal so no price can be named with nothing meant for it, and together coming to exactly one — the only check reading the weights as a set, and the reason the other two do not suffice; and the quantity a lot step leaves behind, an even split reaching the total exactly where no step is known because the last part takes the remainder whole, against a split where a step is known flooring that last part as it floors the others, so ten split three ways with a step of three sends nine, the shortfall bounded by one step because a last part flooring to nought is refused outright. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the Praxis side's ninth package, two modules the file ledger marks full with none of their own behaviour cited: what the report of how the venue is answering refuses, four of its figures walked for being finite numbers at or above nought with a true-or-false refused outright, two of the four then capped at one, and the count of failures in a row reached by neither walk and held instead to being a whole number at or above nought; that the same report exists as separate code on each side of the seam holding the same five figures to the same rules, with neither copy naming the other and nothing comparing them, so a rule changed on one side alone would show only when a report accepted on one side was refused on the other — the third such pair the wiki has found; what the bucket pacing calls to the venue refuses, a rate or a capacity at or below nought by comparison rather than by type, starting out holding its capacity so the first calls go straight through, and refilling on every take by the time elapsed times the rate while capping the total at the capacity so a long quiet spell buys no unlimited burst; and the token taken before the waiting, the wait worked out first and the token then subtracted whether one was there or not, so the count can fall below nought and lengthen every later wait, the lock let go before the waiting because the debt is already recorded, and a wait cut short part way adding the token back so nothing is charged for a call never made. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the Praxis side's eighth package, the behaviour left uncited in modules the file ledger already marks full, found by parsing each module and comparing the statements inside its function bodies against the lines the articles cite: the questions four records answer about themselves in a line each, which accounts increase on the debit side and which do not, whether a command or an order was sized in money — answered by the presence of a money amount rather than by a flag beside it — and whether a position has closed, answered by its amount standing equal to nought so that an amount written to two places answers as a plain nought does; the escape in the one check every name on this side goes through, which lets a none by where the caller asked for optional and otherwise refuses a none and an empty text by the same line, and which never trims, so a name of blank space alone is kept here where the records across the seam trim before refusing; what a clock refuses and what stands in, the replay clock turning back a start with no zone and keeping whatever zone it is given without converting it, where a price store given no clock uses one answering in universal time; and the severity an alert gives back, which is the one actually recorded after an unknown one is turned into a warning, read again by the call that also posts so the line written and the thing posted agree. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the Nexus side's eighteenth package, the behaviour left uncited in thirteen small records, found by comparing every line an article cites against every line that runs: what the record of how one report was handled refuses, its kind one of the named ones and a reason required where it says it failed and refused where it says it succeeded, while the field both of those checks turn on is never asked to be a flag, so text put there is read for truth alone and sends the record down the success arm; what one entry in the log refuses, three kinds of entry, a moment with no zone demanded, bytes for what it carries, and a number ordering the log that is refused below nought and asked nothing else, so a true-or-false or a fraction stands as a number there where the record's other three checks each ask a type; the two cuts across the six kinds of outcome, four answered as endings and two as fills, the full fill answering to both and the acknowledgement to neither, so neither question alone places a kind — the candidate the twelfth package's re-seed left open; and what stands where nothing was set, a signal handing a missing key back to whatever default the asking named while the three breaker limits are simply absent until set, so an unconfigured policy turns every breaker off without a line saying so, and neither record notes anywhere that a default was taken. With these, thirteen modules move from partial to full. 710 articles, 11,576 line references across 5,128 claims

  • Add seven articles on the Nexus side's seventeenth package, the last two modules the file ledger reached only by citation, closing that list: what the record of how one instance is configured refuses, its account and venue usable text, its duplicate window a whole number above nought with a true-or-false refused outright, two further figures held to that same rule where given and two more to being finite decimals at or above nought, its self-trade setting one of the named ones, and its two shutdown timeouts finite numbers above nought; the mapping it accepts where two records beside it accept only a dictionary, so which objects a caller may hand over depends on which record receives them; the keys it rewrites, two of its mappings trimming theirs as they read and each refusing a key left with nothing as well as one colliding with a key already taken after that trimming, so a mapping that would have quietly lost an entry is refused instead; the one check it makes that reads a mapping whole, each share a finite decimal above nought and at or below a hundred and the shares summed as they are walked with a total above a hundred refused, so two shares of sixty pass alone and fail together while a total below a hundred leaves part of the pool allotted to nobody; the field that must name its yardstick, optional, trimmed and lowered and written back over itself, accepted only as the one name allowed, with a deviation cap of either kind refused where no source is named — the only check this record makes weighing one of its fields against another; what the loader asks of a path, relative and ending in the module suffix, with the base and the joined path both resolved before the joined one is tested for staying inside, so a path climbing out and a link pointing out are both caught, and the file then required to be there; and what it asks of what it found, the module run with any failure wrapped as one error naming the file, then something required under the expected name that must be a class, must inherit from the base, and must not be the base itself, with building it wrapping any failure as one error naming the strategy instead. 710 articles, 11,576 line references across 5,128 claims

  • Add six articles on the Nexus side's sixteenth package, the six modules left on that side of the seam that the file ledger reached only by citation: what the translation from a passed decision to an instruction refuses — a decision that did not pass, a moment without the universal-time marker, an empty reference for the command, and a change refused by name because that road carries none — with the mapping of four kinds of action standing as the last thing between an action and an instruction; the kind of command nothing on this side builds, three being named and the mapping reaching two, so the one for amending an order is built nowhere here although the command record still carries the rules for one; what an exit is given where it asked for nothing, a single shot, a market order and sixty seconds standing in for a way of working, a kind of order and a deadline it left out, where an entry is given none of the three and an action that is not a new order has all three set aside, and where one statement settles that a spend and a size can never both be carried; what the record of money moving into or out of an account refuses, its two names walked for usable text, its moment and that moment's marker weighed by one test, its amount asked in one test to be a decimal, finite and above nought, and its direction held as text against a fixed pair so a word differing only in case is turned back; what the record of a disagreement with the venue refuses, three names, a moment, two finite figures, and the two of them agreeing — which is the one check it makes that puts two of its own fields side by side, and the reason the record cannot be made to report that nothing is wrong, its reported gap never being nought; and the three sets of named values declared again on this side so the strategy layer need not reach into the trading side's package, each a copy rather than the thing itself with nothing checking that the two lists still agree, alongside the queue outcomes come back through, which weighs neither the queue nor the wait it is handed. 710 articles, 11,576 line references across 5,128 claims

  • Add eight articles on the Nexus side's fifteenth package, the three modules that decide whether an account may trade, which the file ledger reached only by citation: what the record of how the trading side is faring refuses, four of its figures walked by name and each held to being a finite number at or above nought with a true-or-false refused outright, two of those four then capped at one where the latency and the drift carry no ceiling at all, and the count of failures in a row reached by neither walk and held to being a whole number instead; what the policy refuses, ten thresholds walked for finite numbers and three for whole ones, four orderings each checked as one chain of two comparisons so that equal thresholds pass while a middle one out of line does not, and a ceiling of one put on six of them by a walk that runs after the orderings; how the mode is settled, by one chain of five measures against their halting thresholds and a second of four against their acting ones, each comparison reached rather than passed so a measure exactly at its threshold fires, and the answer the worst measure rather than any sum of them; the four alerting thresholds checked as the policy is built and read by an ordering and then weighed against no measure anywhere, so setting one changes what the policy accepts and nothing about what it decides; what stops a turn, the seconds between turns refused at or below nought and for a true-or-false while a figure that is not a number and one at infinity are both let by, the check comparing where the snapshot's own figures are asked for finiteness, and a failed refresh told and passed over where a failed fetch or a failed weighing abandons the turn and leaves the mode alone; the two roads a turn's answer takes, the direct write doing nothing where the mode already agrees and otherwise putting a whole new state in place with a fresh moment carrying the universal-time marker, against the road through the controller which stores the answer and settles the mode again over every standing hold, so it can leave a mode the turn did not ask for, with the pending halt told only after the lock is let go; what the five records of the mode refuse, a hold's flag, reason and optional moment, a mode's named value and usable driver, a strategy's reference, and the two gatherings of holds that check nothing at all, where a hold may stand active without saying since when; and the two moments asked for nothing beyond being moments, one of them defaulting to the earliest moment there is, which carries no zone, where the records crossing the seam are refused without the universal-time marker itself. One further finding is recorded in the register as already written rather than written twice. 710 articles, 11,576 line references across 5,128 claims

  • Add six articles on the Praxis side's seventh package, the four modules the file ledger had marked uncovered and the Nexus module that repeats the Praxis logging, closing the last of the ledger's uncovered rows: what a fill's own record requires, a loop holding seven of its fields to one shared check that refuses an empty one, a moment that must carry a zone giving an offset, and the venue's own name for the trade left off that loop so it may be carried empty, which turns the key for spotting a repeat from that one name into four other fields taken together; what that record never asks, its amount and price refused at or below nought and its fee below it, with no check asking any of the three to be a finite figure or a decimal, and its side and its maker flag weighed in no way at all, so a record may name a side that is not one of the named ones and pass; that nothing builds the record, the module named once where the domain's types are handed on and no statement in Praxis calling it, so every refusal it makes runs only when a test builds one while the running system reports a fill as the event record instead; the name a bracket's protective exit is given, one letter joined to the entry's name with a dash, nothing asked of what is handed in, callers in both the launcher and the manager sharing the one helper, and nothing in the Nexus checkout working the name out at all, so the side that reads it is handed it rather than deriving it, where the module’s own docstring claims the derivation is a contract both sides must compute identically; what the Nexus logging adds over the Praxis arrangement already written up, a binding that lasts a block and puts the keys it was given back as they stood, on the way out through a raise as much as through the end, where the level lookup and the emptying of the root are the same statements on both sides; and the three records that refuse nothing, declaring their fields and checking none of them, one of the three able to say whether its lifecycle has finished. Four further findings are recorded in the register as already written rather than written twice. 710 articles, 11,576 line references across 5,128 claims

  • Add seven articles on the Nexus side's fourteenth package, the five records left on that side with refusals in them, none of which any article cited before: what the event logged so a count of losses can be rebuilt is checked for, its strategy's reference and the kind it names each having to be text with something left once trimmed, its moment a moment carrying the universal-time marker itself, and the result it carries a finite decimal figure, where a whole number is refused however ordinary and no check of the record's own weighs that figure against nought; the one field of that event allowed to be empty text where a blank one is refused, the check asking whether the text has content before it trims it and the field having no none at all, so empty text is the only way the record can say the field was not filled in; what the signal a predictor hands back is checked for, its reference, a dictionary of values whose every key must be text and whose whole, floating and decimal values must each be finite, with a value of any other kind weighed in no way at all, and its moment held to the same marker; the sealing three records on that side do by one statement each, copying the mapping they were handed and sealing the copy over the field it arrived in, which stops a caller changing which entries the record holds and leaves every entry pointing at the object the caller handed in, so reaching into one of those and altering it alters what the record holds — closing a candidate the eleventh package's re-seed left open — with a signal crossing a process boundary handed over unsealed and rebuilt on the far side by running every one of its checks again; what the settings a strategy is configured with ask and answer, one check that what was handed is a dictionary and nothing else weighed, and a missing setting answered with whatever default the asking named; what the word that a bracket's protection was lost and dealt with is checked for, four fields walked by name and each held to the same rule, a moment and its marker weighed by one test rather than two, and an attempt number that must be a whole number at or above one with a true-or-false caught by a test set ahead of the one for whole numbers; and the three limits that trip the breakers, each able to be left out and passed over before its own figure is looked at, where a limit that is given must be a finite decimal figure above nought, so nought is refused and leaving a limit out is the only way to leave it unset. 710 articles, 11,576 line references across 5,128 claims

  • Add seven articles on the Nexus side's thirteenth package, the two records Nexus keeps around an order, whose own checks no article reached before: what the record of money held is checked for, its own reference and the reference of the strategy that asked for it each having to be text with something left once trimmed and each of its two sums a finite figure at or above nought, where both checks refuse a figure below nought rather than one standing at it; the moment it was made at and the moment it runs out at, each having to carry the universal-time marker itself and the second having to stand strictly after the first, these being the only pair of its fields it weighs against each other, so a record cannot run out at the instant it was made; what it is asked once it exists, being the sum of its two figures, worked out on each reading rather than read from a field and named by none of its own checks, and whether it has run out, which refuses a moment handed in from outside where every other refusal of the record weighs a field the record holds, and answers yes at the moment it runs out as well as past it; what the record of the attempt must carry, a granted one something in its lock field and nothing in its reason field and a refused one the reverse, as four checks standing on their own, none of which asks the type of any of its three fields where the record beside it asks the type of all six of its own; what the note Nexus needs to read a report is checked for, two references that must be usable text and a third held to the same rule wherever it is given, a side that must be one of the named ones, two yes-or-no fields that must be yes-or-no, and a worth and an expected fee that must each be a finite figure with the worth above nought and the fee only at or above it; the size that note may leave out, absent only where the order grows a position, an absence clearing that one check, and otherwise a finite figure above nought, those two tests reading nowhere the flag that allowed the absence; and the flag saying the order grows a position, which must be a yes-or-no, never weighed against the side so that a buy may be marked either way and a sell too, read turned round to answer whether the order reduces a position, and unable to stand true alongside the other yes-or-no the note carries, a note setting both being refused by that check, which either of them standing false clears. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the Nexus side's twelfth package, the report the trading side sends back, which no article reached before: what every one of those reports checks on itself, its own reference and the reference of the instruction it answers each having to be text with something left once trimmed, its kind one of the named ones, its moment a moment carrying the universal-time marker itself, and a size still working, where one is given, a finite figure at or above nought, that last check being reached after the report has already been sorted by whether anything filled and still asked of every kind, so the checks every report answers sit either side of that sorting rather than all of them before it; what a report of a fill must carry, a size, a price, an amount and the fees paid, each refused where absent and refused again where not a finite figure, three of them having to stand above nought where the fees need only be at or above it, and the same four forbidden to a report carrying no fill, each refused on its own; the reason such a report may carry, where a refusal must give one with something left in it once trimmed while a cancellation may give one or leave it out, each of the two refused on every kind but its own; and the two measures it may carry, taken by name in one loop where an absent one is passed over before any figure is looked at while a measure of nought goes on to the checks, refused on a report carrying no fill, and required to be a finite figure where the report carries one, so on a report carrying no fill an absent measure passes where a measure of nought is turned away. 710 articles, 11,576 line references across 5,128 claims

  • Add four articles on the Nexus side's eleventh package, the instruction Nexus hands the trading side, which no article reached before: what that instruction checks on itself as it is made, its reference, account, venue and symbol each having to be text with something left once trimmed, its kind one of the three named ones, the amount it names a finite figure at or above nought and its moment a moment, with thirteen further things that may be left out refused wherever present and wrong, every one of those tests standing behind a test for absence, and a deadline given as a true-or-false caught by a test set ahead of the one for whole numbers because such a thing would otherwise pass as one; the marker its moment must carry, which is the universal-time marker itself rather than any zone standing at that offset, so two moments naming one instant are treated differently and the other handoffs the same connector makes accept the zone this one refuses; the settings it rewrites, where anything that is not a mapping is refused and a mapping is copied, sealed and written over its own field, so a caller altering what it handed over changes nothing the instruction carries, this being the one check of the module that changes rather than refuses; and what each kind must carry, a new order naming a side, a self-trade setting and either a size or a spend but never both or neither, where a change and a cancel may carry none of those eleven things at all, each kind weighed against its own copy of that list rather than one they share. 710 articles, 11,576 line references across 5,128 claims

  • Add six articles on the Nexus side's tenth package, the strategy cluster, which no article reached before: the wrapper every strategy sits behind, built for it alone as the start builds the strategy and holding a lock no other strategy's shares, which every way in takes and holds across the call, so a strategy reached through its wrapper is asked one thing at a time while the lock one strategy is held under is not the lock another is held under; which roads reach a strategy, eight of them, each reached outside the tests from a single line — three where a start begins it, hands back the state it saved and replays an event to it, two where a stop asks it to finish and asks for its state to keep, and one each for a prediction, an outcome and a timer — every one of those lines on the Nexus side, with Praxis's own modules naming none of them; what a strategy must provide, seven things it has to supply before it can be built at all and an eighth already supplied whose body discards the record it is handed; what the thing routing to a strategy refuses, three things when it is asked for one by name and five more when the whole set is built, with the name trimmed both as the wrappers are taken in and as one is looked up; what a turn of a timer does, set going by a countdown that fires once, marked so it cannot hold the process up and kept under a name joining the strategy and the timer, testing whether the loop still runs before it fetches what the strategy is handed and again after, asking for the next turn even where the work raised but building no countdown where the loop has stopped by then; and what a strategy is handed, a sealed thing checked five ways before a strategy sees it, its own fields unable to be rebound once built, with the settings beside it built empty on every road that hands any. 710 articles, 11,576 line references across 5,128 claims

  • Add three articles on the Praxis side's sixth package, which is what verifying the fifth turned up rather than a module with no page: what the clearing of the notes saying an instruction's figures are unsaved cannot reach, that clearing working from a list copied before the save and testing only the entries the list holds, so a note for one instruction can fall outside the list another instruction's save copies and be left standing by it, where a note always falls inside the list its own save copies because it goes on before that reply is queued, with the clearing being the one deletion the list of notes ever takes, and such a note standing for figures that save wrote down or for figures it did not with no way to tell the two apart; what the lock over the account's money is doing when a sale's result is written down, which is nothing, by either of the two routes that reach that line: where the sale frees money set aside, the lock is taken inside the freeing and handed back as it answers, before the line goes down; and where it frees none, nothing reaches for the lock at all and the line is still written; and what a save of the whole picture waits on, the lock it takes over the account's money being the money's own, made once and handed out by a reading, which ten of the money's roads take, the one that sets money aside raising five refusals before taking it and then holding it from the clearing out of what has expired through to whichever ending it reaches, on a road that asks for no save of any kind itself. A fourth was drafted and withdrawn: the save a left-over note can ask for turned out to rest entirely on facts already written, the test's third arm and the acknowledgement that sets neither of the other two, so the register carries the finding and no article does. 710 articles, 11,576 line references across 5,128 claims

  • Add seven articles on the Praxis side's fifth package, the half of the seam between the two systems that the Nexus run left open: how a note that an instruction's figures are unsaved is cleared, which happens in batches, so one instruction's save clears the notes standing against others while a save an operator asks for clears none; what can stop the line that closes a reply going down, the ten-second wait that leaves the write still going and the road that never attempts the line at all; what ends a start squaring its holdings, which is a holding the trading side does not mention; which starts weigh nothing against nothing and so ask for no save; the road an arriving reply takes and what it never reads, with the one account road that drops a reply and the one that applies its figures later; when the part that saves state runs with neither of the two locks over what it reads, being the window before the start has handed them over; and which of its three kinds of save take which of those locks. 710 articles, 11,576 line references across 5,128 claims

  • Add five articles on the Nexus side's ninth package, which hosts save their state and the roads into the log nothing takes: which hosts the save-on-a-timer job runs on, switched on only for a live account as that account's own thread starts its background work and switched off again on the way down, where a run over bars that already happened builds the same machinery, never switches it on, and never reaches the save a stopping host makes either, so a full picture gets written on such a run only where its own start asks for one, though the run still writes single changes as it works replies through; what a failed save costs that start, which the first article had no room to hold once it outgrew its cap, the failure caught where the save is asked for and turned into a start failure that nothing on the way out catches, left to the account's own thread on a live host and to the run's closing step on a run over past bars, which shuts the account down before the failure leaves; which clock a line in the log is stamped off, always the real time of the machine, because the part that writes those lines is built without a clock and handed none, so a run driven by a made-up clock stamps real time onto its records while the money, the checks, the modes and the predictions all read the made-up one; the road that empties the log, wiping the file complete with its opening mark, which nothing in either system calls, and which the next write would repair rather than refuse; and what writes the name a success records, the label of a reply from the venue kept so a repeat of it can be turned away, which nothing saves on its own account: the save a host asks for after a reply turns on three marks that keeping the label sets none of, so the label goes to disk only on the back of the next save something else asked for, and a host that stops with no save of any kind behind it leaves a log and a picture that never held the label, while the turning away of a repeat reads that label where it stands in memory, so the wait costs nothing until a restart. Add four facts to articles already written: the position a start takes in from Praxis, which rides the same test as the two changes that article already names and is written nowhere else either; the moving line the clearing of old entries draws, read off the clock as the clearing runs, so an entry one clearing keeps the next one throws away with nothing about the log having changed in between; the six places turning a line back into a record can fail, where one catch inside the step covers a missing field alone; and the removal in the account thread that reaches nothing where the build it wraps is what failed, the runtime only reaching the list it removes from once that build has returned

  • Add eight articles on the Nexus side's eighth package, the log and the figures that reach it: how a record reaches the log, each line given a short head saying how long it is and a number worked out from its contents, forced out to the disk before the write is called done, a file whose end was left torn trimmed back to the last sound line before anything new goes on, and a file whose opening mark reads wrong refused outright; what a damaged record costs, the read stopping at the first line that fails any of its checks, a short head, a length past the cap, a length past the file's end, a payload that runs out or a checksum that does not match and keeping only what came before it, so one bad line hides every good line after it, alongside a second way of reading the file that raises where the first keeps quiet and that no code under the package calls, which left with the unpack fault as an eighth article when the subject outgrew its cap; which of a host's changes reach the log, an operator halting or resuming the whole account written down every time and an outcome from the venue only where working it through succeeded and one of three marks is set, while the running valuations of what is held are written on nobody's account and ride along with whatever else is saved; how the checkpoint rewrites the log, emptying the file and writing the survivors back into that same file with no side file and no move, so a failure part-way through leaves the file holding less than the history it stood for, a file too short to carry the opening mark passing the one guard unread; the timer that asks for those checkpoints while a host runs, measuring each wait from the end of the last save and passing over a failed save, the turn after it making a whole new one rather than finishing the last; the cap on how fast entries may be let by, counted in one allowance for the whole account so a busy strategy can spend it all and leave the others turned away; and the window that turns a repeated order away, keeping labels against the strategy that sent them for one second, its refusals for an order naming no side and for one naming no label never reached from a live request, Praxis filling both in before it builds one

  • Add six articles on the Nexus side's seventh package, the last of stopping and what sits either side of the checks: what a stopping host saves of its strategies, asking each to describe itself in bytes and writing each to a side file and moving it over the old one, a strategy that cannot describe itself leaving the file it had before standing; the last record it writes, a final picture with the log behind it cut back to recent activity, then the account handed back, each step wrapped so a failure is written down and passed over; what the first stage weighs before it reads trading state, which is a name with space around it, a request worth nothing and a strategy whose whole allowance is nothing, the name and the allowance already settled when the settings are read while a request to close or to alter an order is named as exempt from the amount test and the allowance test rather than having to clear them; what Praxis works out for a request to sell before the checks see it, from the holding being there to what is left of it after anything already in progress, which is where a full close is settled; the watch over handovers that ran out of time, which reports the flags that have stood too long while a command whose final reply the books cannot take in drops off the list with its flag still raised, one whose reply blows up on the way in leaving both standing; what the prediction loop's stop leaves running, since the loop gathers its work before it carries it out, so work gathered before the switch-off is still carried out and can still reach a strategy and put its answer up for the checks; and, split out of the first, what a start does with a strategy's saved state, handing empty bytes over for a file that is missing and for one it cannot read, and never looking at all where the setting is blank — which is the setting the stopping side falls back on and the start does not; and, split out of the second, what a checkpoint holds and what the thirty-day cut leaves, the cut going by when each log line was written, the recent-loss figures rebuilt from what survives going by when the thing described happened, and the running total adding up what survived once repeats of one outcome are dropped; and, split out of the third, what settles a request before the first stage, the name fixed when the settings are read while the allowance is written as the order is put together, from two figures the settings already hold above zero, save on a request to alter an order, which is given none at all; and, split out of that, what an order to buy has its worth worked out from, either an amount of money or a quantity trimmed to what the venue trades in before it is priced, which can make the order smaller than was asked for; and, split out of the first, what a failed save costs the stopping, a write that fails on the disk losing one strategy's update while leaving what it saved before, a directory that cannot be made losing every update, and a strategy handing back something the writer cannot take costing the shutdown its final saved picture while the account is still handed back

  • Add six articles on the Nexus side's sixth package, stopping a Nexus host: what a stopping host halts first, turning away anything a strategy asks for through the usual checks and then switching off the background jobs one after another in a set order; and, split out of that, what the halted mode turns away, which is a strategy's request to open, close or alter, refused by the usual checks, while an abandonment and the system's own closing orders still go out on routes that skip them; and, split out of it again, what a loop's stop leaves running, which cancels the next run of a repeating job and not the run already going, so a write can still land after the switch-off returns; what a strategy is handed when it is asked to stop, which is the holdings it owns, the money it still has room for and the state trading is in, with its own settings arriving empty; the abort a host sends as it stops, naming an order already handed over by a label the strategy supplies and going out with no checks asked at all; what a stopping host waits for, which is each order it wrote down rather than each order it sent, read until the list clears, a set time passing with some unfinished bringing a drop and half as long again before the host goes down regardless; where an outcome outside the wait is sent, which is a stand-in the launcher wires for any reply whose order is off that list, reached once the usual reader has been told to stop; and the name an order comes back with, settled once by reading the receiving side for a label of its own, so a label that differs is a failure for one receiver and simply the label for another; and, split out of the first of those, stopping the loop that reads outcomes, which is asked to finish and given a while, one still going when the while is up being left to complete the turn it is in and so able to take one more message away from whoever reads next; and, split out of the last, which name a command is kept under, filed under the label the sender chose where the other side was held to it and under the label that came back where it was not; and, split out of that, claiming the money after the send, the road taken where the receiving side is not held to the label it was sent, so a refusal arrives with the order already handed over and can leave the reply to it with no strategy to attach it to — a road the launcher's own wiring never takes, since the receiver it hands over does declare that label

  • Add six articles on the Nexus side's fifth package, the passes that tidy up: when a reservation times out, swept by a walk at the head of a fresh request while an order finding its own hold already expired hands the money back itself; releasing an order the system can name and no longer describe, which answers success for an order that was never there; whether a fill closes a position, a leftover below the increment the venue prices sizes in counting as closed; the sale a host sends as it stops, asked for by a strategy and approved by the host itself so the checks that normally stand in front of an order never see it; and where an imported position's three labels come from, a holding missing any one of them being left out of the records altogether; and what weighs a shutdown sale, which is the price guard on the single-shot road and the venue's own minimum size as the order is placed, each skipped where its own settings are absent and the first skipped entirely by a sale fed out in pieces

  • Add seven articles on the Nexus side's fourth package, the figures that follow a position: what moves a strategy's committed figure, ten places moving it and one meaning to raise it; what a pending sale is, which caps what a further sale asking through the checks may request; what a position written back at a start carries, taking one price as both what it was entered at and what its money is booked at; what the host counts when a fill empties a position, a holding being gone before the message announcing its close arrives; and what a pending sale does to the two roads into the dust, barring the one for a close the venue refused and leaving the one for a finishing fill wide open; and what a settling fee does to the committed figure, which it can raise with no money set aside behind the rise; and what a pending sale refuses, which the sales a host fires off as it shuts down never meet

  • Add twelve articles on the Nexus side's third package: where a position's last scraps go, and the running total per coin that no decision reads; what money arriving in the account changes, which is the log and the mark that the report was seen, two pools being kept, the one the checks weigh against fixed when the account is born and the one a strategy is told it has taken from the settings; where a realized result is written down, and why the record is written before the figures are counted; what a boot finds stranded, and what writing it off gives up; and what a boot rebuilds from the positions, without which money set aside is refused for as long as the per-strategy figures do not add up; what a dusted scrap leaves behind in the money figures; and which fills come back with a result at all, the gain being measured from the price a position was entered at rather than the one its money is booked at; and what two records of committed money disagreeing refuses, which is a new holding and not a sale; and how much a taking-out takes, a strategy left with a sliver being dropped from the books rather than kept; and what a start does with a position written off, which is to ask the host what it holds and write back what the record is missing, passing over anything it cannot read; and what a start weighs each position at, the price it settles on being written back onto the position; and what the fee figure taken off a gain is worked out from, which is a flat thousandth of the fill, while the ledger on the same side books the charge the venue reported

  • Ask _check_page itself which checks an atom and a spine are held to, each check replaced in turn by one that answers, where the test read the shape of the two branches out of the source. A guard that can never hold reads there as one that always does: the atoms branch was an early return, so its checks sat under no test at all, and pointing either guard at the folder rather than its name, inverting one, or exchanging the two all left the suite green. Each check is counted rather than merely heard, a check called twice in one branch being the defect the test exists for

  • Check that the causes and the obligation words the register names are the ones the purpose rule matches, the pattern spelt out into the phrases it accepts and read against the register's own sentence, and anything in a pattern that cannot be spelt out stopping the reading rather than being guessed at. The register named four where the pattern took eight, the causes were read against nothing at all, and a word appended after the sentence's last or went unseen

  • Read a module's logger off the name it assigns getLogger to, where the rule refusing a citation that holds nothing but a logged message looked for _log alone. That is the Praxis name and most of Nexus keeps it, but the module holding the money figures writes _logger, and a range holding one of its warnings and nothing else read as code. Structlog's get_logger is read alongside logging.getLogger, two Nexus modules taking the second. A line carrying else:, try: or finally: and nothing more no longer saves such a range either

  • Count a Nexus module as owned by the article identifiers its ledger cell carries, where the absence of cited, not traced was read instead. Two cells came to carry both, which counted them as owned by nobody and put the split wrong in three places at once, with no count able to fail

  • Check that a Nexus ledger cell already carrying rows carries every row that cites the file. The Praxis cells were held to their citations exactly and the Nexus cells to only half of that, so 22 rows across 13 cells had gone unlisted; a cell reading cited, not traced carries none and is held to neither side

  • Check each row identifier a Nexus ledger cell carries, which has to belong to an article citing that file. Membership was checked both ways and identity not at all, so two cells naming an article that cited neither of their files sat there unseen. The test takes the cell carrying the most rows, a cell carrying one being unable to tell every offender from the first

  • Put the newest bullet at the top of this version's Add section, where the one standing there was the oldest

  • Gather this version's three ### Add headings into one, in the order the house keeps — Add, then Fix, then Change. Successive commits had each opened a new heading rather than adding to the one above, which no other version in the file does

  • Harden the gate against the two voice defects it was given, which took seven readings of the diff to get right. An ordinal standing in for a thing is refused in its definite form alone — a third held in reserve is a fraction, a second is usually a length of time, and no pattern separates those from the defect — and one following a first in the same section is left alone, the reader having the list in front of them. A purpose clause carrying an obligation is refused where the two sit in one clause, the window stopping at a full stop, a comma, a bracket, a bracket of either kind, a dash of any of four, or a word that opens another clause, and reads an obligation only as a word of its own rather than inside a hyphenated one — that excepted, the real defect carrying a relative clause of its own, which leaves one known false positive — an obligation inside a noun phrase — that the writer rewords around, which lets a compound subject past. Both read whole paragraphs — a list item being its own, quoted or not, so a cause in one and a requirement in the next are not paired — so a sentence that wraps is read as one, both read a phrase however widely its words are spaced, and both read a word through the emphasis around it. Both judgements go the same way: a check that blocks correct prose costs more than one that misses

  • Fix the defects those readings found in the rest of the gate. A review stamped later than the last edit is refused as covering a version that never existed, one with no stamp or no modified line is refused without crashing, and a stamp written twice or with no version is refused rather than read as the first of them. The state column is read whatever case it is written in, so a state the wiki does not use is refused rather than skipped. A review stamp may sit anywhere in the metadata, including past the evidence list, but not inside it, where dropping it would hide a claim parted from its source. And the Nexus breakdown is checked as well as its totals, in the ledger's own words as well as the index's — three pages stated how the named modules split and all three had it wrong

  • Read a row span written with the Nexus series, and refuse one whose ends are not the same series and package — the end was matched and thrown away, so a span from one series to another expanded as though both were the first. Row identifiers were widened to carry it and the span between two of them was left reading the Praxis series alone. A Nexus range had named nothing, every row in it reading as uncited

  • Refuse a moment written into a page's prose, on every page rather than the articles alone. Stamping an article means rewriting the line carrying its time, and one such rewrite landed inside a paragraph on the register that quotes the footer convention, leaving the sentence half-replaced and a code span open for four days. It reads whole paragraphs too, so a moment split across a wrap is still found, and passes over what a fence holds, whichever mark opens it and however long, a shorter run inside a longer one not closing it, nor a run of the other mark, nor one naming a language, where a longer run of the same mark alone does; a quote mark is taken off before any of this, so a fence or a paragraph break inside a quotation is read as one, and a quotation ending closes a fence it opened, however it ends. A thematic break parts two paragraphs the way a blank line does, prose and a quotation after it are two, and a backtick run opening a list item is not read as a fence — that was tried and was wrong, taking three list items for one fenced block and hiding the middle one. The footer on its own line, a metadata key, a table cell and a pinning line are left alone, each matched whole; a footer quoted inside a sentence is not, nor is a sentence that merely opens with those words

  • Repair that paragraph, and the status line above it, which still named two states the gate refuses

  • Hold every per-page check to running on both kinds of page by reading the branches off the source. One had been added at the wrong indentation, landing in the spines branch twice and the atoms branch not at all, which is valid Python and ran green for a day. A branch is told by the condition it sits under, and by that condition asking which folder the page is in and saying yes, so neither replacing it with a constant nor reversing its operator leaves the reading unchanged

  • Make every test that could not fail able to. Among them: both heading cases wrote a heading the check would not have fired on anyway, so neither protected the exemption; no case wrapped a sentence across two lines, which is what reading paragraphs is for; the wiring test asserted only that more than eight checks were found where eleven exist; no metadata case carried a review stamp; no state case was written in capitals; no count was put on the index, so the arm reading it went unexercised. Each voice pattern had one example, leaving most of its words, every ordinal past the fourth and both its cases unpinned; they are written out member by member now, with a test that the written list is the one the pattern holds — the first attempt read the list off the pattern itself, so removing a word removed its own test; no case moved the unreviewed count while leaving the reviewed one right, so half that comparison could have been dropped; and the window cases sat well inside and well past the limit rather than either side of it, so any of thirty-five lengths would have satisfied both; the list-item case used the one marker the window already stopped at, so it proved nothing about splitting items; the three voice checks were reached only by calling them directly, so dropping any from the page walk changed nothing; and the purpose check's less common words had no case at all, so deleting lest, ought, needs to or cannot be allowed would have passed

  • Correct two ledger rows naming an article that cites neither file: the ledger check reads which files a row names and not which rows name a file, so a stale identifier sits there unseen

  • Close the review count on a word boundary, which it had been missing: "151 notes" and "151 nothing" both read as the count of rows not reviewed

  • Correct a docstring on the ordinal check that still gave the indefinite form as the sentence it exists to catch, which the check stopped reading two rounds earlier

  • Correct two register rows that counted: one said two checks read the order where four do, and one named four refusals where the stage has six ways to refuse

  • Correct two index entries that described their articles as those articles read before the verify rounds: the checks do not mostly read the account, and the roads around them are not two

  • Mark six more rows reviewed, both re-derivations having come back settled on the same text: how Nexus sets money aside, what becomes of it, what it does when a command does not get across, what each check weighs, and what the platform ceilings and the price check weigh. Each stamp names the version it covers, so editing any of them takes the mark off

  • Separate whose catches are whose in the undoing article. Nexus's are for ordinary failures and an interrupt goes straight past them, where Praxis catches one once the claim has run, undoes what it can, and lets it go on

  • Correct two last ones. The health stage's thresholds are each optional too, so a figure with none set is read and never acted on. And Praxis reads the clock before it takes the book from the cache rather than before fetching it — the poller stamps its own time after the fetch returns

  • Correct two more. The lifetime peak the risk stage reads is of closed money alone, not of the measure the moment's figure uses. And a book stamped later than the snapshot need not mean either figure is wrong: Praxis reads the clock before it fetches, so a book landing between the two is genuinely newer

  • Correct two more. A stage raising does not always leave money set aside: the stage that sets it is fourth of six, so only the two after it can raise with any held. And the four drawdown measures are two pairs — the moment's figure and a lifetime peak, each as an amount and a fraction — rather than four unlike things

  • Correct two more. An undoing that fails under the send brings no release; one that fails escaping the taking does bring it, and the release then finds the reservation gone. And say that the four drawdown measures are no two of them alike, the worst on closed money refusing while the moment's figure reads nothing

  • Narrow the unreachable-sign claim. A holding the account did not buy does count against the projected sum, positions being kept on either side; it is the negation written for the incoming order that no road reaches

  • Say thirty days rather than a month for the third loss window, the windows being twenty-four hours, seven days and thirty

  • Say that the order's own ceiling is conditional too. Every one of the platform stage's five is unset by default, so a stage with no ceilings configured passes everything

  • Correct four more. A claim naming an order already tracked raises before the sweep and sweeps nothing, so not every claim catches up the figures. A registration raising before it claims leaves the money to be given back by the release; one raising after it leaves the release nothing to find. The later-stamp refusal comes before any subtraction, so there is no age below nothing to speak of. And the money is set aside before the decision is sent rather than before Praxis sees it — Praxis is holding the action throughout

  • Correct two more. A registration raising before the claim drops itself first, so nothing is the wrong word for what it undoes, and a claim refused for being too late has already given its own amount back — either way the release that follows may find the reservation gone. And the signs in the projected holding are never exercised down this road: the stage is skipped for every action but an entry, and an entry has to buy

  • Correct four more. A registration raising before the claim reaches the release with nothing undone, where one raising after it undoes the order first and leaves the release to find the reservation gone. The undoing drops any bracket exit recorded against the command as well. The projected holding negates the order's own amount where it sells. And a limit set on a figure nothing supplies refuses a decision that reaches that check, which is not every decision — an earlier refusal stands the rest down

  • Correct two more. Intake's demand that a change carry an amount above nought is answered before it is asked: what Praxis puts there is a standing one, the same for every change. And the projected holding does not always include the order — one sized in money alone is turned into an amount at a middle price, and where none is to be had it adds nothing

  • Correct three more. Two bookkeeping refusals come before the four limits: money deployed with no record of which strategy holds it, and a record that does not add up to the deployed total. A registration that raises as it is being taken does reach the plain release, the raise being caught where the taking is, so only a send failing with a registration already in hand skips it. And say what the projected holding is: what the order's own pair holds, bought counted positive and anything else negative, plus the order itself, floored at nothing

  • Say what the book's age actually measures. The moment on the book is when Praxis fetched it, taken off its own clock as the fetch returned, the venue's answer carrying no time at all — so the age is the wait since the fetch rather than since the venue drew the book up

  • Correct three more. Claiming a reservation takes its own amount out of the set-aside bucket and leaves every other reservation's there. An undoing in Praxis runs a callback against the position rather than restoring it, and drops the command's registration where this attempt wrote it. And the deviation's four refusals come before it is weighed against the cap, not before it is read at all — the missing-figure test reads it

  • Correct four more. A reservation the record no longer holds is refused as not found whether it was given back, swept, or claimed already, so the answer covers three causes rather than two. An undoing in Praxis puts the position back and drops this attempt's records whatever happened, and only the order's money waits on the reservation having been claimed. A change's new amount is never weighed against the standing one at all, the only arithmetic for it sitting in the stage a change skips. And the price stage refuses alike for no snapshot, no moment on it and no stamp on the book, the later-stamp refusal being separate

  • Correct two more. Marking a registration unknown is not nothing: in Praxis it writes a record against the command, and leaves the money alone. And the deviation has a fourth thing it refuses on unweighed — a decision carrying no reference price at all

  • Withdraw the tally half of that check after one pass over every article. It cannot separate a count of a set the code enumerates, which is a fact, from the writer's grouping, which goes stale, and refusing both would have meant rewriting a dozen correct sentences. What survives is the ordinal with no first before it in the same section, which left three real instances to fix

  • Fix the ordinal check, which had been added at the wrong indentation: it landed in the spines branch twice and in the atoms branch not at all, which is valid Python and ran green for a day. Hold both branches to their checks by reading them off the source, proved by putting the misindentation back and watching the test name both halves

  • Say that past the claim there is nothing in the set-aside bucket to give back, and that what a failed send undoes is the tracked order instead

  • Split the price check out as well, the third subject to outgrow the stage survey. It weighs the book's age, its spread and a price's distance from a reference, each only where a limit for it is set, and refuses a decision for a figure being absent as readily as for one out of bounds: a missing stamp, a book stamped later than the snapshot, a missing spread, a missing reference source, and two sources naming different things

  • Correct three more. A failed claim drops the registration only where it came back a failure; where it raises instead, for an order already tracked, the registration is left standing. Marking a registration unknown undoes nothing in Praxis, which is a fact about Praxis rather than about every registration. And the lock around the projected holding is held only long enough to copy the list of positions: the positions in that copy are the live ones, their sizes written to as reports come in, so the figure can be read mid-change

  • Record that a sweep takes a reservation at the expiry moment itself, where a claim arriving at that same moment is still in time

  • Split the platform ceilings into their own article, a reviewer having found what makes them worth one. The stage weighs five things: what the order comes to, read off the decision, and four figures handed in from a snapshot. The snapshot Praxis builds carries the projected holding and nothing else, and a limit set where the figure is absent refuses the decision — so the limits offered on the order rate, the day's losses and the pool committed cannot be used to tighten the account, only to stop it

  • Correct three more. A failed claim drops the registration only where that attempt put it there, and the raise is caught and reported as a failure to submit rather than travelling out. The registration handed an undoing holds no decision, only whether the reservation was claimed and which command it was. And the price stage's missing-figure refusals each need their own limit set, an unset one letting the figure go unread

  • Correct two more. A registration owns an undoing only where the send failed other than by timing out; a timeout marks it unknown instead. And each of the price stage's three refusals fires on a missing figure as well as a bad one, the age refusing a book stamped later than now

  • Name who claims a reservation, the earlier withdrawal having been right about Nexus and incomplete about the system. Praxis claims it as it registers the command — before the send goes out, not at it — and where that claim fails the registration is dropped and the submission raises. Nexus offers a road of its own to the claim and no code there walks it

  • Correct three more over-assertions. A claim naming an order already tracked raises before the reservation is looked up at all, so the shared not-found answer covers only one given back or swept. The registration that owns an undoing comes from outside and is handed the decision with its reservation on it, so what the undoing reaches is decided out there rather than known to be untouched. And the health stage is not a pure pass-through: which way each figure is weighed, and that a halt outranks a breach and a breach a warning, are its own, a warning refusing nothing

  • Correct two more. The eighty-per-cent weighing counts what this order and its fees come to alongside everything already deployed, rather than the deployed total alone. And where a registration owns the undoing, the money set aside is still set aside: nothing has claimed it on that road, so what the registration undoes is whatever else it took on

  • Correct four more, two of them rules of this project broken by its own author. The health stage's figures were described as a round trip to the venue and a count of its failures, which is what their names say and not what the code shows: five figures are handed in from outside and weighed against thresholds handed in with them. And the striking claim that one limit governs two measures in two places was wrong — the mode controller keeps its own set, tied to the walk's by nothing, so one can be loose where the other is tight. Also: a reservation can be given back by name, a third ending beside claiming and sweeping, and a claim made too late has its own amount swept with the rest

  • Correct four more. Four of the six checks read the order and the other two read the account's losses and how the venue is answering, so the grouping that called most of it account state was wrong twice over. The health stage stops a decision for the state of the connection — a round-trip time, a run of failures, rate-limit headroom, clock drift — and not for anything about the account's money. The value that leaves open positions out still counts what the account started with. And the worst the account has ever been down on its whole value is not unread: no stage of the walk sees it, and the part of Nexus deciding whether the account may trade weighs it against the same two limits the walk applies to the worst on closed money, so one configured limit governs two measures in two places

  • Correct four claims about a command that does not get across. A release asked for without a controller to ask returns having released nothing, so both roads that ask are conditional. An undoing that raises leaves the figures wherever the registration had got to, rather than untouched. Which road a timeout takes turns on whether a registration was taken, nothing about the money being read. And only a timeout with a registration is reported unknown carrying the command's name; one without is reported failed, carrying none

  • Correct three claims about money set aside, then split what becomes of it into its own article. The eighty-per-cent cap leaves the fee reserve out of what it counts and that reserve comes off free capital all the same, so the last fifth is not held clear of everything. Expired reservations are swept only where one is asked for or claimed — releasing one sweeps none, acknowledging an order sweeps none — so one nobody claims counts against the limits until one of those two calls comes. And a claim sweeps before it moves, so the total deployed can fall across a claim by other reservations' amounts

  • Carry the same withdrawal into the article on setting money aside, which described the claim that moves a reservation into flight without saying nothing in Nexus makes it

  • Split how far down the account is into its own article, the four drawdown figures having made the stage article outgrow its cap on the round it was written. Nexus keeps two figures for what the account is worth: the whole value, which includes what open positions are up or down, and a second counting only what has been closed. Each keeps a high mark that only rises. The moment's drawdown on the whole value falls back as the value recovers, where the worst on closed money is a record that stays. And the worst on the whole value is kept the same way and handed to no check, so a bad hour of open positions leaves a record nothing acts on

  • Correct the risk stage's four drawdown figures, which are not one measure counted two ways twice: the first pair is the current drawdown on total equity and its share of that high water, and the second is the lifetime worst on realized equity and its share of its own, so unrealized profit is in the first pair and not the second

  • Withdraw the claim that money is spent as a command goes out. At the pinned commit nothing under nexus/ calls the step that would move a reservation into what sent orders hold — the function is exported and has no caller but the tests, the duty belonging to the host that wires Nexus to Praxis. What the source does show is the capital stage granting the reservation, and only an entry's answer carrying one, the stage that grants it being the stage an exit and a change skip

  • Extend the renumbering check to a tally of part of a group, the form that slipped past it and was wrong four times over. A count of the whole set, which the code does name, stays allowed

  • Stop counting which stages read the order, that count having been wrong twice now. Four of the six do: intake reads an entry's side and amount and a change's amount, capital reads the value and the fees, the platform ceilings read the value, and the price stage refuses a decision carrying no reference price where a deviation cap is set. What the stages mostly read is the state of the account

  • Correct two more. A stopping host keeps only the exits and abandonments its strategies ask for, and an exit naming a trade the record has no position for is dropped before any send. And a change is asked only for an amount above nought, intake reading nothing about the amount it replaces

  • Split what each check weighs out of the walk's article, which it had grown past the cap with three rounds of findings against it. The risk stage walks seven figures and stops at the first over its limit, an unset limit letting that figure run; the platform stage weighs the order's value and four account figures, and refuses where one it needs is absent, which is the opposite handling; the price stage reads the book's age, spread and a handed-in deviation; the health stage reads none of the decision at all; and the capital stage is the one that sets money aside

  • Correct one more. A fill does not move one amount: it takes the filled amount and the fee estimated on it out of what resting orders hold, and puts that amount and the fee actually charged into what the position holds. The difference between the two fees is what goes to the reserve

  • Correct one more. No action skips intake, which is not the same as every walk reaching it: the order is given rather than fixed, so a walk putting another stage first can refuse there and never get to intake

  • Correct two more. The price stage reads no book price against the reference price: it refuses on the book's age, its spread, and a deviation handed in against a cap set per strategy. And a nought cost basis is read before an exit fill is weighed against the position, so an oversize fill on one raises rather than reducing it

  • Correct two more. A stopping host does not close what is open: it sends the exits its strategies ask it for, and one asking for nothing leaves nothing to send. And the fee reserve is an entry's affair — an exit's fill never reaches it, that exit's fees coming off the profit it reports instead

  • Correct four more. The risk stage weighs losses run up over rolling windows as well as drawdowns, and either alone refuses a decision. The two stages that read the order read what it comes to in money, not its size in coin. A refusal and a cancellation take money from whichever of the two holdings the order sits in, where an acknowledgement and a fill each want one and are refused for the other. And an entry fill whose position never moved is still handed to the strategy, the loop logging the raise and carrying on with that same outcome

  • Correct three more. The cross-reference to the roads around the walk named two of them when a third had been added. An acknowledgement is refused unless the order is one sent and a fill unless it is one resting, so neither moves money from the other holding. And a reserve left within a rounding margin of nothing is set to nothing, so a small surplus need not lift it

  • Split the fee reserve out of the entry's article, which it had grown past the cap. The reserve is money held back for what trading costs: one of five sums taken off the pool, moved by the gap between what a command's fees were estimated at and what the fill billed, drawn down by fills that cost more and topped up by ones that cost less, and refusing a fill's move where the shortfall is bigger than the reserve itself

  • Correct seven more. A third kind of order reaches Praxis without the walk: a shutdown whose wait runs out abandons each command still pending, the same way. A refusal's message is required to be there and not blank, with nothing routing it to a person. An answer that is not a decision raises before the answer is read for anything else, rather than sparing a pass that would otherwise be counted. An acknowledgement runs for every kind and moves money for an entry alone. A refusal, cancellation or expiry of an entry reaches no position. And the dust path needs the fill to have finished the order, a part-fill leaving the remainder on the position

  • Correct three more. A shutdown send is passed over for an ordinary failure, an interrupt going straight past that catch. A position a fill meant to close whole but filled short of loses the rest too, the remainder moving to the account's dust, so it can lose more than the fill filled. And the sign turned for a short position is turned before the exit's fees come off, which come off either way round

  • Make the renumbering count a blocking check as well. An ordinal standing in for a thing reads its meaning off a count stated earlier, and three rounds running moved that count as each pass turned up another branch. An ordinal qualifying a noun says what it counts and is left alone

  • Correct five more. Of the five skipped stages only the platform ceilings and the money to set aside read the order's size; the book is read against a reference price and a per-strategy cap. The fee settlement goes onto the reserve rather than off it, growing it where a fill cost less than estimated. An expiry lowers what a position has pending too, there being no handling of its own for one. And stop counting the endings that leave a position alone: every count written so far has gone stale by the next round, two of them being the ones that turn an outcome back before any handling at all

  • Correct four more. A fee shortfall refusing the move and the reserve taking the difference are two branches, not one sequence. An entry fill's raise does not end anything: the loop that handed the outcome over logs it and tells the strategy of the outcome regardless, so the position is left unwritten with nothing downstream the wiser. An exit's refusal comes before the position is changed rather than before it is read. And what the account and the strategy hold does not cap a release: a release past either is refused, and only one over by no more than a rounding margin is trimmed

  • Make the rationale defect a blocking check, four verify rounds having found it in a different article each time. What the instances share is a purpose clause carrying an obligation — a word that gives a reason, then one that gives an obligation — which is the writer explaining rather than reporting, code holding conditions and not duties. A bare cause stays allowed, being a fact about the path. Proved by putting the shutdown's unreachable venue back and watching the gate refuse it

  • Strip six rationales the code does not carry. The five skipped stages do not read only the account — three of them read the order's size — and which actions skip them is decided by the action alone, with nothing weighed about the decision. A shutdown send is passed over for raising anything at all, not for a venue being unreachable. An exit fill takes off what is pending down to nothing rather than always its own size. And the endings that leave a position alone are four, not three

  • Open the next Nexus package with the exit, which the re-seed named first because two articles already written point at it. Tracing it turned up nine facts; four promoted, and two of those are the subjects the re-seed had queued already and stay queued. What an exit outcome changes is the article: the size coming off the position and off what it has pending, the three endings that leave the position alone and the fourth that reduces it with no money moved, and the two figures an exit is worth — the profit measured off the entry price and the money given back measured off the cost basis, capped at what the account and the strategy hold

  • Correct three more, each a gloss the code does not carry. The five skipped stages do not all ask whether more should be committed: they read a drawdown, a book, a health snapshot, platform ceilings and the money to set aside, and nothing on a change's road checks that it keeps the size it re-aims. A refusal under the wrong stage's name does not travel out misattributed, the raise stopping it going out at all. And an exit fill naming no trade, or none with a position, raises alongside the two endings already named

  • Say what turns an exit's fill back before it reaches the position: a release worked out and then refused, or a fill bigger than the position is. Scope the entry's own account to the entry, the exit's handling being the next topic rather than half an account here

  • Correct two more. A cancellation is named in the walk's skipping set and a strategy never asks for one — the four things it asks for are to enter, to exit, to change and to abandon — so that entry is as dead as the abandonment's, and both now sit with the roads around the checks. And money is spent at the send only where the answer carried a reservation, which an entry's does and an exit's and a change's do not

  • Split the roads around the checks into their own article. Two kinds of order reach the venue without the walk: an abandonment a strategy asks for, sent before the walk is reached, and an exit a stopping host sends, which writes its own allowed answer rather than asking for one. The walk's skipping set names an abandonment as though one could arrive, and nothing builds a request carrying one, so that entry decides nothing. Also say that no outcome but a fill, a refusal or a cancellation reaches a position

  • Correct two more. An exit's fill reduces the position wherever no release was worked out for it at all, so the reduction waits on a release only when one was worked out and then refused. And the two figures re-averaged are not re-averaged alike: the entry price weights a price by a size, where the cost basis adds a value and a fee that are amounts already

  • Correct three more claims a second reviewer found. Intake is not the one stage no action skips: an abandonment is named in the skipping set with the exits and cancellations, and nothing reaches the walk carrying one, the strategy's leaving by an earlier road. An exit's fill reduces the position only where the money it releases came back. And the two figures a fill re-averages each take a different number off it, the entry price the price it went off at and the cost basis the value it came to, which nothing requires to be the one multiplied by the size

  • Re-seed the Nexus package from what its own tracing turned up: what an exit outcome changes, where a position's last scraps go, a deposit the venue reports and the pool it leaves alone, where a realized result is written down, stranded money found at boot, and money set aside that nobody claimed. The exit comes first, two articles already written saying a figure waits for it

  • Say that an entry's position is looked at only once the money has moved. The two faults a fill can raise sit behind that move, so a fill the money would not move for comes back as a failure and never reaches them

  • Correct five claims the verify stage found across four Nexus articles. A strategy's abandonment is sent without being walked through the checks at all, so the account of the walk could not open by saying every decision goes through it. A fee shortfall refuses a fill's move only once it passes the reserve by more than a rounding margin. A refusal or a cancellation of an exit lowers what a position has pending, so fills are not the only outcomes that reach one. And the two figures a fill re-averages are read for different things: the profit an exit reports is measured from the entry price, while the cost basis sets the money that exit gives back

  • Take topic five through the same five stages. Tracing what Praxis sends back about a command turned up eleven facts, which the one-sentence test folded into one topic and the word cap then split in two: what an entry outcome changes, which is where the money set aside for a command goes as each kind of report arrives, and when an entry's position grows, which is the averaging a second fill does to the price and the cost basis a later exit is measured against

  • Correct two Nexus articles a second reviewer dissented on. A change takes no new reservation because the capital stage never runs for it, and what covers it is what the command it re-aims already holds — the money that command went out on was spent at the send, so no reservation of its own still stands. And the two unreadable answers do not share one reason: an answer that is not a decision could pass unjudged, while one refusing under another stage's name is already a refusal and goes wrong only in whom it blames

  • Read the list of checks the wiring tests cover off the gate itself rather than keeping it by hand. Three checks had been added to the gate without being added to the list, so nothing held them to reaching the report

  • Fix what the review state meant, because it was unsatisfiable. It had been set to mean a verify pass that returned nothing, which an asked reviewer almost never does — the pass over three articles returned thirty-two judgements of supported against a handful of corrections and still left the count at zero. Reviewed now means the re-derivation happened and what it turned up was settled, by a fix or by a refusal recorded on the register page with its reason. It is also a fact about a version: a row reading reviewed names the version it covers in the article's own metadata, and the check refuses the claim where that stamp is missing or older than the article's last change, so editing a reviewed article un-reviews it with nobody having to judge that. On those terms one row was reviewed at first — two of the three a pass had settled were reopened by a second reviewer the same day — and the rest were not

  • Take topic four through the same five stages. Tracing harvested six behaviours as H-076 to H-081 and the merge test folded all of them into one row, splitting nothing: a report matching no strategy yet is set aside under its command's name, every later report for that command queues behind it so the order they arrived in survives, only the head is tried, and a head still unmatched past the last wait has the whole queue dropped and logged rather than reported — so a strategy that never resolves costs its command every report, not only the first. Verify then found that a sibling counts as taken even where handing it over failed, so the queue advances regardless, and that a refusal identifies the stopping check to its caller rather than to the strategy — an outcome waiting on a strategy says both

  • Take the first Nexus topic through all five stages, which changed what got written. Tracing harvested five behaviours as H-071 to H-075; the merge test joined two, promoted two, and split the fifth out to the queue because how an abort reaches Praxis is an additional independent question — it goes by a road that never uses the walk's answer. Verify then found that a change shares the bypass while reducing nothing, that the trace had missed the shape a stage's answer must take, and that a stage which raises returns no decision at all, so the reservation is neither handed on nor released. Those additions took the article to 453 words against a 300-word cap, so it split: the checks a decision passes keeps the configured order, the skipping and what a decision carries out, and what a check must answer with takes the two shapes an answer may have and the two the walk declines to read. Topic four is traced and harvested as H-076 to H-081

  • Run the Seed stage for the first Nexus package, which the two articles already written had skipped. The brief puts five stages in order — topics proposed and a reviewer challenging what is missing, then tracing with every behaviour harvested, then the merge test, then writing and verifying, then re-seeding — and those two were written straight off a candidate list that came out of a Praxis coverage review. The register now records the package's scope and that breach rather than tidying it away. The Seed approved five topics in a tracing order, kept both written ones with their scope, added the subject the candidate list missed — an outcome that cannot yet be matched to a strategy is parked and later outcomes for that command queue behind it — and queued seven more necessary Nexus subjects with what proves each is behaviour, so they enter a later package rather than enlarging this one

  • Make a row's review state a state rather than decoration. The status column every register row carries was never read by the check, so written meant nothing and an unreviewed article was indistinguishable from a reviewed one. A row is now written or reviewed and nothing else — reviewed meaning a reviewer re-derived the article from the source its claims cite, which is the bar issue #185 sets — the check refuses any other word, and the register states how many are each with the count checked against the table. Every row read written when the state was introduced: none had been through that re-derivation as a recorded step, and the number now says so on the page rather than being an absence nobody sees

  • Correct both Nexus articles, which a review found wrong. Money is set aside partway through the staged checks rather than before them, so a later stage can refuse a decision that already holds capital — which is what the release on that path is for. Free capital is the pool less positions, working orders, money in flight, the fee reserve and existing reservations, not the two the article named. The first of the four limits weighs the order's worth without its fees, where the others count both. And the account of a timed-out send was wrong at its centre: the reservation is claimed before the command is handed over, so that money is already in flight and no expiry can release it — the registration taken beforehand owns the undoing, is allowed to fail, and has no release behind it

  • Open the Nexus side, which issue #185 puts in scope alongside Praxis, with the two articles a Praxis reader most needs. How Nexus sets money aside: a trade is weighed against its share of the pool, its strategy's budget, the free capital and a ceiling of four fifths deployed, and what is held covers the fees as well as the order. What Nexus does when a command does not get across: the money comes back on every road but one — a send that times out keeps it and marks the registration unknown, because the command may have arrived, and freeing it would let another trade spend money against an order that may be resting at the venue. Row identifiers widened to carry an N series

  • Close the last branch the Praxis remainder carried: a ladder's price change is turned away before any of it starts by another change already under way on that ladder, by the ladder being under any hold, and by settings belonging to another way of working. The other three branches on that list — the not-active refusal on a protection re-price, the watch returning before its deadline, and squaring an order making no filled ending of its own — were written into their articles earlier in this release, and the list now says so

  • Correct what a change to a part-shown order may name. The route said it may name only the amount to show and keeps its price; it may name the amount, the price, or both, and whichever it leaves out keeps the value it had. The refusal for settings matching no way of working is also two refusals, the first a raise before the change is queued and the second on the worker, and the route now distinguishes them

  • Close out the five routes against a third reading of their evidence, all fifty-two claims of which resolve. A lost protection no longer reads as closing the position: only one of the two policies attempts a closing order, and even that is an attempt. The hold that sets a change aside covers a poisoned account as well as one catching up, and that one does not lift while the host runs. A worker is stopped as its own account is unregistered rather than past them all. The retained backfill hold belongs to one adapter branch, and incomplete is the backfill's result rather than the squaring's. Starting a dequeued request now names the way of working that owns it — a run, a ladder, a part-shown order, a bracket — instead of pointing every one at plain placement. The bounded shutdown wait and unregistration moved to the article that owns them

  • Add the last two Praxis subjects the register carried as seeded. When a reconnection releases an account: the phase an account is in is the one thing recorded and the gate on its work is read off it, a feed going down mid-asking marks that pass to end gated, a reconnection arriving mid-asking books exactly one rerun, and only a pass that got all the way through releases it — the round of checks that runs on a timer never asks. When an older record can be opened: a shape from a newer build is refused outright, an identity another build wrote is refused however right the shape, and old duplicate marks come forward only where every one matches a fill whose pair is known

  • Add How an outside event enters the record, the first of the Praxis subjects the register carried as seeded. News from outside is written by the account's own writer and nobody else: a caller queues the event with a place for the answer, wakes the writer, and waits on what the writer did. An account still starting has no writer draining that queue, so the caller doing the starting writes straight through — and only that caller. Poisoning is weighed again after the record is written, so a write can land and the caller still be told it failed, and a writer called off mid-drain leaves that caller waiting on an answer that never comes

  • Tighten what the five routes cite and what they leave out. The cancel route gained the step its own evidence already proved and its body did not — a request whose trade cannot be named is left without a report, past the venue call and past any write it made. The stop route gained the stages it had compressed away: the wait for open work to clear, the feeds and the venue connection closing, the accounts being unregistered, and the failure there that is kept while the rest are attempted and raised past them, leaving trading marked as started. Entry citations now carry the handoff from the host through to the manager rather than stopping at the guard, a confirmed cancellation is distinguished from a refused one in the claim about what is written first, and answering an orphan command is named as the report it sends rather than the classification it makes

  • Correct what reviewing the five spines under that new bar turned up. The change route had the stop-price, weighted-field and buy-exposure refusals as late arms on the worker; all three run before the change is queued, and the route now says so. The start route split on a live venue against a simulated one; the branch is the adapter's kind, and the simulated venue uses the same adapter, so it takes the feed and backfill path too. One claim said exactly one request leaves the ordinary queue each pass, where an empty queue ends the pass having taken none. The stop flag was cited at the handlers that install it rather than the wait and the two setters, and the second shutdown pass was described as following the abandonments rather than beginning without waiting for them. The scan the squaring tick asks for carries drains, changes and failed closes besides protection, and now links accordingly

  • Give a spine evidence of its own, and check it the way an article's is checked. An article owns a behaviour; none owns the order behaviours happen in, which is the whole of what a spine adds — so every ordering claim a spine made was borrowing an article that did not support it, which two review rounds kept finding and no rule could catch. A spine now carries claim and source pairs proving its route against the pinned commits, resolved on the same terms: the lines must exist, hold code rather than a docstring or a log call, and sit at the declared baseline. Row identifiers, the register's row table, and the index's link pattern all widened to cover spines, and the voice rules now apply to them

  • Add the four remaining spines the brief names: draining an account's queues, the pass every other route is carried by; changing work already sent, with one arm per way of working; stopping a host with work in flight, which abandons what is in flight, cancels what is resting, and carries on through three things going wrong; and starting a host back up, which ends either ready or gated. Each was walked against the code rather than assembled from the articles, and each sentence names the article that owns it

  • Add the first spine, Cancelling a trade, and the check that makes a spine one. Issue #185 names two kinds of page and calls the spine the deliverable — a numbered walkthrough sequencing articles end to end — and names one published cancel spine with its failure forks as the guard against shipping hundreds of correct short pages that still leave a cancel unfollowable outside execution_manager.py. The directory for them existed and was empty, and nothing checked for one. The route runs from the asking to the report in fifteen steps, grouped the way the code branches rather than as one line: the refusals before anything is queued, the three arms a queued cancellation takes — work being fed out, no order ever sent, an order resting — the three results of the one venue call, and what the caller is told on each. A first draft sequenced the articles instead of the dispatch, which read as a single fourteen-step line and put alternative arms in series; both reviewers walked it against the code and rejected it, which is the bar the issue sets for a spine. A spine asserts nothing of its own: the check refuses a step that names no article, a route numbered with a gap, and a page under spines/ with no route at all. A step ends at the next step or the next heading, underlined headings included, so a link below one cannot stand in for the step's own; and a bullet saying where the route is not taken names an article on the same terms, since that is a claim about the route too. Ownership is also per sentence rather than per step: one link at the end of a step reads as covering every sentence in it, which is how a spine comes to assert what no article says — the sentence carrying the claim is not the sentence carrying the link. A trailing run of links and a bold label assert nothing and need no owner. Every one of these holes was found by walking the spine rather than by the check, and each now has a test that fails when the rule is removed

  • Add What the host refuses first. Placing a request, cancelling one and changing one share one guard that runs before the books or the worker are reached: a host shutting down refuses all three, and each then requires the named account's own start to have finished. A caller turned away there is told by a raise with nothing written down — and because ready is set only after a start finishes, work arriving that way never belongs to an account still starting, which is what the startup waits further in are for. Written because the cancel spine asserted these refusals with no article owning them

  • Add six articles to the wiki: what the simulated venue turns an order away for, and what it turns a depth snapshot away for; what a lost protection costs the account, freeze by freeze; what stops the order that closes the position it leaves open — a sell for a long, a buy for a short — and how big that order goes out; and the holds a reported finding places on an account, down to the lifts nothing in the running system calls Add a seventh on the part of a fill a command counts: the whole fill reaches the order and the money record, and only what fits the order's budget reaches the figures Nexus hears, so the two part company by exactly what was discarded. Add an eighth on what a restart puts back: each kind of live work rebuilt at the point it had reached, with nothing already standing at the venue sent again, and a scheme's hold rebuilt under the precedence the running one keeps. Add the rest of the Praxis side: how a ladder's prices are changed and what can leave the new grid short; how protection's prices are changed, and the endings where nothing replaces the pair; how a schedule change is carried out, the parts already sent kept and the next set a full gap from now; what startup does with orphaned work on both sides of the record; the window a movement is found in; a weight curve that plans a part of nothing; when a venue call is sent again and what each attempt costs; how an unfinished close is recovered; how an order is brought back into step with the venue; and what a restart puts back of a bracket. 710 articles, 11,576 line references across 5,128 claims

  • Add the branches three articles stopped short of. A venue frame whose handler raises is logged and the frame dropped, so a feed being up says nothing about whether what arrived was taken in. A change to a buy that would commit more money than the order first did is refused, and the caller told to place a new order. Each leg of a protective pair takes exactly one of an outright price or a distance from the entry, and both or neither is refused

Fix

  • Name the condition on when Praxis claims the money set aside for a command. The article on what becomes of that money said the claim is made before the order goes, which holds only where the receiving side was taken as bound to the identifier it was sent; where it was not, the order goes first and the claim follows

  • Qualify four recovery guarantees the articles stated as settled and the code leaves open. An unknown protective pair past its deadline is not always remediated: a leg query that fails, or fills that will not settle, return before the deadline is reached. A restart waiting for a filled entry before putting protection up is not waiting for exposure to exist — a part-filled order already shows in the holdings. An amended pair passed over on resume is not handed to the watch, which walks only rebuilt brackets. And a close recovered from the venue's fills takes them only where the record carries none for it yet

  • Correct every stamp in the wiki that named a time which had not arrived. 603 of the 720 pages carried one: 508 created, 597 modified and 6 reviewed stamps, with 79 footers to match, standing up to seven days after the work they describe and asserting 56.9 days of writing in all. They were not read from the clock but counted — half an hour added to the stamp before, ninety-nine times in a row across consecutive packages — and each is now pulled back to the minute of the commit that recorded it, or left alone where it already fell before that. A stamp earlier than its commit is kept, writing before committing being the ordinary case

  • Bound a stamp by the clock and by its own commit, which nothing did. _stale_stamp asked only that a page carrying an uncommitted edit be stamped later than the version committed, so a stamp once ahead of the clock could never be put back: every later edit had to run further ahead again, and one invented value propagated through a hundred and ninety packages. It now refuses a stamp after the present minute, and on a settled page a stamp after the commit that recorded it; an edit is still made to restamp its page, asked as a stamp differing from the committed one rather than one later than it

  • Read the recording commit to the minute rather than the day, through _last_commit_stamp. A stamp inflated by half an hour lands on the same day as the commit it belongs to, so a day's granularity cannot see the thing that happened

  • Stop the gate's own tests stamping their fixtures 2099-01-01. A stamp that far ahead satisfied the rule that a stamp be no older than its commit, so the suite was built on the hole it was meant to guard, and two tests asserted the invariant backwards — that a stamp before its commit is wrong and one after it is fine. Both now read the other way, the walk and uncommitted-edit fixtures work in the past, and the page walk's stamp case checks that a time yet to come is refused

  • Correct how the gate reads a citation that names more than one file. A line number belonged to every file its row mentioned rather than to the file named before it, so 385 rows handed 4,660 line references to modules no claim makes them about, across 132 of the 158 files the ledger names. praxis/launcher.py was credited with 477 such lines, praxis/core/execution_manager.py with 373 and praxis/trading.py with 334. _cited_lines now attributes each number to the nearest file named ahead of it and leaves out a number with no file named before it at all, which is the reading _evidence_totals already gave them, so the article and claim counts do not move

  • Correct the one figure the ledger states about its own coverage, which the misreading above had carried. execution_manager.py has 2,419 of its 2,504 statements cited, not 2,422, and the 85 that are not — not 82 — are still only the three kinds the gate refuses to let a claim name: 70 log calls, 13 insistences and 2 bare re-raises. Three log calls had been counted as cited because rows naming binance_adapter.py and trading.py beside it lent them their line numbers

  • Stop asking for a citation the gate will not accept. _statement_lines counted the heading of a function written inside another as a statement needing an article, while _signature_lines refuses a citation to any such heading, so 44 lines across launcher.py, trading.py and binance_adapter.py were owed an article that could not be written. A nested declaration is now read as the declaration it is

  • Fix the gate's own test suite where a fixture could stop testing without failing. Three helpers took their example from the register or the ledger as it stood and skipped when it no longer held one, which is how two tests of the open-candidate check came to skip in silence; they now build the rows they need outright. The lagged-cell fixture named a Nexus module, so it failed outright wherever only one tree is checked out, and now finds a Praxis module that reads full with every statement cited. The settled-candidate tests named two harvest rows by number and now synthesise theirs, with a case for each of the four words that settle a row

  • Clone Nexus beside the checkout in the tests workflow, under NEXUS_READ_TOKEN. Fourteen tests covering the gate's Nexus side skip where that tree is absent, and the suite reported green having skipped them

  • Write the docstrings added to the gate with single quotes, as the rest of the tree does

  • Correct ten claims in the new articles that misread the code they cite. A replacement protective pair the venue cannot be asked about was described as protection lost, when only a pair the venue returns marked rejected is — anything unanswerable leaves it unknown. A stop between cancelling a single order and placing its replacement was described as leaving the old order resting, when by then it is gone and nothing stands in its place. A schedule change was described as always replanning, when only a change to the count does. A ladder amend's clean write-off was described as the road a cancellation failure takes, when a cancel is already committed by then. Also: the holding and the reported amount part company over a buy's commission as well as over the budget, the venue sweep is per symbol and counts closed orders as known, a movement in another asset carries the mark forward without a handover, and a resumed ladder needs more than its surviving rungs settling to finish

  • Finish three articles that covered a path and left out a branch a reader needs. When a send's outcome is unknown now carries the fill that arrives after the send was written off as refused: it is taken into the closed order, the ending already reported stands, and the name cannot be used again. How a price change is carried out now says what a restart keeps of a change — the count the next name is built from, and nothing else, the change itself living in memory alone. Two further subjects outgrew their parents and became articles of their own: the window a movement is found in, which never reaches back past the moment the account was taken on, and a weight curve that plans a part of nothing, caught on the way out rather than at the start

  • Count a figure in the wiki's own prose that a line wrap separated from the thing it counts. Every count the gate checks was matched with a literal space, so the index's article count sat wrong across a wrap while the check passed. Every count the gate reads now matches across any whitespace, and a term another article owns is matched as whole words with the same tolerance — so order booked no longer reads as the order book, and a term wrapped onto the next line no longer escapes needing its link

  • State the finite, positive requirement a protective pair's figures are held to, and the refusal of a change raising a buy's commitment, in the prose of the articles that cite them rather than in their front matter alone

  • Ask Unicode what a character is rather than matching a class of them, where the gate refuses a character the YAML behind the front matter cannot carry. The class was written as everything outside the characters it allows, which needed an eight-digit escape for the range past the basic multilingual plane; rewriting it as the characters it refuses only moved the complaint from that escape to the control range, py/overly-large-range holding against scripts/check_wiki.py either way. _uncarried now reads each character's Unicode category and refuses exactly the same 2,113 of the 1,114,112 code points: the controls but for a tab and a next line, the surrogates, and the two noncharacters closing the basic plane

  • Stop the test that reads the register's account of the obligation rule from backtracking exponentially. Its pattern let an open parenthesis be taken either by the run of plain characters or by the start of a nested group, so a string of many of them would have taken exponential time to reject; excluding it from the plain runs leaves one reading of every input and captures the same text. py/redos had held against tests/test_check_wiki.py since the branch's first analysis

  • Correct what the live-leg guard is said to refuse, in when a flatten places nothing. The article had an unanswerable leg stopping the flatten, which holds for a query that errors and not for one the venue answers by saying it holds no such list: that reading counts as nothing live, the flatten goes ahead, and any leg behind the missing one is never asked about. The guard's own docstring says a query failure is treated as live, which is where the overstatement came from, the body having two readings where the docstring has one

  • Measure a cited span against the file before opening it out. _cited_lines turned a citation's digits into numbers and expanded the range with nothing asked of either end, so a span naming a billionth line would ask for a billion numbers to be held at once, and one of five thousand digits would end the run where the gate means to report it. Both ends now go through _as_line, which the two checks that already read a span use, and a span reaching past the end of its file adds nothing. Measuring a span means reading the file, so one whose tree is not checked out is passed over here as it is everywhere else. Every line reference in the corpus is left where it was

  • Count an annotation given a value among the lines a module has to have cited. _statement_lines excluded every ast.AnnAssign, which is the node for a bare held: int and equally for the data: Any = await response.json() a depth reply arrives by, so a type written on a line exempted whatever that line does. The exclusion was holding 326 lines across 63 of the modules the wiki cites, 158 of them cited by no article, and of those 147 declare state and nothing more, being a constant or a fresh empty container, while 11 run something. Only the 10 bare annotations are left out now. _lagging_cells is the one check that reads the set, and it refuses a partial row with nothing left uncited, so a larger set can only quiet it: every reading in the ledger is where it was

  • Cite the four of those statements worth an article, in the order book, what an order type decides about its parameters, which health figures are read under the lock and where credentials come from: the depth reply decoded while the request is still open, the five fields every order carries before its kind's demands apply, the tracker made for each account the adapter is handed credentials for, and the copy it takes of that mapping. Of the seven others, three are keyword mappings in a test, two are a logging set-up no article reaches, one is a weight window opened at construction, and one is a null stand-in taken for a lock that was not passed

Change

  • State the wiki's scope as both repositories, which is what issue #185 asks for. The index and the register had come to say the wiki was about Praxis and that Nexus was not in the package — a narrowing that was never asked for and does not match the brief, which puts Nexus's 81 files in scope and requires boundary articles written from both ends. Seed the seven Nexus subjects a reader of the Praxis side is left needing, as candidates for their own Seed stage

  • Name six Nexus modules in the ledger with a row of their own rather than a passing citation, taking the modules it names from 17 to 21 of the 70: the two reactions a reported finding runs into, the two lists of answers they choose from, and the mode controller and manifest those answers reach. Praxis stands at 46 full, 38 partial and 4 uncovered, bracket_params.py having moved off the uncovered list

  • Order the index by the chain the work runs down rather than by repository. How the wiki works and where to start now head the page, where the account of what is covered had stood at line 810 of 821, below every entry; the walk from a strategy through the checks, the money set aside, the command, the send and the outcome replaces a start that began at a trade; and the Nexus groups precede the Praxis vocabulary they hand work to. The heading that read "what Nexus does with the money" is split into eight, having grown to 323 of the 719 entries while drawing on 94 modules with none above a twentieth of it, where every other heading of twenty or more rests on two to eight with one of them between a third and all of it; the Praxis modules parked under it return to the headings that already name them, leaving the largest at 72. Every entry is carried over as it was written

  • Say that both repositories are written, in the index. The line read that Praxis was the side that had been written, which its own next three sentences contradict — all 70 Nexus modules named, 64 carrying a row, every one of those accounted for in full — and which 233 of the index's entries contradict too

Edit this sourceCheckout revision · 7381aa49
Reference / keep your place
Find a passage