Publish Microstructure code and documentation package

Microstructure/.gitignore

@@ -0,0 +1,36 @@
+.DS_Store
+.idea/
+.vscode/
+.venv/
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+
+# External and generated research data must stay local.
+data/raw/**
+data/normalized/**
+data/derived/**
+data/models/**
+data/quality/**
+data/_ingestion_manifests/**
+data/m8/**
+data/m8_l2/**
+data/exploratory_aggtrades_2026-08-05_08/**
+!data/raw/.gitkeep
+!data/normalized/.gitkeep
+!data/derived/.gitkeep
+!data/models/.gitkeep
+!data/quality/.gitkeep
+!data/_ingestion_manifests/.gitkeep
+
+# Generated run artifacts are reproducible and may contain large files.
+artifacts/runs/**
+!artifacts/runs/.gitkeep
+
+# Generated dashboard/runtime files.
+.streamlit/secrets.toml

Microstructure/.python-version

@@ -0,0 +1 @@
+3.12

Microstructure/AGENTS.md

@@ -0,0 +1,66 @@
+# Repository instructions
+
+These instructions apply to the entire repository.
+
+## Mission and safety boundary
+
+Build a reproducible research and simulation system for short-horizon market
+microstructure. The repository must never place live orders, authenticate to a
+trading account, or imply that a simulated result is executable profit.
+
+## Research integrity
+
+- Never invent observations, performance, statistical significance, or a data
+  source. Label synthetic, fixture, smoke-test, partial, and full-data results.
+- Keep predictive quality, execution assumptions, and strategy results separate.
+- Every generated result must include the configuration hash, input manifest
+  hashes, UTC data interval, code version or explicit `UNBORN`, and dirty state.
+- Preserve raw observations. Put transformations in normalized or derived data
+  and log exclusions; do not silently repair suspect events.
+- Treat a timestamp at decision time `t` as unavailable unless its event and
+  receipt ordering prove it was observable at `t`. Features use information at
+  or before `t`; labels begin strictly after `t`.
+- Do not tune against the final test period. Use time-ordered splits, purge
+  overlapping label horizons, and embargo adjacent folds when configured.
+
+## Engineering conventions
+
+- Target Python 3.12 and a local Apple Silicon machine with 16 GB RAM.
+- Keep core logic in `src/microstructure`; notebooks may call but not duplicate it.
+- Prefer Polars lazy/streaming scans and partitioned Parquet. DuckDB may query
+  partitions without loading the full data set.
+- New data sources implement the adapter interfaces; exchange-specific fields do
+  not leak into normalized research modules.
+- Store timestamps as UTC epoch nanoseconds and prices/quantities as decimal-safe
+  integer ticks/lots where the adapter supplies metadata; floating research
+  columns must document their units.
+- Randomized procedures require an explicit seed.
+- External raw data belongs under ignored `data/raw`; only small, documented test
+  fixtures belong in Git.
+
+## Verification
+
+Run focused tests after each meaningful phase and `make check` before handoff.
+Tests must cover sequence gaps and book invariants, temporal leakage, purged
+splits, deterministic simulations, partial fills, fees, and latency. A test may
+not call the public internet; mock adapters at the HTTP boundary.
+
+Primary commands:
+
+```text
+make setup
+make download-sample
+make validate-data
+make smoke
+make test
+make reproduce-sample
+make report
+make dashboard
+```
+
+## Documentation discipline
+
+Record material assumptions and reversals in `docs/DECISION_LOG.md`. Keep
+`STATUS.md` honest and current. Update `docs/PROJECT_PLAN.md` acceptance evidence
+when a milestone moves state. Do not manually paste model metrics into prose;
+reports must read machine-generated run artifacts.

Microstructure/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Microstructure Research Project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Microstructure/Makefile

@@ -0,0 +1,202 @@
+PYTHON_BIN ?= python3.12
+PYTHON ?= .venv/bin/python
+RUN_DIR ?= artifacts/runs/sample-smoke
+PUBLIC_RUN_DIR ?= artifacts/runs/binance-public-sample
+SMOKE_CONFIG ?= configs/smoke.toml
+PUBLIC_CONFIG ?= configs/public_sample.toml
+PUBLIC_INGESTION_MANIFEST ?=
+PUBLIC_INGESTION_MANIFEST_SHA256 ?=
+M8_CONFIG ?= configs/m8_multidate_trade_study.toml
+M8_DATA_ROOT ?= data/m8
+M8_RUN_DIR ?= artifacts/runs/binance-m8-multidate
+M8_RAW_MANIFEST ?=
+M8_RAW_MANIFEST_SHA256 ?=
+M8_L2_CONFIG ?= configs/m8_l2_capture_study.toml
+M8_L2_ANALYSIS_CONFIG ?= configs/m8_l2_analysis.toml
+M8_L2_DATA_ROOT ?= data/m8_l2
+M8_L2_SESSION_DATE ?=
+M8_L2_BUNDLE_DIR ?=
+M8_L2_TRAIN_BUNDLE_DIR ?=
+M8_L2_TRAIN_MANIFEST_SHA256 ?=
+M8_L2_TRAIN_CHECKSUMS_SHA256 ?=
+M8_L2_VALIDATION_BUNDLE_DIR ?=
+M8_L2_VALIDATION_MANIFEST_SHA256 ?=
+M8_L2_VALIDATION_CHECKSUMS_SHA256 ?=
+M8_L2_DEVELOPMENT_LOCK_DIR ?=
+M8_L2_DEVELOPMENT_LOCK_SHA256 ?=
+M8_L2_PRIMARY_BUNDLE_DIR ?=
+M8_L2_PRIMARY_MANIFEST_SHA256 ?=
+M8_L2_PRIMARY_CHECKSUMS_SHA256 ?=
+M8_L2_REPLICATION_BUNDLE_DIR ?=
+M8_L2_REPLICATION_MANIFEST_SHA256 ?=
+M8_L2_REPLICATION_CHECKSUMS_SHA256 ?=
+M8_L2_RUN_DIR ?= artifacts/runs/binance-m8-live-l2
+M8_L2_RUN_MANIFEST_SHA256 ?=
+M8_L2_RUN_CHECKSUMS_SHA256 ?=
+M8_L2_REPORT_DIR ?= artifacts/runs/binance-m8-live-l2-reports
+
+.PHONY: setup download-sample download-m8 capture-m8-l2-session verify-m8-l2-session lock-m8-l2-development verify-m8-l2-development-lock reproduce-m8-l2 verify-m8-l2-run report-m8-l2 validate-data validate-public-data smoke check-smoke test reproduce-sample reproduce-public-sample reproduce-m8 verify-run verify-public-run verify-m8-run report report-public report-m8 dashboard dashboard-public lint typecheck check
+
+setup:
+	@if command -v uv >/dev/null 2>&1; then \
+		uv sync --locked --extra dev; \
+	else \
+		"$(PYTHON_BIN)" -m venv .venv; \
+		.venv/bin/python -m pip install --upgrade pip; \
+		.venv/bin/pip install -e ".[dev]"; \
+	fi
+
+download-sample:
+	$(PYTHON) -m microstructure.cli ingest --config $(PUBLIC_CONFIG)
+
+download-m8:
+	$(PYTHON) -m microstructure.cli acquire-m8 --config "$(M8_CONFIG)" --output-root "$(M8_DATA_ROOT)"
+
+capture-m8-l2-session:
+	@test -n "$(M8_L2_SESSION_DATE)" || { echo "M8_L2_SESSION_DATE is required"; exit 2; }
+	@status=0; $(PYTHON) -m microstructure.cli capture-m8-l2-session --config "$(M8_L2_CONFIG)" --date "$(M8_L2_SESSION_DATE)" --output-root "$(M8_L2_DATA_ROOT)" || status=$$?; if [ "$$status" -eq 1 ]; then exit 0; fi; exit "$$status"
+
+verify-m8-l2-session:
+	@test -n "$(M8_L2_BUNDLE_DIR)" || { echo "M8_L2_BUNDLE_DIR is required"; exit 2; }
+	$(PYTHON) -m microstructure.cli verify-m8-l2-session --config "$(M8_L2_CONFIG)" --bundle-dir "$(M8_L2_BUNDLE_DIR)"
+
+lock-m8-l2-development:
+	@test -n "$(M8_L2_TRAIN_BUNDLE_DIR)" || { echo "M8_L2_TRAIN_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_TRAIN_MANIFEST_SHA256)" || { echo "M8_L2_TRAIN_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_TRAIN_CHECKSUMS_SHA256)" || { echo "M8_L2_TRAIN_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_BUNDLE_DIR)" || { echo "M8_L2_VALIDATION_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_MANIFEST_SHA256)" || { echo "M8_L2_VALIDATION_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_CHECKSUMS_SHA256)" || { echo "M8_L2_VALIDATION_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_DEVELOPMENT_LOCK_DIR)" || { echo "M8_L2_DEVELOPMENT_LOCK_DIR is required"; exit 2; }
+	@status=0; $(PYTHON) -m microstructure.cli lock-m8-l2-development --capture-config "$(M8_L2_CONFIG)" --analysis-config "$(M8_L2_ANALYSIS_CONFIG)" --train-bundle-dir "$(M8_L2_TRAIN_BUNDLE_DIR)" --train-manifest-sha256 "$(M8_L2_TRAIN_MANIFEST_SHA256)" --train-checksums-sha256 "$(M8_L2_TRAIN_CHECKSUMS_SHA256)" --validation-bundle-dir "$(M8_L2_VALIDATION_BUNDLE_DIR)" --validation-manifest-sha256 "$(M8_L2_VALIDATION_MANIFEST_SHA256)" --validation-checksums-sha256 "$(M8_L2_VALIDATION_CHECKSUMS_SHA256)" --lock-dir "$(M8_L2_DEVELOPMENT_LOCK_DIR)" || status=$$?; if [ "$$status" -eq 1 ]; then exit 0; fi; exit "$$status"
+
+verify-m8-l2-development-lock:
+	@test -n "$(M8_L2_TRAIN_BUNDLE_DIR)" || { echo "M8_L2_TRAIN_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_TRAIN_MANIFEST_SHA256)" || { echo "M8_L2_TRAIN_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_TRAIN_CHECKSUMS_SHA256)" || { echo "M8_L2_TRAIN_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_BUNDLE_DIR)" || { echo "M8_L2_VALIDATION_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_MANIFEST_SHA256)" || { echo "M8_L2_VALIDATION_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_CHECKSUMS_SHA256)" || { echo "M8_L2_VALIDATION_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_DEVELOPMENT_LOCK_DIR)" || { echo "M8_L2_DEVELOPMENT_LOCK_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_DEVELOPMENT_LOCK_SHA256)" || { echo "M8_L2_DEVELOPMENT_LOCK_SHA256 is required"; exit 2; }
+	@status=0; $(PYTHON) -m microstructure.cli verify-m8-l2-development-lock --capture-config "$(M8_L2_CONFIG)" --analysis-config "$(M8_L2_ANALYSIS_CONFIG)" --train-bundle-dir "$(M8_L2_TRAIN_BUNDLE_DIR)" --train-manifest-sha256 "$(M8_L2_TRAIN_MANIFEST_SHA256)" --train-checksums-sha256 "$(M8_L2_TRAIN_CHECKSUMS_SHA256)" --validation-bundle-dir "$(M8_L2_VALIDATION_BUNDLE_DIR)" --validation-manifest-sha256 "$(M8_L2_VALIDATION_MANIFEST_SHA256)" --validation-checksums-sha256 "$(M8_L2_VALIDATION_CHECKSUMS_SHA256)" --lock-dir "$(M8_L2_DEVELOPMENT_LOCK_DIR)" --development-lock-sha256 "$(M8_L2_DEVELOPMENT_LOCK_SHA256)" || status=$$?; if [ "$$status" -eq 1 ]; then exit 0; fi; exit "$$status"
+
+reproduce-m8-l2:
+	@test -n "$(M8_L2_TRAIN_BUNDLE_DIR)" || { echo "M8_L2_TRAIN_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_TRAIN_MANIFEST_SHA256)" || { echo "M8_L2_TRAIN_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_TRAIN_CHECKSUMS_SHA256)" || { echo "M8_L2_TRAIN_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_BUNDLE_DIR)" || { echo "M8_L2_VALIDATION_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_MANIFEST_SHA256)" || { echo "M8_L2_VALIDATION_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_CHECKSUMS_SHA256)" || { echo "M8_L2_VALIDATION_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_DEVELOPMENT_LOCK_DIR)" || { echo "M8_L2_DEVELOPMENT_LOCK_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_DEVELOPMENT_LOCK_SHA256)" || { echo "M8_L2_DEVELOPMENT_LOCK_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_PRIMARY_BUNDLE_DIR)" || { echo "M8_L2_PRIMARY_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_PRIMARY_MANIFEST_SHA256)" || { echo "M8_L2_PRIMARY_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_PRIMARY_CHECKSUMS_SHA256)" || { echo "M8_L2_PRIMARY_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_REPLICATION_BUNDLE_DIR)" || { echo "M8_L2_REPLICATION_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_REPLICATION_MANIFEST_SHA256)" || { echo "M8_L2_REPLICATION_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_REPLICATION_CHECKSUMS_SHA256)" || { echo "M8_L2_REPLICATION_CHECKSUMS_SHA256 is required"; exit 2; }
+	@status=0; $(PYTHON) -m microstructure.cli reproduce-m8-l2 --capture-config "$(M8_L2_CONFIG)" --analysis-config "$(M8_L2_ANALYSIS_CONFIG)" --train-bundle-dir "$(M8_L2_TRAIN_BUNDLE_DIR)" --train-manifest-sha256 "$(M8_L2_TRAIN_MANIFEST_SHA256)" --train-checksums-sha256 "$(M8_L2_TRAIN_CHECKSUMS_SHA256)" --validation-bundle-dir "$(M8_L2_VALIDATION_BUNDLE_DIR)" --validation-manifest-sha256 "$(M8_L2_VALIDATION_MANIFEST_SHA256)" --validation-checksums-sha256 "$(M8_L2_VALIDATION_CHECKSUMS_SHA256)" --development-lock-dir "$(M8_L2_DEVELOPMENT_LOCK_DIR)" --development-lock-sha256 "$(M8_L2_DEVELOPMENT_LOCK_SHA256)" --primary-bundle-dir "$(M8_L2_PRIMARY_BUNDLE_DIR)" --primary-manifest-sha256 "$(M8_L2_PRIMARY_MANIFEST_SHA256)" --primary-checksums-sha256 "$(M8_L2_PRIMARY_CHECKSUMS_SHA256)" --replication-bundle-dir "$(M8_L2_REPLICATION_BUNDLE_DIR)" --replication-manifest-sha256 "$(M8_L2_REPLICATION_MANIFEST_SHA256)" --replication-checksums-sha256 "$(M8_L2_REPLICATION_CHECKSUMS_SHA256)" --run-dir "$(M8_L2_RUN_DIR)" || status=$$?; if [ "$$status" -eq 1 ]; then exit 0; fi; exit "$$status"
+
+verify-m8-l2-run:
+	@test -n "$(M8_L2_TRAIN_BUNDLE_DIR)" || { echo "M8_L2_TRAIN_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_TRAIN_MANIFEST_SHA256)" || { echo "M8_L2_TRAIN_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_TRAIN_CHECKSUMS_SHA256)" || { echo "M8_L2_TRAIN_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_BUNDLE_DIR)" || { echo "M8_L2_VALIDATION_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_MANIFEST_SHA256)" || { echo "M8_L2_VALIDATION_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_CHECKSUMS_SHA256)" || { echo "M8_L2_VALIDATION_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_DEVELOPMENT_LOCK_DIR)" || { echo "M8_L2_DEVELOPMENT_LOCK_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_DEVELOPMENT_LOCK_SHA256)" || { echo "M8_L2_DEVELOPMENT_LOCK_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_PRIMARY_BUNDLE_DIR)" || { echo "M8_L2_PRIMARY_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_PRIMARY_MANIFEST_SHA256)" || { echo "M8_L2_PRIMARY_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_PRIMARY_CHECKSUMS_SHA256)" || { echo "M8_L2_PRIMARY_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_REPLICATION_BUNDLE_DIR)" || { echo "M8_L2_REPLICATION_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_REPLICATION_MANIFEST_SHA256)" || { echo "M8_L2_REPLICATION_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_REPLICATION_CHECKSUMS_SHA256)" || { echo "M8_L2_REPLICATION_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_RUN_MANIFEST_SHA256)" || { echo "M8_L2_RUN_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_RUN_CHECKSUMS_SHA256)" || { echo "M8_L2_RUN_CHECKSUMS_SHA256 is required"; exit 2; }
+	@status=0; $(PYTHON) -m microstructure.cli verify-m8-l2-run --capture-config "$(M8_L2_CONFIG)" --analysis-config "$(M8_L2_ANALYSIS_CONFIG)" --train-bundle-dir "$(M8_L2_TRAIN_BUNDLE_DIR)" --train-manifest-sha256 "$(M8_L2_TRAIN_MANIFEST_SHA256)" --train-checksums-sha256 "$(M8_L2_TRAIN_CHECKSUMS_SHA256)" --validation-bundle-dir "$(M8_L2_VALIDATION_BUNDLE_DIR)" --validation-manifest-sha256 "$(M8_L2_VALIDATION_MANIFEST_SHA256)" --validation-checksums-sha256 "$(M8_L2_VALIDATION_CHECKSUMS_SHA256)" --development-lock-dir "$(M8_L2_DEVELOPMENT_LOCK_DIR)" --development-lock-sha256 "$(M8_L2_DEVELOPMENT_LOCK_SHA256)" --primary-bundle-dir "$(M8_L2_PRIMARY_BUNDLE_DIR)" --primary-manifest-sha256 "$(M8_L2_PRIMARY_MANIFEST_SHA256)" --primary-checksums-sha256 "$(M8_L2_PRIMARY_CHECKSUMS_SHA256)" --replication-bundle-dir "$(M8_L2_REPLICATION_BUNDLE_DIR)" --replication-manifest-sha256 "$(M8_L2_REPLICATION_MANIFEST_SHA256)" --replication-checksums-sha256 "$(M8_L2_REPLICATION_CHECKSUMS_SHA256)" --run-dir "$(M8_L2_RUN_DIR)" --run-manifest-sha256 "$(M8_L2_RUN_MANIFEST_SHA256)" --run-checksums-sha256 "$(M8_L2_RUN_CHECKSUMS_SHA256)" || status=$$?; if [ "$$status" -eq 1 ]; then exit 0; fi; exit "$$status"
+
+report-m8-l2:
+	@test -n "$(M8_L2_TRAIN_BUNDLE_DIR)" || { echo "M8_L2_TRAIN_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_TRAIN_MANIFEST_SHA256)" || { echo "M8_L2_TRAIN_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_TRAIN_CHECKSUMS_SHA256)" || { echo "M8_L2_TRAIN_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_BUNDLE_DIR)" || { echo "M8_L2_VALIDATION_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_MANIFEST_SHA256)" || { echo "M8_L2_VALIDATION_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_VALIDATION_CHECKSUMS_SHA256)" || { echo "M8_L2_VALIDATION_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_DEVELOPMENT_LOCK_DIR)" || { echo "M8_L2_DEVELOPMENT_LOCK_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_DEVELOPMENT_LOCK_SHA256)" || { echo "M8_L2_DEVELOPMENT_LOCK_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_PRIMARY_BUNDLE_DIR)" || { echo "M8_L2_PRIMARY_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_PRIMARY_MANIFEST_SHA256)" || { echo "M8_L2_PRIMARY_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_PRIMARY_CHECKSUMS_SHA256)" || { echo "M8_L2_PRIMARY_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_REPLICATION_BUNDLE_DIR)" || { echo "M8_L2_REPLICATION_BUNDLE_DIR is required"; exit 2; }
+	@test -n "$(M8_L2_REPLICATION_MANIFEST_SHA256)" || { echo "M8_L2_REPLICATION_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_REPLICATION_CHECKSUMS_SHA256)" || { echo "M8_L2_REPLICATION_CHECKSUMS_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_RUN_MANIFEST_SHA256)" || { echo "M8_L2_RUN_MANIFEST_SHA256 is required"; exit 2; }
+	@test -n "$(M8_L2_RUN_CHECKSUMS_SHA256)" || { echo "M8_L2_RUN_CHECKSUMS_SHA256 is required"; exit 2; }
+	@status=0; $(PYTHON) -m microstructure.cli report-m8-l2 --capture-config "$(M8_L2_CONFIG)" --analysis-config "$(M8_L2_ANALYSIS_CONFIG)" --train-bundle-dir "$(M8_L2_TRAIN_BUNDLE_DIR)" --train-manifest-sha256 "$(M8_L2_TRAIN_MANIFEST_SHA256)" --train-checksums-sha256 "$(M8_L2_TRAIN_CHECKSUMS_SHA256)" --validation-bundle-dir "$(M8_L2_VALIDATION_BUNDLE_DIR)" --validation-manifest-sha256 "$(M8_L2_VALIDATION_MANIFEST_SHA256)" --validation-checksums-sha256 "$(M8_L2_VALIDATION_CHECKSUMS_SHA256)" --development-lock-dir "$(M8_L2_DEVELOPMENT_LOCK_DIR)" --development-lock-sha256 "$(M8_L2_DEVELOPMENT_LOCK_SHA256)" --primary-bundle-dir "$(M8_L2_PRIMARY_BUNDLE_DIR)" --primary-manifest-sha256 "$(M8_L2_PRIMARY_MANIFEST_SHA256)" --primary-checksums-sha256 "$(M8_L2_PRIMARY_CHECKSUMS_SHA256)" --replication-bundle-dir "$(M8_L2_REPLICATION_BUNDLE_DIR)" --replication-manifest-sha256 "$(M8_L2_REPLICATION_MANIFEST_SHA256)" --replication-checksums-sha256 "$(M8_L2_REPLICATION_CHECKSUMS_SHA256)" --run-dir "$(M8_L2_RUN_DIR)" --run-manifest-sha256 "$(M8_L2_RUN_MANIFEST_SHA256)" --run-checksums-sha256 "$(M8_L2_RUN_CHECKSUMS_SHA256)" --output-dir "$(M8_L2_REPORT_DIR)" || status=$$?; if [ "$$status" -eq 1 ]; then exit 0; fi; exit "$$status"
+
+validate-data:
+	$(PYTHON) -m microstructure.cli validate --config $(SMOKE_CONFIG)
+
+validate-public-data:
+	$(PYTHON) -m microstructure.cli validate --config $(PUBLIC_CONFIG)
+
+smoke:
+	$(PYTHON) -m microstructure.cli reproduce --config $(SMOKE_CONFIG) --run-dir $(RUN_DIR)
+
+check-smoke:
+	@check_root="$$(mktemp -d)"; \
+	trap 'rm -rf "$$check_root"' EXIT; \
+	$(PYTHON) -m microstructure.cli reproduce --config $(SMOKE_CONFIG) --run-dir "$$check_root/run"
+
+test:
+	$(PYTHON) -m pytest
+
+reproduce-sample: smoke
+
+reproduce-public-sample:
+	@test -n "$(PUBLIC_INGESTION_MANIFEST)" || { echo "PUBLIC_INGESTION_MANIFEST is required"; exit 2; }
+	@test -n "$(PUBLIC_INGESTION_MANIFEST_SHA256)" || { echo "PUBLIC_INGESTION_MANIFEST_SHA256 is required"; exit 2; }
+	$(PYTHON) -m microstructure.cli reproduce --config $(PUBLIC_CONFIG) --run-dir $(PUBLIC_RUN_DIR) --ingestion-manifest $(PUBLIC_INGESTION_MANIFEST) --ingestion-manifest-sha256 $(PUBLIC_INGESTION_MANIFEST_SHA256)
+
+reproduce-m8:
+	@test -n "$(M8_RAW_MANIFEST)" || { echo "M8_RAW_MANIFEST is required"; exit 2; }
+	@test -n "$(M8_RAW_MANIFEST_SHA256)" || { echo "M8_RAW_MANIFEST_SHA256 is required"; exit 2; }
+	$(PYTHON) -m microstructure.cli reproduce-m8 --config "$(M8_CONFIG)" --run-dir "$(M8_RUN_DIR)" --raw-manifest "$(M8_RAW_MANIFEST)" --raw-manifest-sha256 "$(M8_RAW_MANIFEST_SHA256)"
+
+verify-run:
+	$(PYTHON) -m microstructure.cli verify --run-dir $(RUN_DIR)
+
+verify-public-run:
+	$(PYTHON) -m microstructure.cli verify --run-dir $(PUBLIC_RUN_DIR)
+
+verify-m8-run:
+	@test -n "$(M8_RAW_MANIFEST)" || { echo "M8_RAW_MANIFEST is required"; exit 2; }
+	@test -n "$(M8_RAW_MANIFEST_SHA256)" || { echo "M8_RAW_MANIFEST_SHA256 is required"; exit 2; }
+	$(PYTHON) -m microstructure.cli verify-m8 --config "$(M8_CONFIG)" --run-dir "$(M8_RUN_DIR)" --raw-manifest "$(M8_RAW_MANIFEST)" --raw-manifest-sha256 "$(M8_RAW_MANIFEST_SHA256)"
+
+report:
+	$(PYTHON) -m microstructure.cli report --run-dir $(RUN_DIR)
+
+report-public:
+	$(PYTHON) -m microstructure.cli report --run-dir $(PUBLIC_RUN_DIR)
+
+report-m8:
+	@test -n "$(M8_RAW_MANIFEST)" || { echo "M8_RAW_MANIFEST is required"; exit 2; }
+	@test -n "$(M8_RAW_MANIFEST_SHA256)" || { echo "M8_RAW_MANIFEST_SHA256 is required"; exit 2; }
+	$(PYTHON) -m microstructure.cli report-m8 --config "$(M8_CONFIG)" --run-dir "$(M8_RUN_DIR)" --raw-manifest "$(M8_RAW_MANIFEST)" --raw-manifest-sha256 "$(M8_RAW_MANIFEST_SHA256)"
+
+dashboard:
+	$(PYTHON) -m streamlit run dashboard/app.py -- --run-dir $(RUN_DIR)
+
+dashboard-public:
+	$(PYTHON) -m streamlit run dashboard/app.py -- --run-dir $(PUBLIC_RUN_DIR)
+
+lint:
+	$(PYTHON) -m ruff check .
+
+typecheck:
+	$(PYTHON) -m mypy src/microstructure
+
+check: lint typecheck test check-smoke

Microstructure/README.md

@@ -0,0 +1,509 @@
+# Order Flow to Price Impact
+
+A research-only, event-driven market-microstructure platform for asking:
+
+> When do order-flow imbalance, liquidity, and limit-order-book conditions
+> predict short-horizon price movement, and how much apparent value survives
+> fees, latency, uncertain fills, adverse selection, and inventory risk?
+
+The project is deliberately reproducibility-first. It keeps market-data evidence,
+predictive diagnostics, execution assumptions, and simulated outcomes separate.
+It has no authenticated exchange client, account connection, or order-entry path.
+
+> **Evidence boundary:** `SYNTHETIC_SMOKE` output verifies software behavior only.
+> It is not market, alpha, profitability, or investment evidence.
+
+## Architecture
+
+```mermaid
+flowchart LR
+    A["Public REST trades or deterministic synthetic events"] --> B["Raw bytes + immutable manifests"]
+    C["Optional public live diff-depth + REST snapshot"] --> B
+    B --> D["Versioned UTC-normalized Arrow schemas"]
+    D --> E["Partitioned, content-addressed Parquet"]
+    E --> F["Non-mutating quality findings"]
+    F --> G["Causal features + strictly future labels"]
+    G --> H["Purged expanding walk-forward models"]
+    H --> I["OOS-only execution simulation"]
+    I --> J["Frozen checksummed run bundle"]
+    J --> K["Generated reports + read-only dashboard"]
+```
+
+The normalized event contract retains exchange time, local receipt time when
+captured, the conservative availability clock used by research, exact integer
+ticks/lots, sequence identifiers, and a continuity epoch. Features, labels,
+folds, open orders, and markouts cannot cross a known book gap.
+
+## Quick start
+
+Python 3.12 is required. The default acceptance path is deterministic and does
+not need internet access:
+
+```bash
+make setup
+make check
+make reproduce-sample
+make report
+```
+
+The frozen sample is written to `artifacts/runs/sample-smoke`; independently
+rendered reports go to `artifacts/runs/sample-smoke-reports`. Both directories
+are reproducible and intentionally ignored by Git.
+
+To inspect the completed run:
+
+```bash
+make verify-run
+make dashboard
+```
+
+The dashboard loads only checksum-verified artifacts. It does not download data,
+fit models, rerun simulations, or place orders.
+
+## Credential-free public sample
+
+The bounded public path downloads BTCUSDT and ETHUSDT aggregate trades from a
+fixed UTC interval, fetches `exchangeInfo` for exact tick and lot scales, keeps
+the response bytes, and writes raw and normalized manifests:
+
+```bash
+make download-sample
+.venv/bin/python -m microstructure.cli validate \
+  --config configs/public_sample.toml
+```
+
+It uses Binance's public market-data-only REST base URL and requires no API key.
+The adapter honors retryable status codes, `Retry-After`, and interrupted body
+streams; paginates by trade ID to avoid losing tied timestamps; enforces a
+response-byte ceiling; and imposes a small per-symbol row cap. Pages flow once
+through disk-backed incremental validation into bounded Parquet batches. See
+the official [Spot REST documentation](https://developers.binance.com/en/docs/products/spot/rest-api)
+and [Spot WebSocket stream guide](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-streams/~).
+
+Historical public trade ingestion and live order-book collection are separate on
+purpose. Public historical Spot depth is not assumed to exist. A book-based
+empirical study begins only after a continuous local snapshot/delta epoch has
+been captured and passed sequence checks.
+
+Producing a public research bundle never scans for a "latest" input. Select the
+immutable ingestion manifest explicitly by both path and digest:
+
+```bash
+make reproduce-public-sample \
+  PUBLIC_INGESTION_MANIFEST=data/_ingestion_manifests/<manifest>.json \
+  PUBLIC_INGESTION_MANIFEST_SHA256=<64-character-sha256>
+make verify-public-run
+make report-public
+```
+
+## Frozen multi-date trade study
+
+The prospective M8 trade-only study uses the complete BTCUSDT and ETHUSDT
+Binance Spot daily aggregate-trade archives for 2024-01-03 through 2024-01-06.
+Acquisition is deliberately separate from research production:
+
+```bash
+# Networked, raw-only: authenticates ZIP/CHECKSUM/metadata evidence but never
+# opens a CSV member or reads an economic field.
+make download-m8
+
+# Copy the manifest path and lowercase SHA-256 printed by download-m8.
+# Production requires the exact clean committed source tree.
+make reproduce-m8 \
+  M8_RAW_MANIFEST=data/m8/_manifests/<manifest>.json \
+  M8_RAW_MANIFEST_SHA256=<64-character-sha256>
+make verify-m8-run \
+  M8_RAW_MANIFEST=data/m8/_manifests/<manifest>.json \
+  M8_RAW_MANIFEST_SHA256=<64-character-sha256>
+make report-m8 \
+  M8_RAW_MANIFEST=data/m8/_manifests/<manifest>.json \
+  M8_RAW_MANIFEST_SHA256=<64-character-sha256>
+```
+
+The producer opens and validates only the train and validation members first.
+It fits and calibrates the selected model and an independent historical prior
+exactly once on development data, persists their canonical numeric preprocessing
+and estimator states in each per-symbol lock, closes one aggregate lock, and
+revalidates the exact protocol, config, Git/source identity, raw authority,
+development manifest, fitted-state hashes, and child locks immediately before
+every held-out member is opened. Held-out evaluation restores those states with
+no fit, refit, recalibration, or update.
+A declared-data failure becomes an immutable `INSUFFICIENT_DATA` bundle with no
+replacement date or endpoint predictions. A successful bundle remains
+trade-only: execution, P&L, capacity, significance, and cross-instrument pooling
+are unauthorized by the protocol.
+
+That failure branch is the observed outcome of the declared study. The canonical
+bundle at `artifacts/runs/binance-m8-multidate` stopped on the ETHUSDT training
+archive after complete normalization found 53 `temporal.long_silence` warnings.
+BTCUSDT training normalization had already completed with 2,071,461 rows and no
+findings; ETHUSDT contributed 987,297 rows, zero errors, and 53 warnings. The
+producer did not start selection, create a development lock, open either held-out
+date, publish a prediction, or run execution. This is a valid, checksummed
+`INSUFFICIENT_DATA` result, not an incomplete attempt and not evidence against or
+for the economic hypothesis.
+`report-m8` revalidates the terminal and its external raw authority, then renders
+the failure report into a separate report directory. It does not repair, append
+to, or otherwise mutate the canonical failure bundle.
+
+## Frozen live-L2 sessions — replacement campaign v2
+
+Each declared date is captured by one command that waits for the exact common
+UTC barrier and starts both public market-data feeds under one authority. It
+never authenticates or exposes an order-entry path:
+
+```bash
+make capture-m8-l2-session M8_L2_SESSION_DATE=2026-08-10
+```
+
+The superseded v1 campaign is retained as historical control evidence: Aug 8
+was a verified `MISSED_WINDOW`, Aug 9 completed, and its development authority
+is permanently `NOT_CREATED`. It is not rewritten or used by v2. Before any v2
+session was observed, the user explicitly reset the empirical campaign to Aug
+10 train, Aug 11 validation, Aug 12 primary test, and Aug 13 replication test,
+each at 14:00--15:00 UTC. A missed, disconnected, gapped, warning-bearing, or
+otherwise insufficient v2 date is frozen as such and is never replaced. Only
+checksum-verified `COMPLETE` bundles may expose economic frames.
+A verified held-out `INSUFFICIENT_DATA` bundle may be consumed only as control
+evidence for an aggregate insufficiency terminal; its economic frames are never
+opened.
+
+The analysis specification is separately frozen in
+[`docs/M8_L2_ANALYSIS_CONTRACT.md`](docs/M8_L2_ANALYSIS_CONTRACT.md). Its strict
+loader, session input verifier, observed-interval feature/label construction,
+Aug 10/11 development-authority producer, no-refit Aug 12/13 evaluation, market-only
+execution evaluator, descriptive diagnostics, and artifact-driven report
+renderers are integrated behind tested CLI/Make producers and recursive
+verifiers. The software path is complete; no v2 session data existed when the
+10--13 calendar and authority bytes were fixed, so v2 may reach either a valid
+complete result or an honest insufficiency terminal. No L2 metric or execution
+result is claimed before those terminals exist. During the campaign, live
+status belongs only to the immutable campaign/session authorities; this tracked
+README must not be revised between sessions.
+Use the ignored run targets
+`artifacts/runs/binance-m8-l2-development-lock` for the durable development
+authority and `artifacts/runs/binance-m8-live-l2` for the final campaign bundle;
+do not place mutable study state in a source-controlled path.
+
+### Frozen L2 operating sequence
+
+Every later command requires explicit authorities; none scans for a "latest"
+bundle. The Make targets default to the frozen
+`M8_L2_CONFIG=configs/m8_l2_capture_study.toml` and
+`M8_L2_ANALYSIS_CONFIG=configs/m8_l2_analysis.toml`; do not substitute either
+during the campaign. After each capture, retain the emitted JSON. Its
+`output_root`, `session_manifest_sha256`, and `checksums` fields identify the
+bundle, manifest digest, and checksum file. Independently hash that exact
+checksum file:
+
+```bash
+shasum -a 256 /absolute/session/bundle/checksums.sha256
+```
+
+Map those values without abbreviation to the role-specific Make variables:
+
+- `M8_L2_<ROLE>_BUNDLE_DIR`
+- `M8_L2_<ROLE>_MANIFEST_SHA256`
+- `M8_L2_<ROLE>_CHECKSUMS_SHA256`
+
+where `<ROLE>` is `TRAIN`, `VALIDATION`, `PRIMARY`, or `REPLICATION`. Make accepts
+these as command-line assignments or exported environment variables. First
+verify every session. After the Aug 11 validation terminal, create and verify the
+development authority before any held-out analysis. If both development
+sessions are `COMPLETE`, the authority is `LOCKED` and contains the eight fitted
+child states. If either is a valid `INSUFFICIENT_DATA` terminal, the authority is
+`NOT_CREATED`; it contains typed control evidence and deliberately opens no
+economic frame. In either case it is immutable, and the Aug 12/13 captures must
+still proceed on their declared dates:
+
+```bash
+make verify-m8-l2-session M8_L2_BUNDLE_DIR=/absolute/session/bundle
+
+make lock-m8-l2-development \
+  M8_L2_DEVELOPMENT_LOCK_DIR=artifacts/runs/binance-m8-l2-development-lock \
+  M8_L2_TRAIN_BUNDLE_DIR=... M8_L2_TRAIN_MANIFEST_SHA256=... \
+  M8_L2_TRAIN_CHECKSUMS_SHA256=... \
+  M8_L2_VALIDATION_BUNDLE_DIR=... M8_L2_VALIDATION_MANIFEST_SHA256=... \
+  M8_L2_VALIDATION_CHECKSUMS_SHA256=...
+
+make verify-m8-l2-development-lock \
+  M8_L2_DEVELOPMENT_LOCK_DIR=artifacts/runs/binance-m8-l2-development-lock \
+  M8_L2_DEVELOPMENT_LOCK_SHA256=... \
+  M8_L2_TRAIN_BUNDLE_DIR=... M8_L2_TRAIN_MANIFEST_SHA256=... \
+  M8_L2_TRAIN_CHECKSUMS_SHA256=... \
+  M8_L2_VALIDATION_BUNDLE_DIR=... M8_L2_VALIDATION_MANIFEST_SHA256=... \
+  M8_L2_VALIDATION_CHECKSUMS_SHA256=...
+```
+
+Use the `development_lock_sha256` printed by the command for either `LOCKED` or
+`NOT_CREATED`. The direct CLI returns 1 for a valid `NOT_CREATED` command or
+verification; the Make wrapper normalizes that research-terminal code to 0.
+In both cases inspect the JSON status and preserve its `development_lock.json`,
+exact `_NOT_CREATED` marker (`not-created\n`), and printed authority SHA instead
+of retrying or changing dates. After Aug 13, pass
+the same development coordinates plus both held-out authorities to the final
+producer. A `NOT_CREATED` authority forces an aggregate `INSUFFICIENT_DATA`
+result, opens no economic frames from any of the four sessions, and reports the
+union of development and held-out control reasons. The command below explicitly
+lists all four role triplets; none may be omitted or discovered by wildcard:
+
+```bash
+make reproduce-m8-l2 \
+  M8_L2_DEVELOPMENT_LOCK_DIR=artifacts/runs/binance-m8-l2-development-lock \
+  M8_L2_DEVELOPMENT_LOCK_SHA256=... \
+  M8_L2_TRAIN_BUNDLE_DIR=... M8_L2_TRAIN_MANIFEST_SHA256=... \
+  M8_L2_TRAIN_CHECKSUMS_SHA256=... \
+  M8_L2_VALIDATION_BUNDLE_DIR=... M8_L2_VALIDATION_MANIFEST_SHA256=... \
+  M8_L2_VALIDATION_CHECKSUMS_SHA256=... \
+  M8_L2_PRIMARY_BUNDLE_DIR=... M8_L2_PRIMARY_MANIFEST_SHA256=... \
+  M8_L2_PRIMARY_CHECKSUMS_SHA256=... \
+  M8_L2_REPLICATION_BUNDLE_DIR=... M8_L2_REPLICATION_MANIFEST_SHA256=... \
+  M8_L2_REPLICATION_CHECKSUMS_SHA256=...
+```
+
+The producer prints `run_manifest_sha256` and `checksums_sha256`. Reuse the full
+four-session/development authority set and add those two values for
+`verify-m8-l2-run` and `report-m8-l2`. If that full set has been exported under
+the exact Make variable names above, the terminal commands are:
+
+```bash
+make verify-m8-l2-run M8_L2_RUN_MANIFEST_SHA256=... \
+  M8_L2_RUN_CHECKSUMS_SHA256=...
+make report-m8-l2 M8_L2_RUN_MANIFEST_SHA256=... \
+  M8_L2_RUN_CHECKSUMS_SHA256=...
+```
+
+`report-m8-l2` recursively verifies the final run and all external authorities,
+then writes to `artifacts/runs/binance-m8-live-l2-reports`. It never modifies the
+immutable run bundle. At the direct CLI boundary, capture, development, final
+producer, verifier, and report commands use exit 1 for a valid insufficiency
+terminal; Make maps that one code to success because GNU Make otherwise collapses
+it into a generic error. Automation must inspect the emitted JSON status and
+exact marker rather than infer research status from Make's process code or retry
+with changed dates or rules.
+
+## Commands
+
+| Command | Purpose |
+| --- | --- |
+| `make setup` | Create/synchronize the locked Python 3.12 environment |
+| `make download-sample` | Download the bounded credential-free public trade sample |
+| `make download-m8` | Acquire the frozen M8 raw authority without opening archive members |
+| `make capture-m8-l2-session M8_L2_SESSION_DATE=YYYY-MM-DD` | Capture the frozen concurrent BTCUSDT/ETHUSDT L2 session for one declared date |
+| `make verify-m8-l2-session M8_L2_BUNDLE_DIR=<path>` | Verify a complete or `INSUFFICIENT_DATA` frozen L2 session bundle |
+| `make lock-m8-l2-development` | Atomically publish the Aug 10/11 development authority: fitted `LOCKED` state when both sessions pass, or control-only `NOT_CREATED` evidence when either is insufficient |
+| `make verify-m8-l2-development-lock` | Recursively verify either development-authority status against its path, SHA, configs, sessions, campaign, and clean source identity |
+| `make reproduce-m8-l2` | Produce a new immutable four-session L2 terminal bundle; use the explicit-digest verifier for an existing target |
+| `make verify-m8-l2-run` | Verify a complete or `INSUFFICIENT_DATA` L2 run plus all external authorities |
+| `make report-m8-l2` | Re-render verified L2 reports into a separate directory without mutating the run |
+| `make validate-data` | Run offline, non-mutating validation on the synthetic fixture |
+| `make validate-public-data` | Validate configured public normalized partitions incrementally |
+| `make smoke` | Produce or verify the immutable synthetic vertical slice |
+| `make test` | Run all unit and integration tests without network access |
+| `make reproduce-sample` | Alias for the canonical smoke producer |
+| `make reproduce-public-sample` | Produce a trade-only run from an explicit manifest path + SHA |
+| `make reproduce-m8` | Produce M8 from an explicit raw manifest + SHA under a clean commit |
+| `make verify-run` | Verify run structure and every protected checksum |
+| `make verify-public-run` | Verify the explicit public run bundle |
+| `make verify-m8-run` | Verify a complete or `INSUFFICIENT_DATA` M8 terminal bundle |
+| `make report` | Render a fresh report set from the frozen bundle |
+| `make report-m8` | Render a complete M8 bundle or expose its frozen failure report |
+| `make dashboard` | Open the local read-only Streamlit research dashboard |
+| `make check` | Run Ruff, strict mypy, pytest, and the smoke producer |
+
+The equivalent CLI is available as `microstructure` after setup. Run
+`microstructure --help` for the `ingest`, `acquire-m8`, `validate`, `reproduce`,
+`reproduce-m8`, `verify-m8`, `report-m8`, generic `verify`/`report`, the frozen
+`capture-m8-l2-session`, `verify-m8-l2-session`, `lock-m8-l2-development`,
+`verify-m8-l2-development-lock`, `reproduce-m8-l2`, `verify-m8-l2-run`, and
+`report-m8-l2` commands, plus exploratory research-only `collect-l2`.
+
+## What is implemented
+
+- Credential-free aggregate-trade ingestion with bounded retries, raw response
+  preservation, symbol metadata, exact scaling, immutable manifests, and
+  streaming partitioned Parquet writes. A verified public reader performs
+  physical-order incremental DQ and a single upstream Parquet pass into a
+  spill-capable DuckDB canonical sort; eager compatibility reads have a separate
+  hard row limit.
+- Optional public live diff-depth capture plus REST snapshot anchoring and pure
+  `U/u` reconstruction with stale, overlap, gap, crossed-book, and invariant
+  checks. Reconnection starts a new continuity epoch. The frozen L2 runner uses
+  one absolute UTC barrier for both instruments, a byte-bounded receiver queue,
+  OBSERVED-only continuity intervals, cross-symbol overlap gates, exhaustive
+  artifact inventory, and atomic `COMPLETE`/`INSUFFICIENT_DATA` evidence.
+- Typed quality findings for duplicates, ordering and clocks, invalid values,
+  scale mismatches, abnormal spread, silence, gaps, and crossed books. Validation
+  never repairs observations.
+- Leakage-safe spread, L1/L5/L10 depth state, queue imbalance, microprice, OFI,
+  signed flow, intensity, volatility, observable zero-quantity cancellation,
+  causal lagged impact/recovery, regime, and stability features, with event-time
+  and clock-time labels and explicit censoring.
+- A common-fold model ladder: historical prior, unpenalized logistic regression,
+  L2-regularized logistic grid, and shallow tree. Selection uses validation data;
+  the final test is frozen. Calibration and protocol-specific paired bootstrap
+  diagnostics are serialized with their block count, status, and seed: the
+  trade-only study uses fixed dependency blocks, while the prospective L2 study
+  uses interval-local overlapping moving blocks. Neither is presented as a
+  complete model of cross-instrument or overlapping-label dependence.
+- OOS-only market/limit simulation with decision and order latency, maker/taker
+  fees, adverse price rounding, top-depth caps, partial fills, a declared queue
+  proxy, adverse selection, inventory limits, liquidation, turnover, and size
+  sensitivity.
+- Atomic run production. `_SUCCESS` is written last; every other file is covered
+  by `checksums.sha256`. A completed target is read-only and reusable only when
+  the caller supplies its previously retained manifest and checksum digests to
+  the recursive verifier.
+- Raw-only M8 acquisition with exact official CHECKSUM evidence, bounded ZIP
+  central-directory inspection, a hard retained-evidence byte ledger, an exact
+  content-addressed inventory, and an atomic self-contained bundle copy. The M8
+  producer enforces development-only normalization and final selected/prior
+  fitting before a durable analysis lock, restores transparent numeric states
+  for prediction, and fails closed at every held-out member-open boundary.
+- Frozen L2 campaign identity and strict session readers that reject changed
+  clean-source identities, tampered or symlinked artifacts, invalid Parquet
+  footers/schemas, row mismatches, and continuity violations before exposing a
+  frame. One outcome-blind nonce binds all dates to the canonical output-root
+  path/filesystem identity, loaded source/import origin, and a hashed fingerprint
+  of Python, platform, and eight production dependency versions. Development-only
+  regime/model locks, no-refit held-out evaluation, paired dependency-block
+  diagnostics, market-only scenarios, descriptive analyses, and generated L2
+  reports feed one atomic final producer. Fail-closed memory admissions reserve
+  at most 8 GiB for development materialization and 12 GiB for final production
+  (raw, causal, evaluation, descriptive, and execution workspaces), leaving at
+  least 4 GiB of the 16 GiB host envelope for the interpreter and libraries;
+  every major allocation is checked before and immediately after materialization.
+  Its verifier streams tabular checks,
+  recursively revalidates the four external sessions and development authority,
+  binds a self-contained authority snapshot, rejects tampering, and enforces
+  `COMPLETE` versus `INSUFFICIENT_DATA` semantics.
+- Generated technical report, two-page IC memo, held-out comparison table, and
+  six-tab Streamlit dashboard, all downstream of frozen serialized artifacts.
+
+## Run contents
+
+Each completed run includes:
+
+```text
+run_manifest.json             # data interval, symbols, artifact map, assumptions
+provenance.json               # config/input hashes, seed, runtime, Git commit/state
+resolved_config.json
+data/normalized/              # partitioned Parquet + immutable manifests
+quality/summary.json
+research/                     # full/evaluation frames and exact fold indices
+models/                       # all predictions and selected held-out predictions
+metrics/                      # predictive, execution, and sensitivity diagnostics
+execution/                    # orders, fills, positions, replay state
+reports/                      # code-generated report, memo, comparison table
+dashboard/market_state.parquet
+checksums.sha256
+_SUCCESS
+```
+
+The final L2 bundle uses the same immutable terminal convention but has its own
+study inventory: self-contained `authority/` snapshots, per-date/symbol/endpoint
+`causal_frames/`, locked `evaluation/`, seven descriptive analyses, partitioned
+market-scenario orders/fills/positions plus assumptions and metrics, a
+checksummed `report_inputs.json`, and three generated reports. An
+`INSUFFICIENT_DATA` terminal retains the exact authorities, any allowable causal
+evidence, report snapshot, and failure reports while omitting promoted
+evaluation, descriptive, and execution artifacts. The recursive verifier checks
+physical inventory, Parquet semantic claims, rendered-report equality, and all
+external authorities. Exactly one final marker closes the bundle: `_SUCCESS`
+contains `complete\n` for `COMPLETE`, while `INSUFFICIENT_DATA` contains
+`terminal\n` for the typed data-availability terminal.
+
+The semantic run key is derived from the configuration, immutable input identity,
+Git commit, the exact tracked/non-ignored source-tree digest, and seed—not
+generation timestamps. Reuse additionally requires the current source identity
+and caller-retained output manifest/checksum digests to match; an older or
+coordinatedly rewritten bundle cannot masquerade as evidence for changed code.
+
+## Main findings and current evidence
+
+Replacement-campaign source-freeze snapshot as of 2026-08-09:
+
+- The latest settled integration gates passed Ruff, formatting, strict mypy, and
+  the full pytest suite across the data, reconstruction, timing, modeling,
+  execution, reporting, dashboard, and pipeline boundaries. Exact test/module
+  counts belong to the dated verification ledger in `STATUS.md`, not to an
+  empirical claim.
+- A fixed public sample for 2024-01-02 downloaded and normalized 10,000 real
+  aggregate trades: 5,000 each for BTCUSDT and ETHUSDT. The configured cap was
+  reached for both instruments, so both ranges are explicitly marked incomplete.
+  The current validators reported zero errors and zero warnings on those rows.
+- The generated trade-only report serializes per-symbol paired held-out
+  model-minus-prior diagnostics without pooling instruments. Exact metrics live
+  only in the checksum-verified run bundle; they are not manually copied into
+  this file.
+- The single-date, cap-truncated, validation-selected diagnostics do
+  not authorize a statistical-significance, persistent-alpha, profitability,
+  or capacity claim. The public bundle records execution and P&L as `NOT_RUN`;
+  synthetic model/P&L values are never interpreted economically.
+- The prospective M8 acquisition, lock-before-open producer, failure bundle,
+  verifier, and report interfaces are implemented and tested offline. The eight
+  official archives and their CHECKSUM/metadata evidence are now present in the
+  verified raw-only authority
+  `data/m8/_manifests/m8-acquisition.manifest-04d5c01f3810b6a300ec.json`
+  (SHA-256 `04d5c01f3810b6a300ec0f9317052f254b2bec5d89bc0dfefd18cd71ad6582e6`).
+  The raw-acquisition phase opened no CSV member. The corrected clean-source
+  producer then published and verified the canonical
+  `artifacts/runs/binance-m8-multidate` terminal at commit
+  `88060613abe211cd8e80a3499678fca830f8ba2d`. It stopped at the declared ETHUSDT
+  training DQ gate with 53 warnings, before selection, locks, or held-out access;
+  execution is `NOT_RUN`. The bundle, rather than this summary, is the authority
+  for its exact status and evidence inventory.
+- The live-L2 capture protocol and analysis contract are frozen, and strict
+  capture, session-verification, input, development-lock, locked-evaluation,
+  market-scenario, descriptive-analysis, and report components are covered by
+  offline tests. The superseded v1 evidence is preserved separately; no v2
+  Aug 10--13 L2 session existed at this source freeze, so these tracked bytes
+  contain no v2 book-based empirical result.
+
+This distinction is the main research conclusion so far: a functioning simulator
+is not evidence that a market effect exists.
+
+## Limitations and next milestone
+
+Exchange timestamps are not colocated receipt times. Public trades cannot reveal
+true queue priority, hidden liquidity, cancellations, or endogenous impact. The
+limit-fill mechanism is therefore a scenario proxy, and reported sensitivity is
+not deployable capacity. A short crypto interval cannot generalize across dates,
+venues, or asset classes; overlapping horizons also reduce effective sample size
+and make multiplicity control necessary.
+
+The trade-only study is closed at its predeclared `INSUFFICIENT_DATA` gate and
+must not be rerun with replacement dates or a relaxed warning policy. The next
+empirical milestone is the already-frozen prospective, simultaneous
+BTCUSDT/ETHUSDT local-L2 study. It requires four declared session terminals, a
+single clean campaign source identity, continuous valid observed intervals, an
+Aug 10/11 development authority durably published before either held-out session,
+and unchanged Aug 12/13 evaluation when that authority is `LOCKED`. A
+`NOT_CREATED` authority records why fitting was forbidden, while the declared
+held-out captures still proceed and the final producer opens no economic frame.
+A failed session remains evidence of insufficiency; no trade-only result can
+substitute for book evidence.
+
+See [the research protocol](docs/RESEARCH_PROTOCOL.md), [data contract](docs/DATA_CONTRACT.md),
+[project plan](docs/PROJECT_PLAN.md), [decision log](docs/DECISION_LOG.md),
+[L2 analysis contract](docs/M8_L2_ANALYSIS_CONTRACT.md), and
+[methodology limitations](reports/methodology_limitations.md) for the exact
+contracts and promotion rules.
+
+## Portfolio material
+
+The source-controlled report files contain no manually pasted performance
+numbers. Run-specific documents are generated from verified bundles. Supporting
+communication artifacts are in `portfolio/`: an interview narrative, three
+resume-bullet variants, and a ten-minute presentation outline.
+
+## Public release
+
+- Project page: <https://yangxiaoshawn.github.io/projects/microstructure/>
+- GitHub source: <https://github.com/YangXiaoShawn/open-economic-quant-microstructure>
+- Versioned code and documentation mirror: <https://huggingface.co/datasets/ShawnChamberlain/open-economic-quant-research-data/tree/main/Microstructure>
+- Interactive evidence explorer: <https://huggingface.co/spaces/ShawnChamberlain/open-economic-quant-research-observatory>
+- Publication and data boundaries: [docs/PUBLICATION.md](docs/PUBLICATION.md) and [docs/DATA_POLICY.md](docs/DATA_POLICY.md)
+
+Licensed under the MIT License. This repository is for research and simulation,
+not investment advice or live trading.

Microstructure/STATUS.md

@@ -0,0 +1,163 @@
+# Status
+
+Last updated: 2026-08-09 UTC
+
+> **Replacement-campaign source-freeze snapshot.** This tracked file records the
+> state before the v2 four-date L2 campaign. It must not be edited between the
+> first Aug 10 capture and the Aug 13 terminal. During that interval, current
+> status is authoritative only in `data/m8_l2/campaign_authority.json` and the
+> immutable per-session bundles; after the campaign, generated final-run
+> provenance is the authority for results.
+
+## Current evidence
+
+The portfolio-quality software vertical slice is complete. Its model and
+execution output is labeled `SYNTHETIC_SMOKE` and supports only a software
+reproducibility claim.
+
+A credential-free `PUBLIC_SAMPLE_PARTIAL` ingestion and a frozen trade-only
+research protocol were also completed for the
+fixed 2024-01-02 UTC configuration: 5,000 aggregate trades each for BTCUSDT and
+ETHUSDT. Both symbol ranges reached the configured cap and are explicitly
+incomplete. The normalized 10,000 rows produced zero current validation errors
+and warnings. This supports a bounded data-pipeline observation only—not a market
+signal, statistical-significance, profitability, or capacity claim. The public
+producer uses per-symbol purged folds and paired model-minus-prior uncertainty;
+execution and P&L are explicitly `NOT_RUN` because no contemporaneous book is
+present.
+
+The frozen trade-only M8 study has reached its canonical terminal state. The
+raw-only authority binds two exchange-metadata responses, eight official
+ZIP/CHECKSUM pairs, and 36 retained artifacts totaling 117,897,562 bytes; every
+acquisition entry records `csv_member_opened=false` and
+`economic_fields_inspected=false`. The corrected clean-source producer at commit
+`88060613abe211cd8e80a3499678fca830f8ba2d` published the checksummed
+`artifacts/runs/binance-m8-multidate` bundle with status
+`INSUFFICIENT_DATA`. BTCUSDT training normalization completed with 2,071,461
+rows, zero errors, and zero warnings. ETHUSDT training normalization completed
+with 987,297 rows, zero errors, and 53 warnings, triggering the predeclared
+quality gate. Selection never started; no development lock or prediction was
+published; no validation or held-out archive member was opened; execution and
+P&L are `NOT_RUN`. No date or policy was replaced. Its report command revalidates
+the terminal/raw authority and writes a fresh external report without modifying
+the canonical bundle.
+
+The live-L2 campaign remains the active evidence milestone. The superseded v1
+campaign is preserved, not repaired: Aug 8 is `MISSED_WINDOW`, Aug 9 is a
+verified complete session, and its development authority is `NOT_CREATED`.
+Before observing any v2 session, the user reset the active prospective calendar
+to Aug 10 train, Aug 11 validation, Aug 12 primary test, and Aug 13 replication
+test. V1 evidence is not an input to v2. The v2 capture config, protocol, and
+analysis authority are separately hash-bound. The campaign-authority mechanism
+requires all four dates to share one outcome-blind nonce, canonical output-root
+filesystem identity, clean commit/source/import origin, and hashed
+Python/platform/production-dependency fingerprint. Strict capture and session
+verification, verified lazy inputs, observed-interval endpoint frames,
+Aug 10/11 `LOCKED | NOT_CREATED` development authority, no-refit Aug 12/13 evaluation, dependency-aware
+diagnostics, market-only scenarios, descriptive analyses, and artifact-driven
+L2 reporting are integrated in a tested end-to-end producer and CLI/Make path.
+Development and final production have explicit 8 GiB and 12 GiB fail-closed
+live-memory envelopes respectively; crossing any admission or post-allocation
+bound is a system failure and cannot publish a research terminal.
+The atomic final bundle is either `COMPLETE` or `INSUFFICIENT_DATA`; it embeds
+exact config/protocol, campaign, session-control, and development authority
+snapshots, while its verifier also revalidates every external authority. Reports
+are regenerated only into an external directory, leaving the immutable run
+untouched. The software path was complete at this remaining-campaign source
+freeze; the real v2 session-control evidence was not. No v2 session bundle or
+L2 empirical metric existed when these tracked bytes were frozen.
+
+## Milestones
+
+| Milestone | Status | Evidence |
+| --- | --- | --- |
+| M0 Repository contract | Complete | Required files, Python packaging, locked environment, typed configuration and provenance |
+| M1 Event data foundation | Complete | Public/synthetic adapters, exact schemas, partitioned Parquet, immutable raw/normalized manifests |
+| M2 Book and quality controls | Complete | Gap-safe snapshot/delta replay and non-mutating quality rules covered by tests |
+| M3 Leakage-safe dataset | Complete | Causal features, future labels, censoring, continuity isolation, lineage audit |
+| M4 Model evaluation | Complete | Purged walk-forward prior/unpenalized/L2/tree ladder with calibration and block bootstrap |
+| M5 Execution research | Complete | OOS-only costs, two-stage latency, market/limit partial fills, queue proxy, inventory, liquidation and sensitivity |
+| M6 Reproducible vertical slice | Complete | Atomic CLI producer, immutable checksum bundle, deterministic run key, idempotent verification |
+| M7 Research communication | Complete | Code-generated report/memo/table, read-only six-tab dashboard, limitations and portfolio material |
+| M8 Broader empirical study | In progress | Trade-only branch closed with a canonical `INSUFFICIENT_DATA` terminal; complete frozen L2 software path verified offline; four prospective local-L2 session terminals and the resulting empirical terminal remain required |
+
+## Verification ledger
+
+- 2026-08-08: the final L2 session, input, development-lock, total-producer,
+  recursive-verifier, CLI/Make, and external-report paths passed their focused
+  offline suites. A consolidated repository gate is run separately before source
+  freeze; its volatile test count is not hardcoded in this market-evidence file.
+- 2026-08-08: every path listed by the canonical trade M8
+  `checksums.sha256` reverified. Its manifest/failure/provenance agree on
+  `INSUFFICIENT_DATA`, the clean source identity above, zero selection, zero
+  held-out access, and `NOT_RUN` execution.
+- 2026-08-07: `make lint` passed across source, tests, and dashboard.
+- 2026-08-08: the pre-L2 baseline `make check` passed Ruff, strict mypy across 40 package
+  modules, all 574 offline tests on Python 3.12.13, and a fresh current-source
+  synthetic bundle. `ruff format --check` also passed across all 92 Python files.
+- 2026-08-07: `make check` passed Ruff, strict mypy, all tests, and a fresh
+  current-source synthetic bundle produced in an isolated temporary target.
+- 2026-08-07: adversarial M8 tests proved that raw acquisition opens no CSV
+  member, unsafe ZIP metadata is rejected before the standard ZIP parser, both
+  symbol locks precede the first held-out open, tampered/missing authorities
+  expose zero held-out rows, and deterministic data failures publish no endpoint.
+- 2026-08-08: raw-only M8 acquisition published and independently reverified
+  `data/m8/_manifests/m8-acquisition.manifest-04d5c01f3810b6a300ec.json`
+  (SHA-256 `04d5c01f3810b6a300ec0f9317052f254b2bec5d89bc0dfefd18cd71ad6582e6`).
+  Verification opened no CSV member and found no extra, missing, symlinked, or
+  unmanifested raw artifact.
+- 2026-08-08: the frozen dual-symbol L2 session core and Binance adapter passed
+  82 joint tests. A real adapter-produced mock bundle exposed 19 artifacts that
+  passed strict raw-journal, snapshot, Parquet footer/schema, quality, manifest,
+  absolute-time, overlap, and 29-gate reconciliation.
+- 2026-08-07: pipeline tests independently reproduced two semantically identical
+  run bundles, verified their checksums, rejected corruption, and preserved an
+  incomplete target without repair.
+- 2026-08-07: `make download-sample` succeeded after network permission was
+  granted; raw public responses and metadata were manifested and kept outside
+  Git. `validate-public-data` passed 10,000 normalized rows with zero findings.
+- 2026-08-07: clean-commit canonical synthetic and public bundles were produced,
+  checksum-verified, and independently re-rendered into technical report, IC
+  memo, and model table. Generated artifacts remain ignored rather than
+  committed.
+
+## Empirical claim register
+
+- Supported: the fixed, capped public REST sample can be acquired, normalized
+  with exchange-provided scales, content-hashed, partitioned, and validated.
+- Exploratory diagnostic: the public producer persists each symbol's selected
+  model, paired held-out model-minus-prior loss, fixed-block interval and status
+  in a checksum-protected artifact. Exact metrics are read by generated reports
+  and are not manually duplicated in this status file; instruments are not
+  pooled.
+- Not supported: confirmatory order-flow predictability, statistical
+  significance, effect half-life, cross-date/instrument stability, economic
+  profitability, live fill probability, or deployable capacity. Execution is
+  `NOT_RUN` for the public trade-only input.
+- Inconclusive by design: the full-archive trade M8 hypothesis was not evaluated
+  because ETHUSDT training data failed the frozen warning gate. The terminal is
+  evidence of data insufficiency, not evidence that the hypothesis failed.
+- Failed/unsupported hypothesis disclosure is generated per symbol for runs
+  that reach evaluation. The single capped date cannot test persistence or
+  book/liquidity hypotheses, and synthetic output cannot evaluate a market
+  hypothesis.
+
+## Next evidence sequence
+
+Retain the canonical trade-only `INSUFFICIENT_DATA` bundle and its source-tagged
+predecessor unchanged; do not relax the warning gate, replace a date, or rerun
+until a favorable outcome appears. Use the completed L2 producer and explicit
+authority interfaces with ignored targets
+`artifacts/runs/binance-m8-l2-development-lock` and
+`artifacts/runs/binance-m8-live-l2` for the development authority and final run,
+respectively. Then capture the exact simultaneous Aug 10--13 BTCUSDT/ETHUSDT
+sessions under one new clean v2 campaign authority. After Aug 11, durably publish
+either the fitted `LOCKED` authority or the control-only `NOT_CREATED` authority
+before Aug 12. A valid `NOT_CREATED` result exits 1 but does not cancel the Aug
+12/13 captures; the final producer uses all four control authorities without
+opening economic frames. After Aug 13, produce and recursively verify the immutable
+final bundle, render reports externally, measure peak RSS, and complete the
+clean-room/resource audit. A failed/missed date terminalizes the declared
+campaign rather than selecting a substitute. The
+frozen facts are in `docs/M8_L2_ANALYSIS_CONTRACT.md`; generated bundles remain
+the only authority for any eventual metrics.

Microstructure/configs/exploratory_aggtrades_2026-08-05_08.toml

@@ -0,0 +1,58 @@
+[study]
+name = "binance-aggtrades-2026-08-05-08-exploratory"
+protocol_version = "1.0.0"
+evidence_tier = "PUBLIC_ARCHIVE_EXPLORATORY"
+seed = 20260809
+source = "binance_spot_daily_aggtrades_archive"
+symbols = ["BTCUSDT", "ETHUSDT"]
+selection_metric = "log_loss"
+target = "future_trade_up"
+label_horizon_events = 20
+calibration_fraction = 0.20
+bootstrap_samples = 2000
+bootstrap_block_events = 40
+feature_stability_bins = 10
+max_archive_compressed_bytes = 268435456
+max_archive_uncompressed_bytes = 2147483648
+max_total_download_bytes = 8589934592
+
+[[periods]]
+date = "2026-08-05"
+role = "train"
+
+[[periods]]
+date = "2026-08-06"
+role = "validation"
+
+[[periods]]
+date = "2026-08-07"
+role = "primary_test"
+
+[[periods]]
+date = "2026-08-08"
+role = "replication_test"
+
+[features]
+trade_windows = [5, 20, 100]
+volatility_window = 100
+intensity_window = 50
+large_trade_quantile = 0.95
+
+[models]
+logistic_c_values = [0.1, 1.0, 10.0]
+tree_max_depth_values = [2, 4, 6]
+tree_min_samples_leaf = 40
+
+[quality]
+fail_on_error = true
+require_complete_daily_archive = true
+require_contiguous_trade_ids_within_symbol_date = true
+require_nondecreasing_event_time = true
+allow_quality_warnings = true
+
+[claims]
+allow_p_values = false
+allow_significance_claim = false
+allow_cross_instrument_pooling = false
+allow_execution_claim = false
+allow_profitability_claim = false

Microstructure/configs/m8_l2_analysis.toml

@@ -0,0 +1,100 @@
+[study]
+name = "binance-m8-live-l2-analysis-v2"
+protocol_version = "2.0.0"
+seed = 20260807
+source = "verified_m8_l2_session_bundles"
+capture_config_source_sha256 = "b1bf3b4e2820e24e4555bfeb9cb0957f9a0bcdef62039f7d92360e0a97d0dd39"
+capture_protocol_sha256 = "4c77a2099a4cabd049d10e0f8264d3b4c66704d8e87cbaf0c817fd085f4bbd83"
+symbols = ["BTCUSDT", "ETHUSDT"]
+training_role = "train"
+selection_role = "validation"
+primary_endpoint_role = "primary_test"
+replication_endpoint_role = "replication_test"
+
+[features]
+decision_scope = "per_symbol_verified_observed_intervals"
+flat_direction_policy = "flat_is_non_up"
+rolling_windows = [20, 100]
+volatility_window = 100
+model_feature_columns = ["spread_bps", "depth_total_l1", "depth_total_l5", "depth_total_l10", "queue_imbalance_l1", "queue_imbalance_l5", "queue_imbalance_l10", "microprice_deviation_bps", "ofi_l1", "ofi_w20", "ofi_w100", "cancellation_intensity_w20", "cancellation_intensity_w100", "realized_volatility_w20", "realized_volatility_w100", "volatility_regime_low", "volatility_regime_high", "liquidity_regime_liquid", "liquidity_regime_stressed"]
+clock_max_state_age_ms = 500
+clock_target_policy = "exact_target_locf_same_valid_observed_interval"
+clock_label_information_end = "exact_target"
+clock_record_target_sequence = true
+clock_censor_if_no_eligible_state = true
+
+[[endpoints]]
+name = "event_20"
+domain = "event"
+horizon_value = 20
+unit = "events"
+paired_block_width = 40
+paired_block_unit = "events"
+nominal_event_block_width = 40
+
+[[endpoints]]
+name = "event_100"
+domain = "event"
+horizon_value = 100
+unit = "events"
+paired_block_width = 200
+paired_block_unit = "events"
+nominal_event_block_width = 200
+
+[[endpoints]]
+name = "clock_1000ms"
+domain = "clock"
+horizon_value = 1000
+unit = "milliseconds"
+paired_block_width = 2000
+paired_block_unit = "milliseconds"
+nominal_event_block_width = 20
+
+[[endpoints]]
+name = "clock_5000ms"
+domain = "clock"
+horizon_value = 5000
+unit = "milliseconds"
+paired_block_width = 10000
+paired_block_unit = "milliseconds"
+nominal_event_block_width = 100
+
+[regimes]
+fit_role = "train"
+feature = "realized_volatility_w100"
+quantile_numerators = [1, 2]
+quantile_denominator = 3
+
+[calibration]
+bins = 10
+
+[bootstrap]
+method = "paired_moving_block"
+samples = 2000
+
+[signed_impact]
+metric = "ofi_signed_future_mid_markout"
+side_rule = "sign_of_horizon_matched_ofi"
+price_rule = "ofi_sign_times_future_log_mid_return_bps"
+
+[execution]
+market_orders_only = true
+probability_threshold = 0.55
+symmetric_probability_thresholds = true
+order_notional_usd = 100.0
+max_l1_participation = 0.10
+inventory_order_multiples = 10
+reference_price_fit_role = "train"
+reference_depth_fit_role = "train"
+reference_price_statistic = "train_median_mid_price"
+reference_depth_statistic = "train_q05_min_bid_ask_l1_depth"
+reference_quantity_policy = "min_100usd_and_10pct_train_q05_l1_depth_rounded_down_to_lot"
+l1_fill_policy = "fill_up_to_recorded_l1_depth_cancel_remainder"
+scenario_reset_policy = "per_symbol_session_endpoint_latency_pair"
+extra_slippage_bps = 0.0
+liquidate_at_end = true
+
+[claims]
+allow_capacity_claim = false
+allow_realized_execution_claim = false
+allow_profitability_claim = false

Microstructure/configs/m8_l2_capture_study.toml

@@ -0,0 +1,81 @@
+[study]
+name = "binance-m8-live-l2-study-v2"
+protocol_version = "2.0.0"
+evidence_tier = "FULL_DATA"
+seed = 20260807
+source = "binance_spot_live_diff_depth_100ms"
+symbols = ["BTCUSDT", "ETHUSDT"]
+stream_interval_ms = 100
+
+[[sessions]]
+date = "2026-08-10"
+start_utc = "14:00:00"
+end_utc = "15:00:00"
+role = "train"
+
+[[sessions]]
+date = "2026-08-11"
+start_utc = "14:00:00"
+end_utc = "15:00:00"
+role = "validation"
+
+[[sessions]]
+date = "2026-08-12"
+start_utc = "14:00:00"
+end_utc = "15:00:00"
+role = "primary_test"
+
+[[sessions]]
+date = "2026-08-13"
+start_utc = "14:00:00"
+end_utc = "15:00:00"
+role = "replication_test"
+
+[capture]
+duration_seconds = 3600
+max_messages_per_symbol = 60000
+max_raw_frame_bytes = 1048576
+max_arrow_batch_bytes = 16777216
+min_overlapping_coverage_seconds = 3300
+min_single_continuity_epoch_seconds = 1800
+require_complete_status = true
+require_live_reconstruction = true
+max_sequence_gaps = 0
+max_quality_errors = 0
+max_quality_warnings = 0
+
+[features]
+depth_levels = [1, 5, 10]
+event_horizons = [20, 100]
+clock_horizons_ms = [1000, 5000]
+include_spread = true
+include_depth = true
+include_ofi = true
+include_queue_imbalance = true
+include_microprice = true
+include_cancellation_intensity = true
+include_realized_volatility = true
+include_reference_fit_regimes = true
+
+[models]
+selection_metric = "log_loss"
+logistic_c_values = [0.1, 1.0, 10.0]
+tree_max_depth_values = [2, 4, 6]
+tree_min_samples_leaf = 40
+calibration_fraction = 0.20
+bootstrap_samples = 2000
+
+[execution]
+market_orders_only = true
+taker_fee_bps = 4.0
+decision_latency_events = [0, 1, 5]
+order_latency_events = [0, 1, 5]
+liquidate_at_end = true
+allow_limit_fill_claim = false
+allow_capacity_claim = false
+
+[claims]
+allow_p_values = false
+allow_significance_claim = false
+allow_realized_execution_claim = false
+allow_profitability_claim = false

Microstructure/configs/m8_multidate_trade_study.toml

@@ -0,0 +1,58 @@
+[study]
+name = "binance-m8-multidate-trades"
+protocol_version = "1.0.2"
+evidence_tier = "FULL_DATA"
+seed = 20260807
+source = "binance_spot_daily_aggtrades_archive"
+symbols = ["BTCUSDT", "ETHUSDT"]
+selection_metric = "log_loss"
+target = "future_trade_up"
+label_horizon_events = 20
+calibration_fraction = 0.20
+bootstrap_samples = 2000
+bootstrap_block_events = 40
+feature_stability_bins = 10
+max_archive_compressed_bytes = 268435456
+max_archive_uncompressed_bytes = 2147483648
+max_total_download_bytes = 8589934592
+
+[[periods]]
+date = "2024-01-03"
+role = "train"
+
+[[periods]]
+date = "2024-01-04"
+role = "validation"
+
+[[periods]]
+date = "2024-01-05"
+role = "primary_test"
+
+[[periods]]
+date = "2024-01-06"
+role = "replication_test"
+
+[features]
+trade_windows = [5, 20, 100]
+volatility_window = 100
+intensity_window = 50
+large_trade_quantile = 0.95
+
+[models]
+logistic_c_values = [0.1, 1.0, 10.0]
+tree_max_depth_values = [2, 4, 6]
+tree_min_samples_leaf = 40
+
+[quality]
+fail_on_error = true
+require_complete_daily_archive = true
+require_contiguous_trade_ids_within_symbol_date = true
+require_nondecreasing_event_time = true
+allow_quality_warnings = false
+
+[claims]
+allow_p_values = false
+allow_significance_claim = false
+allow_cross_instrument_pooling = false
+allow_execution_claim = false
+allow_profitability_claim = false

Microstructure/configs/public_sample.toml

@@ -0,0 +1,63 @@
+[run]
+name = "binance-public-sample"
+evidence_tier = "PUBLIC_SAMPLE_PARTIAL"
+seed = 20260807
+
+[data]
+mode = "binance_rest"
+source = "binance_spot_rest"
+symbols = ["BTCUSDT", "ETHUSDT"]
+start = "2024-01-02T00:00:00Z"
+end = "2024-01-02T00:10:00Z"
+max_events_per_symbol = 5000
+raw_root = "data/raw"
+partition_root = "data/normalized"
+schema_version = "1.0.0"
+base_url = "https://data-api.binance.vision"
+request_limit = 1000
+timeout_seconds = 30.0
+max_retries = 5
+
+[quality]
+max_spread_bps = 100.0
+max_silence_ms = 5000
+fail_on_error = true
+
+[features]
+trade_windows = [5, 20, 100]
+volatility_window = 100
+intensity_window = 50
+label_horizon_events = 20
+large_trade_quantile = 0.95
+
+[evaluation]
+min_train_events = 1200
+validation_events = 400
+test_events = 400
+step_events = 400
+embargo_events = 20
+bootstrap_samples = 500
+calibration_bins = 10
+
+[models]
+selection_metric = "log_loss"
+logistic_c_values = [0.1, 1.0, 10.0]
+tree_max_depth_values = [2, 4, 6]
+tree_min_samples_leaf = 40
+
+[execution]
+decision_latency_events = 1
+order_latency_events = 1
+maker_fee_bps = 1.0
+taker_fee_bps = 4.0
+half_spread_bps = 1.0
+slippage_bps_per_unit = 0.20
+signal_threshold = 0.56
+max_position_units = 3.0
+order_size_units = 1.0
+limit_fill_base_probability = 0.55
+queue_ahead_units = 2.0
+limit_max_age_events = 20
+cancel_latency_events = 1
+liquidate_at_end = true
+capacity_multipliers = [0.5, 1.0, 2.0, 4.0]

Microstructure/configs/smoke.toml

@@ -0,0 +1,57 @@
+[run]
+name = "sample-smoke"
+evidence_tier = "SYNTHETIC_SMOKE"
+seed = 20260807
+
+[data]
+mode = "synthetic"
+source = "synthetic_v1"
+symbols = ["BTCUSDT", "ETHUSDT"]
+start = "2024-01-02T00:00:00Z"
+events_per_symbol = 3600
+partition_root = "data/normalized"
+schema_version = "1.0.0"
+
+[quality]
+max_spread_bps = 100.0
+max_silence_ms = 5000
+fail_on_error = true
+
+[features]
+trade_windows = [5, 20, 100]
+volatility_window = 100
+intensity_window = 50
+label_horizon_events = 20
+large_trade_quantile = 0.95
+
+[evaluation]
+min_train_events = 1200
+validation_events = 400
+test_events = 400
+step_events = 400
+embargo_events = 20
+bootstrap_samples = 200
+calibration_bins = 10
+
+[models]
+selection_metric = "log_loss"
+logistic_c_values = [0.1, 1.0, 10.0]
+tree_max_depth_values = [2, 4, 6]
+tree_min_samples_leaf = 40
+
+[execution]
+decision_latency_events = 1
+order_latency_events = 1
+maker_fee_bps = 1.0
+taker_fee_bps = 4.0
+half_spread_bps = 1.0
+slippage_bps_per_unit = 0.20
+signal_threshold = 0.56
+max_position_units = 3.0
+order_size_units = 1.0
+limit_fill_base_probability = 0.55
+queue_ahead_units = 2.0
+limit_max_age_events = 20
+cancel_latency_events = 1
+liquidate_at_end = true
+capacity_multipliers = [0.5, 1.0, 2.0, 4.0]

Microstructure/dashboard/app.py

@@ -0,0 +1,189 @@
+"""Read-only Streamlit dashboard for a completed microstructure run bundle."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+import streamlit as st
+
+from microstructure.provenance import sha256_file
+from microstructure.reporting import RunBundle, RunBundleError, load_run_bundle
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_RUN_DIR = PROJECT_ROOT / "artifacts" / "runs" / "sample-smoke"
+
+
+def _argument_run_dir(arguments: Sequence[str]) -> Path:
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("--run-dir")
+    parsed, _ = parser.parse_known_args(arguments)
+    configured = parsed.run_dir or os.environ.get("MICROSTRUCTURE_RUN_DIR")
+    return Path(configured).expanduser() if configured else DEFAULT_RUN_DIR
+
+
+def _integrity_key(run_dir: Path) -> str:
+    checksum_path = run_dir / "checksums.sha256"
+    return sha256_file(checksum_path) if checksum_path.is_file() else "missing"
+
+
+@st.cache_resource(show_spinner=False)
+def _cached_bundle(run_dir: str, integrity_key: str) -> RunBundle:
+    del integrity_key  # It is part of Streamlit's cache key.
+    return load_run_bundle(run_dir)
+
+
+def _rows(rows: Sequence[Mapping[str, Any]]) -> list[dict[str, Any]]:
+    return [dict(row) for row in rows]
+
+
+def _show_rows(rows: Sequence[Mapping[str, Any]], empty_message: str) -> None:
+    if rows:
+        st.dataframe(_rows(rows), hide_index=True)
+    else:
+        st.info(empty_message)
+
+
+def _show_overview(bundle: RunBundle) -> None:
+    st.subheader("Evidence and lineage")
+    columns = st.columns(4)
+    columns[0].metric("Run", bundle.run_id)
+    columns[1].metric("Evidence", bundle.evidence_tier)
+    columns[2].metric("Symbols", len(bundle.symbols))
+    columns[3].metric(
+        "Git state",
+        "dirty" if bool(cast_mapping(bundle.provenance.get("git")).get("dirty")) else "clean",
+    )
+    st.markdown(
+        f"**Observed UTC period:** `{bundle.observed_start_utc}` → `{bundle.observed_end_utc}`"
+    )
+    st.markdown(f"**Instruments:** {', '.join(bundle.symbols)}")
+    st.caption(
+        "The dashboard reads serialized artifacts only. It does not download data, "
+        "train models, or simulate orders."
+    )
+
+
+def cast_mapping(value: Any) -> Mapping[str, Any]:
+    return value if isinstance(value, Mapping) else {}
+
+
+def _show_quality(bundle: RunBundle) -> None:
+    st.subheader("Non-mutating validation findings")
+    if bundle.quality:
+        st.json(dict(bundle.quality), expanded=True)
+    else:
+        st.info("No quality summary was serialized in this completed run bundle.")
+    st.caption("Findings are displayed as recorded; this app does not repair observations.")
+
+
+def _show_market_state(bundle: RunBundle) -> None:
+    st.subheader("Market-state aggregates")
+    _show_rows(
+        bundle.market_state,
+        "No dashboard-safe market-state aggregate was serialized for this run.",
+    )
+    st.caption(
+        "Only bounded aggregates are loaded here; the dashboard never scans external raw data."
+    )
+
+
+def _show_predictions(bundle: RunBundle) -> None:
+    st.subheader("Serialized predictive diagnostics")
+    _show_rows(
+        bundle.predictive_metrics,
+        "No predictive metric rows were serialized for this run.",
+    )
+    st.caption(
+        "Predictive metrics do not establish fillability or performance after execution costs."
+    )
+
+
+def _show_execution(bundle: RunBundle) -> None:
+    st.subheader("Serialized simulated performance")
+    _show_rows(
+        bundle.execution_metrics,
+        "No execution or simulated-performance rows were serialized for this run.",
+    )
+    st.markdown("#### Execution sensitivity grid")
+    _show_rows(
+        bundle.execution_sensitivity,
+        "No execution-sensitivity rows were serialized for this run.",
+    )
+    assumptions = bundle.manifest.get("execution_assumptions")
+    if isinstance(assumptions, Mapping) and assumptions:
+        st.markdown("#### Recorded execution assumptions")
+        st.json(dict(assumptions), expanded=False)
+    st.caption(
+        "Fees, latency, fills, adverse selection, inventory, and liquidation are model "
+        "assumptions—not realized trading outcomes."
+    )
+
+
+def _show_reproducibility(bundle: RunBundle) -> None:
+    st.subheader("Frozen provenance")
+    st.markdown(f"**Run directory:** `{bundle.root}`")
+    st.markdown(f"**Configuration SHA-256:** `{bundle.provenance.get('config_sha256', 'N/A')}`")
+    st.markdown("#### Run manifest")
+    st.code(json.dumps(bundle.manifest, indent=2, sort_keys=True), language="json")
+    st.markdown("#### Provenance")
+    st.code(json.dumps(bundle.provenance, indent=2, sort_keys=True), language="json")
+    st.caption(
+        "The completion marker and checksum manifest were verified before these values loaded."
+    )
+
+
+def render_dashboard(bundle: RunBundle) -> None:
+    """Render a verified bundle without changing it."""
+    st.title("Order Flow to Price Impact")
+    if bundle.evidence_tier in {"SYNTHETIC_SMOKE", "PUBLIC_SAMPLE_PARTIAL"}:
+        st.warning(bundle.watermark)
+    else:
+        st.info(bundle.watermark)
+
+    labels = (
+        "Overview",
+        "Data Quality",
+        "Market State",
+        "Predictions",
+        "Simulated Performance",
+        "Reproducibility & Limitations",
+    )
+    tabs = st.tabs(labels)
+    with tabs[0]:
+        _show_overview(bundle)
+    with tabs[1]:
+        _show_quality(bundle)
+    with tabs[2]:
+        _show_market_state(bundle)
+    with tabs[3]:
+        _show_predictions(bundle)
+    with tabs[4]:
+        _show_execution(bundle)
+    with tabs[5]:
+        _show_reproducibility(bundle)
+
+
+def main(arguments: Sequence[str] | None = None) -> None:
+    st.set_page_config(page_title="Microstructure Research", layout="wide")
+    run_dir = _argument_run_dir(sys.argv[1:] if arguments is None else arguments).resolve()
+    try:
+        bundle = _cached_bundle(str(run_dir), _integrity_key(run_dir))
+    except RunBundleError as error:
+        st.title("Order Flow to Price Impact")
+        st.error(f"Run bundle is incomplete or invalid: {error}")
+        st.caption(
+            "Select a directory containing run_manifest.json, provenance.json, "
+            "checksums.sha256, and the final _SUCCESS marker."
+        )
+        st.stop()
+    render_dashboard(bundle)
+
+
+if __name__ == "__main__":
+    main()

Microstructure/data/_ingestion_manifests/.gitkeep

@@ -0,0 +1 @@
+

Microstructure/data/derived/.gitkeep

@@ -0,0 +1 @@
+

Microstructure/data/models/.gitkeep

@@ -0,0 +1 @@
+

Microstructure/data/normalized/.gitkeep

@@ -0,0 +1 @@
+

Microstructure/data/quality/.gitkeep

@@ -0,0 +1 @@
+

Microstructure/docs/DATA_CONTRACT.md

@@ -0,0 +1,269 @@
+# Data contract and lineage
+
+## Scope
+
+The normalized layer separates exchange-specific acquisition from research
+logic. An adapter may add a new venue, but it must produce the same versioned
+event contracts, preserve original bytes, and declare how observation time is
+approximated. No normalized table is evidence that an event was available to a
+real colocated strategy unless local receipt time was actually captured.
+
+Current schema version: `1.0.0`.
+
+## Clocks and ordering
+
+All timestamps are signed UTC epoch nanoseconds:
+
+- `event_ts_ns`: timestamp supplied by the market-data source;
+- `received_ts_ns`: local wall-clock receipt when captured live, otherwise null;
+- `available_ts_ns`: earliest time the pipeline permits the row to enter an
+  information set;
+- `availability_basis`: explicit reason, such as `local_receive_time`,
+  `exchange_event_time_proxy`, or `synthetic_receipt`;
+- `capture_seq`: local arrival ordering when a collector supplies it;
+- `continuity_id`: a feed epoch that cannot be crossed by rolling features,
+  labels, open orders, or markouts.
+
+Within a continuous book epoch, sequence IDs—not exchange timestamps—are the
+authoritative reconstruction order. Research ordering is stable on availability
+time, sequence/capture order, and event identity. Separate trade and book streams
+with equal timestamps have no assumed common ordering, so cross-stream joins are
+strictly prior unless a future source proves a shared sequence.
+
+## Exact numerical representation
+
+Adapters retain integer `price_ticks`/`quantity_lots` and the corresponding
+`tick_size`/`lot_size`. Floating `price` and `quantity` columns are convenience
+units and must agree with the exact representation. Binance symbol scales come
+from public `exchangeInfo` filters for each download; fixed `1e-8` scale defaults
+exist only as explicit low-level fallbacks and are not the configured sample
+path.
+
+Derived ratios, log returns, volatility, probabilities, and P&L use `Float64`
+with their units named or documented. Execution quantities are rounded down to
+the observable lot size; slippage-adjusted prices round adversely to the tick.
+
+## Normalized tables
+
+### Trades
+
+Identity is `(venue, symbol, trade_id)`. Required economic fields include exact
+and floating price/quantity, quote quantity, first/last constituent trade IDs,
+buyer-maker flag, normalized aggressor side, timestamps, and source artifact ID.
+A `buy` aggressor lifts the ask; a `sell` aggressor hits the bid.
+
+### Depth deltas
+
+Each event contains `first_update_id`, `last_update_id`, optional previous update
+ID, and bid/ask lists of exact `(price_ticks, quantity_lots)` changes. Quantity
+zero is a delete instruction; a negative quantity is invalid.
+
+### Book snapshots
+
+A snapshot carries its request/receipt/availability times, last update ID,
+depth limit, exact levels, scale metadata, source artifact ID, and a new
+continuity ID. Binance REST snapshots do not provide an exchange event timestamp;
+the local receipt time is the anchor availability time.
+
+### Book observations
+
+Reconstruction emits best bid/ask, L1 quantities, cumulative depth at 1/5/10
+levels, spread, mid, microprice, queue imbalance, sequence range, validity flag,
+and full lineage. A crossed/locked or emptied book terminates the epoch rather
+than being silently repaired.
+
+### Sequence gaps
+
+A gap row records expected and observed ranges, the missing inclusive range,
+detection time, continuity ID, source artifact, and reason. After a forward gap,
+the book is not live again until a new snapshot starts a new epoch.
+
+## Binance acquisition semantics
+
+The configured historical adapter uses only credential-free public market-data
+REST endpoints. It starts aggregate-trade pagination with a fixed UTC interval,
+then advances by aggregate trade ID so trades sharing a timestamp are not lost.
+HTTP 408/418/429/5xx, connection failures, and recoverable interruptions while
+streaming an HTTP 200 body use bounded exponential backoff; `Retry-After` is
+honored for rate-limit responses. Response bodies have a byte ceiling. Every
+accepted exact body is content-addressed and manifested before normalization;
+an interrupted or oversized response preserves a bounded rejected prefix and an
+explicit rejection sidecar before retry/failure.
+
+The optional live collector uses the market-data-only WebSocket endpoint and
+diff-depth `U/u` updates. A correct local book buffers updates, fetches a public
+snapshot, discards stale events, requires the first usable event to cover
+`lastUpdateId + 1`, and then validates continuity for every event. Reconnection
+starts a new continuity epoch. These rules follow Binance's official
+[Spot WebSocket stream guide](https://developers.binance.com/en/docs/catalog/core-trading-spot-trading/api/ws-streams/~).
+Public REST behavior and rate-limit headers are described in the official
+[Spot REST documentation](https://developers.binance.com/en/docs/products/spot/rest-api).
+
+Live capture persists each WebSocket frame before UTF-8/JSON parsing in a typed
+base64 journal containing exact bytes, local receipt time, capture sequence and
+continuity epoch. Each reconnect snapshot's raw body and sidecar are journaled as
+an anchor. A frame above 1 MiB fails only after its evidence is preserved;
+normalized Arrow spools flush before an estimated 16 MiB batch ceiling. A
+capture-ID-scoped normalized root produces one streaming Parquet descriptor per
+nonempty table, and a capture-ID completion summary is atomically published
+last. The fixed summary name is only a latest-pointer, never the sole completion
+record. Historical REST output retains the date-partition layout described
+below.
+
+Every historical download requires a finite per-symbol event cap, but that cap
+is not treated as a RAM budget. The default path lazily yields at most one REST
+page per Arrow batch, updates exact disk-backed quality state, and feeds the
+Parquet writer once. Eager compatibility materialization has a separate hard
+row guard. A `ConfiguredDataAdapter` protocol/registry is the normalized
+extension boundary for later venues or institutional sources; its mode must
+match the resolved configuration before dispatch.
+
+### Daily-archive acquisition boundary
+
+A daily-archive acquisition object authenticates raw transport evidence; it is
+not a normalized-data object. Acquisition may hash exact bodies, authenticate
+the official `CHECKSUM`, and inspect bounded ZIP
+end-of-central-directory/central-directory metadata for member name, count, and
+declared compressed/expanded sizes. It must not open or extract the CSV member,
+read decompressed member bytes, parse a header or row, expose economic fields,
+or compute row/ID/timestamp coverage. The first decompressed member byte is the
+economic-data-open boundary, and the archive API must expose a fail-closed guard
+immediately before that byte can be read.
+
+For the prospective M8 study, all declared ZIP, `CHECKSUM`, and exchange-metadata
+responses are acquired and placed in an immutable raw acquisition manifest
+before any member is opened. Only train and validation members are then
+stream-normalized and quality-checked. Their immutable development normalized
+manifest is an input to selection. One per-symbol analysis lock and an aggregate
+lock committing both child-lock hashes are closed and `fsync`ed, along with
+their digest files and containing directories. Each child lock binds the
+selected specification, development-frame identity, feature order, imputer and
+scaler parameters, selected-estimator state, independent historical-prior state,
+calibration state, fit cutoffs, and the canonical numeric fitted-state SHA-256.
+Those states are fit on development data and durably closed before held-out
+member access. The aggregate lock binds the
+protocol/config, raw acquisition manifest, development normalized manifest, and
+clean real Git revision. Every primary/replication member-open guard must
+re-read and re-hash that exact durable lock before allowing decompression. Test
+normalization may construct held-out features, but prediction restores the
+locked numeric state; evaluation cannot reselect, fit, refit, recalibrate, or
+update it.
+
+Declared-object 404/410 responses, invalid exchange-metadata semantics, official
+`CHECKSUM` or ZIP structural violations, frozen per-response size violations,
+and retained-evidence budget exhaustion are typed deterministic insufficiency
+and publish an immutable raw-only `INSUFFICIENT_DATA` authority. Retry exhaustion,
+connection interruption, permission/local-I/O errors, collisions, and program
+faults remain nonterminal system failures so they cannot masquerade as a market
+or data result.
+
+The M8 byte limits have distinct meanings. The compressed ceiling applies to
+each archive response while streaming. The expanded ceiling applies to both the
+declared and actually streamed bytes of each CSV member. The total-download
+ceiling is the hard sum of immutable raw-response evidence retained for the
+study: ZIP bodies, official `CHECKSUM` bodies, every response sidecar,
+`exchangeInfo` bodies and sidecars, and all retained rejected-response prefixes
+and rejection sidecars. Retried attempts still consume the total. A physically
+retained content-addressed file is counted once even if referenced more than
+once; separate retained copies are counted separately. Normalized Parquet,
+quality outputs, and derived aggregate indexes are outside this raw-evidence
+sum. Type-specific bounded `CHECKSUM`, metadata, and rejection responses remain
+subject to the same total. Accounting is enforced while bytes are retained, not
+after all downloads finish, and the raw acquisition manifest records every
+accepted/rejected artifact and the final exact total.
+
+If held-out normalization, continuity/completeness validation, or quality fails
+after lock durability, the run publishes an atomic, checksum-protected,
+immutable `INSUFFICIENT_DATA` terminal artifact under the same run identity. It
+binds the raw and development manifests, per-symbol and aggregate locks, clean
+Git identity, typed failure, partial-evidence hashes, and unopened remainder;
+it contains no endpoint result. That identity may subsequently verify/reuse the
+failure but may not overwrite it, return to selection, substitute inputs, or
+publish a partial successful bundle. A source change creates a new clean Git
+identity rather than rewriting prior evidence.
+
+## Storage and manifests
+
+Normalized Parquet is content-addressed and partitioned beneath:
+
+```text
+<root>/<dataset>/schema-<version>/venue-<venue>/symbol-<symbol>/date-YYYY-MM-DD/
+```
+
+Writers reject oversized input batches before row conversion and consume
+bounded Arrow record batches; they do not require all event rows in memory.
+Each part has an immutable sidecar with source URI, download/creation
+time, requested and observed ranges, row/byte counts, schema version,
+transformations, input checksum, write ordinal, and Parquet checksum. A dataset
+manifest lists all parts, sidecars, hashes, row counts, observed bounds and write
+order. Validation checks those bytes before scanning rows. Run bundles snapshot
+these manifest hashes and protect every included file with `checksums.sha256`.
+
+Each config-driven ingestion also writes a content-named immutable ingestion
+manifest linking only the exact raw responses used by that invocation to the
+normalized dataset manifests. It records the row cap and each symbol's
+`complete_range` state, so capped coverage cannot survive merely as terminal
+output or be mistaken for the entire requested interval. Quality reports and
+full findings JSONL are atomically published under per-run names and their
+SHA-256/byte counts are bound into the same ingestion manifest.
+
+The public research reader verifies metadata, URI/symbol semantics, exact raw
+record membership, inverse raw-to-normalized coverage, scales, parts and
+sidecars before exposing rows. Its batch API performs physical-order incremental
+quality checks while a single upstream Arrow stream is staged through a
+memory-limited, spill-capable DuckDB canonical sort. The legacy eager reader has
+an independent finite materialization guard checked before any Parquet row read.
+
+For M8 specifically, the raw acquisition manifest and normalized manifests are
+different immutable stages and must not be collapsed into one post hoc record.
+A self-contained run preserves the acquisition authority as an exact raw-only
+copy below `data/input`; normalization, Parquet, and DQ evidence live separately
+below `data/normalized_input`.  The final all-date manifest is rooted at `data`
+so it may bind both trees without making derived artifacts members of the raw
+authority.  A failed run inventories every pre-terminal regular file, binds any
+completed and failed normalization evidence, and applies the same verifier both
+before and after atomic publication.
+A successful final bundle binds the raw acquisition manifest, final normalized
+manifest for all eight declared symbol/dates, official `CHECKSUM` and metadata
+bodies plus their sidecars, per-symbol and aggregate lock hashes, and the clean
+real Git revision. Verification rejects a dirty, unborn, synthetic, or changed
+source identity and rechecks all bound artifact bytes before reuse.
+
+External raw and normalized data are ignored by Git. Small deterministic test
+fixtures may be committed only under tests and must state whether they are
+synthetic or sampled public observations.
+
+### Frozen dual-symbol live-L2 session authority
+
+Each prospective L2 date uses one absolute UTC start/end barrier and one
+cross-symbol authority for BTCUSDT and ETHUSDT. The two single-symbol producers
+run concurrently and preserve raw frames before parsing. Coverage is computed
+only from intervals backed by consecutive `OBSERVED` reconstructed book states;
+raw socket first/last span, stale updates, excluded messages, gaps, and silent
+holes do not create coverage. The session gate uses the exact union/intersection
+of those intervals, requires one sufficiently long valid continuity epoch,
+reconciles raw/normalized/reconstructed/excluded rows and snapshot anchors, and
+enforces the frozen gap, error, warning, frame-byte, and Arrow-batch limits.
+
+All per-symbol raw journals, snapshots, normalized data, manifests, quality
+reports, and capture summaries must form an exhaustive regular-file inventory.
+A passing dual-symbol session is published atomically with checksums and exact
+`_SUCCESS` bytes; a typed capture/gate failure publishes an immutable
+`INSUFFICIENT_DATA` authority. Permission, local-I/O, source/config/protocol
+drift, or program faults retain nonterminal raw evidence but may not publish a
+research terminal. Neither terminal authorizes live trading.
+
+## Quality policy
+
+Validators never sort, deduplicate, clip, interpolate, or rewrite observations.
+They emit typed findings for duplicate trades, timestamp/order reversals,
+availability/receipt contradictions, sequence gaps or stale updates, crossed
+books, invalid price/quantity, scale mismatches, abnormal spread, nonmonotone
+depth, long silence, and receipt-clock reversal. A downstream research view may
+exclude a row, but it must preserve the normalized source and report the
+exclusion count/reason.
+
+Incremental validators retain only a bounded in-memory finding preview; exact
+duplicate/clock/sequence state spills to SQLite and complete findings stream to
+JSONL. A failed validation closes and removes only its temporary sink, leaving
+any previously published evidence untouched.

Microstructure/docs/DATA_POLICY.md

@@ -0,0 +1,45 @@
+# Data policy
+
+## Public repository boundary
+
+The public repository and its Hugging Face mirror contain only Git-tracked
+source code, configuration, tests, documentation, and small placeholder files.
+They do not contain exchange observations or generated research bundles.
+
+The following local paths are excluded from every public package:
+
+- `data/raw/`, `data/normalized/`, `data/derived/`, `data/models/`, and
+  `data/quality/`;
+- `data/m8/`, `data/m8_l2/`, and `data/_ingestion_manifests/`;
+- `artifacts/runs/`;
+- local environments, caches, bytecode, credentials, and dashboard secrets.
+
+Empty `.gitkeep` placeholders may exist in the standalone GitHub repository but
+are omitted from the Hugging Face publication mirror where practical.
+
+## Provider terms
+
+The research adapters use credential-free public Binance market-data endpoints
+and official archive metadata. Public availability is not treated as a grant to
+redistribute provider data. Users who reproduce a public-data study obtain the
+inputs independently and remain responsible for the provider's current terms,
+rate limits, and permitted uses.
+
+## Research outputs
+
+Source-controlled prose may summarize bounded aggregate validation counts and
+protocol terminals. Raw events, normalized rows, derived features, fitted model
+states, account-like records, and generated run bundles are not redistributed.
+Synthetic fixtures and smoke outputs are labeled `SYNTHETIC_SMOKE` and support
+software verification only.
+
+The public website and Space may encode low-dimensional aggregate values already
+stated in tracked README or status prose—for example row counts, warning counts,
+and a declared terminal state—when they link back to that source and preserve its
+evidence label. They do not publish additional model or execution metrics.
+
+## Trading boundary
+
+The repository has no authenticated exchange client, account connection, or
+order-entry path. Nothing in the public package is investment advice or evidence
+of executable profit.

Microstructure/docs/DECISION_LOG.md

@@ -0,0 +1,487 @@
+# Decision log
+
+## 2026-08-09 — Supersede the incomplete Aug 8–11 campaign with a new prospective v2 calendar
+
+- **Observed boundary:** The v1 Aug 8 session is an immutable `MISSED_WINDOW`,
+  the Aug 9 validation session is immutable and complete, and the v1 development
+  authority is `NOT_CREATED`. Those facts and files remain preserved.
+- **User decision:** Abandon v1 as the active empirical study and, before any of
+  the new dates is observed, freeze Aug 10 train, Aug 11 validation, Aug 12
+  primary test, and Aug 13 replication test at 14:00–15:00 UTC.
+- **Integrity rule:** This is a new campaign/version and storage/source
+  authority, not a replacement bundle inside v1. V1 observations are not used
+  for v2 training, selection, evaluation, or reporting. Once Aug 10 begins, no
+  v2 date, threshold, feature, model, or interpretation rule may be changed.
+- **Consequence:** A complete v2 train and validation may create the eight-state
+  `LOCKED` development authority before Aug 12; otherwise v2 terminates through
+  its existing `NOT_CREATED`/`INSUFFICIENT_DATA` branches without substitution.
+
+## 2026-08-08 — Preserve the missed first L2 window as control evidence only
+
+- **Observed fact:** The declared Aug 8 14:00--15:00 UTC train window ended
+  before a clean committed producer authority was available. No capture command
+  ran, `data/m8_l2` remained absent, and no raw or economic field was opened.
+- **Decision:** Never backfill, replace, or infer that session. Once the release
+  candidate has a clean source authority, invoke the already-tested late-start
+  path solely to publish `INSUFFICIENT_DATA / MISSED_WINDOW`; it must not call a
+  symbol capture adapter or network endpoint. Verify and retain that terminal,
+  then continue Aug 9--11 on their declared windows under the same campaign
+  authority.
+- **Consequence:** The four-date study cannot promote a fitted development lock,
+  predictive metric, descriptive result, or execution scenario. Its honest final
+  outcome is necessarily aggregate `INSUFFICIENT_DATA`, backed by one missed
+  control terminal plus the remaining declared session authorities.
+
+## 2026-08-08 — Make development insufficiency a positive authority
+
+- **Problem:** A valid `INSUFFICIENT_DATA` terminal on Aug 8 or Aug 9 forbids
+  fitting, but a missing development lock cannot authorize the final four-date
+  terminal and is indistinguishable from an interrupted workflow.
+- **Decision:** The Aug 9 command always atomically publishes exactly one
+  development authority. `LOCKED` contains the eight fitted child states and
+  uses `_LOCKED` bytes `locked\n`. `NOT_CREATED` contains only typed,
+  recursively verified session-control reasons, uses `_NOT_CREATED` bytes
+  `not-created\n`, and must not load any economic frame. Both statuses expose the
+  same canonical authority path and SHA fields; a valid `NOT_CREATED` command
+  or verification exits 1 rather than masquerading as a system error.
+- **Consequence:** Aug 10/11 are still captured on schedule. After Aug 11 the
+  one final producer verifies all four session controls and the development
+  authority. A `NOT_CREATED` branch publishes aggregate `INSUFFICIENT_DATA`,
+  reports the union of development and held-out reasons, and contains no
+  Parquet, model, prediction, descriptive, or execution artifact.
+
+## 2026-08-08 — Complete the explicit-authority L2 terminal producer
+
+- **Decision:** Expose one operational path through
+  `lock-m8-l2-development`, `verify-m8-l2-development-lock`,
+  `reproduce-m8-l2`, `verify-m8-l2-run`, and `report-m8-l2`. Every stage takes
+  explicit bundle paths and independently supplied manifest/checksum SHA-256
+  authorities; development and final verification additionally require the
+  exact lock and run-control digests. No command discovers a "latest" input.
+- **Terminal semantics:** After both held-out bundles' base authorities are
+  verified, any non-`COMPLETE` held-out session publishes aggregate
+  `INSUFFICIENT_DATA` without opening either held-out economic frame. If all
+  sessions are complete but an endpoint has no eligible held-out labels, the
+  same typed terminal is published without predictive, descriptive, or execution
+  promotion. Otherwise the producer restores the eight locked states without
+  refit, writes all declared evaluation/descriptive/market-scenario artifacts,
+  snapshots its external authorities, checksums the exact inventory, writes
+  `_SUCCESS` last, and immediately performs recursive verification. The exact
+  final marker bytes are `complete\n` for `_SUCCESS` and `terminal\n` for
+  `INSUFFICIENT_DATA`.
+- **Reporting:** Both the canonical trade-M8 failure report and live-L2 reports
+  are rendered only after verification into a directory outside the immutable
+  run. The generated report-input snapshot is checksummed and re-rendered for
+  equality; report commands state that the source bundle was not modified.
+
+## 2026-08-08 — Bind one outcome-blind L2 campaign to its runtime and storage root
+
+- **Decision:** The first predeclared capture creates one random 256-bit,
+  outcome-blind campaign nonce and binds all four sessions to one canonical
+  output-root path plus its filesystem device/inode identity. Moving to a
+  different root or replacing that directory is rejected before capture rather
+  than treated as a continuation of the campaign.
+- **Runtime authority:** Bind the clean commit/source-tree identity, loaded
+  package/module origin, Python/platform identity, and the exact versions of the
+  eight production dependencies. Persist the canonical runtime payload and its
+  SHA-256 and revalidate it throughout orchestration and later input/final-run
+  verification.
+- **Reason:** A commit hash alone does not prove that all dates used the same
+  interpreter, dependency environment, imported source tree, physical evidence
+  root, or prospectively chosen campaign instance.
+
+## 2026-08-08 — Accept the frozen trade-only M8 data-insufficiency terminal
+
+- **Observed evidence:** The corrected clean-source run at commit
+  `88060613abe211cd8e80a3499678fca830f8ba2d` normalized 2,071,461 BTCUSDT
+  training rows with no findings, then normalized 987,297 ETHUSDT training rows
+  with zero errors and 53 `temporal.long_silence` warnings. That violated the
+  predeclared zero-warning gate.
+- **Decision:** Treat `artifacts/runs/binance-m8-multidate` as the canonical
+  `INSUFFICIENT_DATA` terminal. Preserve its complete failed-normalization
+  evidence and the earlier noncanonical layout-defect terminal unchanged. Do not
+  replace the date, relax the warning rule, or reinterpret insufficiency as a
+  failed economic hypothesis.
+- **Boundary proved by the terminal:** Selection did not start; no analysis lock,
+  fitted state, prediction, endpoint, held-out member, execution, P&L, capacity,
+  or significance result was produced. The trade-only study is closed; live-L2
+  evidence remains a separate prospective campaign.
+
+## 2026-08-08 — Freeze the complete live-L2 analysis contract before capture
+
+- **Authority:** The exact analysis TOML has source SHA-256
+  `71edf7eeb9d5e935a18b0d8e354dc29b5b1132ace8eccd577730572d2caa8617`
+  and semantic SHA-256
+  `eeb9ac23ff275f26de57533a317d8165a89e99a14e86404a667cc69f6477bdac`.
+  It binds capture-config SHA-256
+  `491b14727a3e8bad907d1ad64072f6ebc14e407f98a5c31fca7b0a9e6801e758`
+  and capture-protocol SHA-256
+  `fe6d4aea5af3e9c529486b7e108afefeba623bf5ad3cc0743c0426a5e62e1fa7`.
+  Every declared TOML field is rendered without amendment in
+  `docs/M8_L2_ANALYSIS_CONTRACT.md` and enforced by a fail-closed loader.
+- **Development boundary:** Fit volatility regimes on Aug 8 only; select each of
+  the two-symbol by four-endpoint candidates on Aug 9; persist final fitted model,
+  prior, preprocessing, calibration, regimes, and execution reference in eight
+  child locks plus one aggregate lock before either held-out session is exposed.
+- **Held-out and claims boundary:** Aug 10/11 restore locked state without fit,
+  refit, recalibration, threshold change, or regime update. Evaluation uses the
+  four declared horizons and 2,000-draw paired moving blocks. Execution is a
+  market-order scenario only. Capacity, realized execution, and profitability
+  claims remain forbidden irrespective of the result.
+
+## 2026-08-08 — Keep raw authority separate from derived M8 failure evidence
+
+- **Discovery:** The first clean-source development attempt stopped at its
+  frozen data-quality gate before selection, locks, or held-out access, but its
+  terminal bundle could not be reused: normalized and quality artifacts had
+  been written inside the directory that the raw-acquisition verifier correctly
+  requires to be an exact raw-only authority.
+- **Decision:** Preserve the bundled raw authority unchanged below
+  `data/input`; write normalized and DQ artifacts below
+  `data/normalized_input`; root the final cross-stage manifest at `data`.
+  `INSUFFICIENT_DATA` inventories must exactly match the physical regular-file
+  tree and bind completed or failed normalization evidence. The producer runs
+  the external reuse verifier before and after atomic publication.
+- **Evidence policy:** The original source-tagged attempt is retained rather
+  than repaired or overwritten. It is not canonical research evidence, and its
+  failure opened no declared held-out member. A fresh terminal requires a new
+  clean committed source identity; the frozen dates and quality policy do not
+  change.
+
+## 2026-08-08 — Lock transparent final fitted state before held-out access
+
+- **Decision:** Fit and calibrate the validation-selected model and an independent
+  historical prior once on train plus validation. Serialize canonical numeric
+  preprocessing, estimator, calibration, feature-order, cutoff, and fallback
+  state into each child lock; bind both state hashes into the aggregate lock.
+- **Held-out rule:** Primary and replication prediction restore those numeric
+  states. No classifier/calibrator fit, refit, recalibration, or online update is
+  permitted after the aggregate lock becomes durable.
+- **Reason:** A lock that committed only a future refit policy did not freeze the
+  actual model used on untouched data.
+
+## 2026-08-08 — Separate deterministic acquisition insufficiency from system faults
+
+- **Decision:** Declared-object absence and authenticated metadata/CHECKSUM/ZIP,
+  response-size, or total-evidence-budget violations produce a typed immutable
+  raw-only `INSUFFICIENT_DATA` authority. Transient-network exhaustion,
+  permission/local-I/O errors, collisions, and program faults do not terminalize.
+- **Reason:** Deterministic missing/invalid declared evidence consumes the frozen
+  study, while an operational failure must remain safely retryable and cannot be
+  recorded as an empirical outcome.
+
+## 2026-08-08 — Define prospective L2 coverage by observed book-state intervals
+
+- **Decision:** A frozen session counts only consecutive receipt-time intervals
+  backed by `OBSERVED` reconstructed states within one continuity epoch. Stale,
+  excluded, gapped, invalid, and silent intervals are not bridged. Cross-symbol
+  coverage is the intersection of each symbol's interval union.
+- **Publication:** Both symbols share one absolute UTC barrier and one atomic
+  terminal authority. Failed data/gates publish `INSUFFICIENT_DATA`; system
+  faults preserve nonterminal raw evidence. No failed date is replaced.
+- **Reason:** Raw first/last websocket timestamps can hide reconnects and silent
+  holes and therefore cannot prove usable simultaneous book coverage.
+
+## 2026-08-07 — Enforce raw-only acquisition and lock-before-open execution
+
+- **Decision:** Split M8 into an immutable raw authority and a one-way research
+  producer. Acquisition authenticates exchange metadata, eight ZIPs, eight
+  official CHECKSUM responses, and bounded ZIP directory metadata, but cannot
+  open a CSV member. The producer normalizes only train/validation, persists two
+  symbol locks and an aggregate lock, then revalidates every committed identity
+  immediately before each held-out member is opened.
+- **Reason:** Merely delaying a later Parquet scan would not preserve the
+  prospective boundary if held-out economic rows had already been decompressed.
+  The first decompressed member byte is therefore the enforced boundary.
+- **Failure policy:** Deterministic data insufficiency before or after locking is
+  an immutable terminal result with no replacement date, endpoint prediction,
+  execution result, or profitability/significance claim. Unexpected system
+  failures publish no partial research target.
+- **Protocol effect:** This is operational hardening only. It changes no date,
+  feature, candidate, endpoint, hypothesis, estimand, or interpretation rule.
+
+## 2026-08-07 — Count every retained raw-evidence byte and physical copy
+
+- **Decision:** Use one reservation ledger for accepted responses, retry/error
+  prefixes, CHECKSUM bodies, exchange metadata, and every source sidecar. Raw
+  manifests enumerate the exact physical inventory. A self-contained run copy
+  is a distinct retained copy and must fit under the same frozen total ceiling
+  before its first byte is written.
+- **Reason:** Per-response limits alone do not bound accumulated retries,
+  sidecars, or duplicated evidence on a 16 GB local machine. Post-hoc counting
+  could leave an oversized partial publication.
+- **Consequence:** Raw response publication is fail-closed and rollback-safe;
+  normalized Parquet and machine-generated manifest indexes remain outside the
+  raw-response byte ceiling, as declared by the protocol.
+
+## 2026-08-07 — Freeze future live-L2 sessions before observation
+
+- **Decision:** Reserve 14:00–15:00 UTC on 2026-08-08 through 2026-08-11 for
+  concurrent BTCUSDT/ETHUSDT development, validation, primary-test, and
+  replication-test captures.
+- **Acceptance:** Both symbols need at least 3,300 seconds of overlapping
+  receipt-time coverage, a 1,800-second continuous valid epoch, zero sequence
+  gaps, zero DQ findings, exact row reconciliation, and complete immutable
+  capture evidence.
+- **Reason:** Fixed future sessions prevent outcome-based window choice and make
+  disconnects or missing data visible failures rather than hidden replacements.
+- **Claim boundary:** The first protocol is book-only. It permits future-mid
+  prediction and market-order scenarios, but not limit-fill, realized execution,
+  capacity, significance, or profitability claims.
+
+## 2026-08-07 — Record the Jan 6 coverage-metadata race
+
+- **Discovery:** Before a stop message reached the parallel feasibility audit,
+  it completed the same official archive availability, checksum, byte/row
+  count, aggregate-trade-ID boundary, and timestamp-boundary checks for Jan 6.
+  It did not inspect or retain price, quantity, maker direction, class balance,
+  features, labels, or model results.
+- **Correction:** Protocol 1.0.2 records coverage-only inspection for all four
+  dates. The calendar, roles, hypotheses, model grid, and interpretation rules
+  were already frozen and remain unchanged.
+- **Boundary:** This metadata helps verify feasibility and completeness only. It
+  is not economic evidence and cannot justify changing or dropping a date.
+
+## 2026-08-07 — Correct the M8 freeze claim to outcome-blind
+
+- **Discovery:** A parallel feasibility audit read official Jan 3–5 archive
+  availability, checksum, byte/row count, aggregate-trade-ID boundary, and
+  timestamp-boundary metadata before commit `a34ba13`. It did not inspect or
+  retain economic fields, class balance, features, labels, or model results;
+  Jan 6 was not inspected.
+- **Correction:** Protocol 1.0.1 describes the study as outcome-blind rather
+  than claiming it was fully acquisition/inspection-blind. The calendar and all
+  roles remain unchanged because they were selected mechanically before those
+  metadata were reported.
+- **Constraint:** No economic field or model outcome from any declared date may
+  be inspected until the ingestion, analysis lock, and final-test gates are
+  implemented. Coverage-only facts cannot be used to replace a date.
+
+## 2026-08-07 — Freeze the M8 multi-date trade calendar before acquisition
+
+- **Decision:** Reserve the complete 2024-01-03 and 2024-01-04 UTC Binance Spot
+  daily aggregate-trade archives for training and validation, and reserve the
+  adjacent 2024-01-05 and 2024-01-06 archives as primary and replication tests.
+  Both BTCUSDT and ETHUSDT are mandatory. The inspected 2024-01-02 sample is
+  excluded from all study estimates.
+- **Reason:** Adjacent dates chosen mechanically before acquisition provide an
+  auditable barrier against outcome-based date selection. Full daily archives
+  remove the current row-cap truncation while remaining feasible on local disk
+  with streaming normalization.
+- **Evaluation:** Model selection uses validation log loss only. A locked model
+  is then evaluated without refit on both untouched dates, using paired
+  40-trade-block loss differences and explicit direction-replication status.
+- **Claim boundary:** This is a complete-data trade-only study. Execution, book,
+  fill, P&L, capacity, significance, and cross-instrument pooling remain
+  unauthorized. M8 still requires separately frozen continuous real L2 evidence.
+- **Failure policy:** Missing, oversized, corrupt, noncontiguous, or otherwise
+  invalid declared data produces `INSUFFICIENT_DATA`; dates are never replaced.
+
+Material choices are appended; prior entries are not rewritten to hide reversals.
+
+## 2026-08-07 — Initialize the empty `Microstructure` directory
+
+- **Context:** The requested `microstructure` folder exists as `Microstructure`
+  and contains no files or Git metadata.
+- **Decision:** Treat the capitalized directory as the target and initialize a
+  clean Python research repository there.
+- **Consequence:** There is no existing user work to merge or preserve inside the
+  target; all new paths are scoped to this directory.
+
+## 2026-08-07 — Separate offline software evidence from market evidence
+
+- **Context:** A new user must reproduce a small run without a large download,
+  while the project must not invent empirical findings.
+- **Decision:** Make the default smoke/reproduction data a deterministic,
+  explicitly synthetic fixture generated from declared rules. Keep public
+  Binance ingestion as a separate, credential-free command and never describe
+  fixture metrics as empirical market results.
+- **Consequence:** The vertical slice can be tested offline. Economic conclusions
+  remain deliberately unavailable until a manifested public-data run is made.
+
+## 2026-08-07 — Use trade events for the initial research slice
+
+- **Context:** Historical trades are broadly public and compact; historical full
+  depth is less consistently public. The objective explicitly permits trades or
+  a small book sample for the first slice.
+- **Decision:** Build the first model dataset from signed trades and event-time
+  liquidity proxies. Implement and test L2 snapshot/delta reconstruction as a
+  separate adapter path, but do not pretend trade-only data identify queue fills.
+- **Consequence:** Initial fill probability and queue position are declared
+  assumptions. Later L2 runs can replace them through the same interfaces.
+
+## 2026-08-07 — Prefer integer event ordering plus UTC nanoseconds
+
+- **Context:** Exchange timestamps may tie and floating timestamps can obscure
+  exact temporal order.
+- **Decision:** Normalize `event_id`, `sequence`, `event_ts_ns`, and
+  `received_ts_ns`. Stable event ordering is `(event_ts_ns, sequence, event_id)`;
+  receipt time is retained for latency realism.
+- **Consequence:** Features and labels can state observable cutoffs explicitly;
+  downstream modules must not reorder tied events arbitrarily.
+
+## 2026-08-07 — Make validation non-mutating
+
+- **Context:** Silent repair can erase evidence of feed or clock problems.
+- **Decision:** Validators emit typed findings and summaries but never mutate raw
+  or normalized observations. Any later filtering writes a new derived dataset
+  and records exclusion counts.
+- **Consequence:** A run can fail on fatal findings or continue on declared
+  warnings without altering source evidence.
+
+## 2026-08-07 — Evaluate event-time models with purged walk-forward folds
+
+- **Context:** Random splits leak regime information and overlapping future-label
+  horizons leak outcomes across adjacent partitions.
+- **Decision:** Use expanding-window, time-ordered folds. Remove training rows
+  whose label end reaches the validation/test boundary and support a configurable
+  embargo. Reserve the last fold for final comparison, not model selection.
+- **Consequence:** Small fixtures may yield wide uncertainty; that is preferable
+  to optimistic metrics.
+
+## 2026-08-07 — Do not infer historical Spot depth from trade archives
+
+- **Context:** Binance's credential-free Spot archive exposes trades and
+  aggregate trades, but not a complete historical Level-2 feed suitable for book
+  reconstruction. REST snapshots are current anchors rather than historical
+  depth observations.
+- **Decision:** Use fixed, bounded public REST aggregate trades for historical
+  ingestion. Keep Level-2 research behind an optional public live diff-depth
+  collector that begins with a locally received snapshot and creates a new epoch
+  after every reconnect or gap.
+- **Consequence:** Historical trade research and book research are different
+  evidence paths. No queue, cancellation, or depth claim is inferred from the
+  downloaded trade sample.
+
+## 2026-08-07 — Derive numerical scales from exchange metadata
+
+- **Context:** Fixed decimal precision can misrepresent instruments and can
+  change across venue rules. Binance aggregate-trade timestamps also changed
+  archive units for newer files, while REST uses its documented request units.
+- **Decision:** Fetch `PRICE_FILTER.tickSize` and `LOT_SIZE.stepSize` from public
+  `exchangeInfo` before normalization, retain integer ticks/lots plus the scale,
+  and make timestamp-unit conversion explicit at the adapter boundary.
+- **Consequence:** Exact source values are reproducible without assuming a
+  universal `1e-8` quantum. Low-level fallback scales are not used by the sample
+  workflow.
+
+## 2026-08-07 — Freeze results as immutable atomic bundles
+
+- **Context:** A dashboard or report must never read half-written results, and a
+  repeated command must not silently revise earlier evidence.
+- **Decision:** Produce into a sibling staging directory, serialize all inputs,
+  folds, metrics, ledgers, assumptions and reports, checksum every file, create
+  `_SUCCESS` last, verify the bundle, then atomically rename it. A completed
+  target is reusable only if verification passes; incomplete or corrupted
+  targets are rejected rather than repaired.
+- **Consequence:** Changed configuration or assumptions require a new run. The
+  deterministic semantic run key is based on config, immutable input identity,
+  Git state and seed, excluding wall-clock generation time.
+
+## 2026-08-07 — Keep execution conditional and out-of-sample
+
+- **Context:** Archived public events cannot identify a strategy's true queue
+  position, endogenous impact, or colocated latency. Replaying in-sample
+  probabilities would further overstate execution evidence.
+- **Decision:** Accept only validation-selected, held-out test predictions in the
+  execution simulator. Treat market depth, limit-fill Bernoulli behavior, queue
+  ahead, latency, fees, liquidation and capacity as serialized scenario inputs;
+  use common keyed randomness for comparable sensitivities.
+- **Consequence:** Predictive and execution tables remain separate. Simulated
+  results are conditional diagnostics, not realized or deployable performance.
+
+## 2026-08-07 — Cap and label the first public sample
+
+- **Context:** A local Apple Silicon workflow needs a small, auditable public
+  acquisition rather than an open-ended download.
+- **Decision:** Request the fixed interval beginning 2024-01-02 00:00 UTC for
+  BTCUSDT and ETHUSDT, capped at 5,000 aggregate trades per symbol, and label the
+  acquisition `PUBLIC_SAMPLE_PARTIAL`.
+- **Consequence:** The cap was reached for both symbols. All 10,000 normalized
+  rows passed the current validators, but both requested ranges are recorded as
+  incomplete and no economic hypothesis is promoted from this sample.
+
+## 2026-08-07 — Freeze the trade-only public study before model comparison
+
+- **Context:** The already acquired public sample contains aggregate trades but
+  no contemporaneous order-book state. Reusing book features or the execution
+  simulator would turn missing observations into assumptions and overstate the
+  evidence.
+- **Decision:** Freeze a retrospective, explicitly exploratory trade-only
+  protocol with per-symbol causal features, strictly later trade labels,
+  purged walk-forward folds, validation-only model selection, and a paired
+  fixed-block comparison against the historical prior. Require the caller to
+  select the ingestion manifest by both path and SHA-256; never scan for a
+  "latest" input. Serialize execution artifacts as `NOT_RUN` with a reason.
+- **Consequence:** BTCUSDT and ETHUSDT are reported separately, including failed
+  or contradictory outcomes. The run cannot be interpreted as a book, fill,
+  P&L, statistical-significance, or persistent-alpha study.
+
+## 2026-08-07 — Make page/batch streaming the default public ingestion path
+
+- **Context:** A configurable row cap made the first 10,000-row sample safe, but
+  the original downloader, validator, and ingestion composition retained the
+  entire acquisition in memory. A cap on observations is not a RAM contract and
+  does not satisfy the larger-history requirement.
+- **Decision:** Expose a lazy, page-bounded Binance iterator; feed each page once
+  through an incremental validator with disk-backed exact identity state and
+  then into a batch-bounded Parquet writer. Keep eager materialization only as an
+  explicit compatibility operation with its own finite row guard.
+- **Consequence:** Public acquisition memory is bounded by response/batch and
+  validator preview limits rather than total history length. Manifest and part
+  metadata may still grow with page count; downstream full-history readers must
+  likewise use verified batch scans instead of eager Arrow/Polars copies.
+
+## 2026-08-07 — Verify public history before exposing a bounded canonical stream
+
+- **Context:** Hashing only an ingestion manifest does not prove that normalized
+  rows still match the declared raw pages, source symbol, exchange metadata, or
+  physical arrival order. Sorting first can also conceal source-order defects.
+- **Decision:** Bind the explicit ingestion path+SHA to configuration, raw URI
+  semantics and exact aggregate-trade fields; require inverse raw-to-normalized
+  coverage; run physical-order incremental DQ; and feed that single verified
+  Arrow stream into a memory-limited DuckDB external sort. Keep eager loading as
+  a separately guarded compatibility API.
+- **Consequence:** The current 10,000-row input can be materialized for the
+  predeclared small study, while larger consumers can iterate bounded canonical
+  batches without trusting a global in-memory sort.
+
+## 2026-08-07 — Make quality evidence atomic and ingestion-manifested
+
+- **Context:** Reusing a fixed findings filename could truncate a previous
+  complete JSONL before a rerun succeeded, leaving an older summary pointing at
+  partial/new evidence.
+- **Decision:** Stream findings into a same-directory temporary file, fsync and
+  atomically publish only on validator completion, use a distinct per-ingestion
+  quality filename, and bind report/findings paths, byte counts and SHA-256 into
+  the immutable ingestion manifest.
+- **Consequence:** A failed rerun cannot damage previously published findings;
+  complete quality evidence is independently integrity-checkable.
+
+## 2026-08-07 — Treat the exact source tree as part of run identity
+
+- **Context:** A Git commit plus `dirty=true` cannot distinguish different local
+  patches. It also allowed an old clean bundle to satisfy `make smoke` after the
+  implementation changed.
+- **Decision:** Hash the bytes, paths and modes of every tracked and non-ignored
+  untracked source file. Include that digest with commit/dirty state in
+  provenance and both synthetic/public run keys; refuse completed-target reuse
+  when any component differs. Run the `make check` smoke leg in a fresh temporary
+  target.
+- **Consequence:** Ignored raw/run artifacts do not perturb identity, but changed
+  code, configuration, tests or documentation requires a new immutable bundle.
+
+## 2026-08-07 — Journal live depth before parsing and reconstruct incrementally
+
+- **Context:** Retaining every WebSocket payload, delta and reconstructed book
+  row in Python made `collect-l2 --max-messages` an in-memory history limit. A
+  malformed frame could also fail before its original bytes were preserved.
+- **Decision:** Emit exact raw frames to a typed capture journal before decoding,
+  record each reconnect snapshot anchor, enforce per-frame/batch byte ceilings,
+  run a bounded-state incremental book reconstructor and incremental DQ, and
+  stream capture-scoped Parquet output. Publish one immutable capture-ID summary
+  last; keep the fixed summary filename only as a latest-pointer.
+- **Consequence:** Capture memory is bounded by book depth and batch limits rather
+  than message count; every epoch is resnapshotted, every message is reconciled
+  to an observation/exclusion, and parse/sequence failure leaves explicit raw
+  evidence without fabricating a completed capture.

Microstructure/docs/EXPLORATORY_AGGTRADES_2026_08_05_08.md

@@ -0,0 +1,59 @@
+# August 5–8 public aggregate-trade exploratory protocol
+
+## Scope
+
+This retrospective, trade-only study uses the complete official Binance Spot
+daily `aggTrades` archives for BTCUSDT and ETHUSDT on 2026-08-05 through
+2026-08-08. It is independent of the frozen live-L2 campaign. It contains no
+book depth, spread, queue, cancellation, local receipt time, or executable
+order evidence.
+
+The date roles are fixed before any archive CSV member is opened:
+
+| UTC date | Role |
+| --- | --- |
+| 2026-08-05 | Train |
+| 2026-08-06 | Validation and model selection |
+| 2026-08-07 | Primary test |
+| 2026-08-08 | Replication test |
+
+The evidence tier is `PUBLIC_ARCHIVE_EXPLORATORY`. Results cannot be described
+as confirmatory, statistically significant, persistent alpha, executable P&L,
+or an L2 finding.
+
+## Data and quality
+
+Each ZIP must match the exchange-published `.CHECKSUM`, contain exactly its
+declared CSV member, remain inside bounded compressed and expanded byte limits,
+and preserve its raw response and source sidecar. Normalization is streamed to
+partitioned Parquet. Aggregate-trade IDs must be contiguous and event time must
+not reverse within each symbol/date.
+
+Quality warnings are retained and reported but do not stop this exploratory
+run; any error, checksum failure, archive-contract failure, ID gap, or temporal
+violation stops the run. No observation is repaired or replaced.
+
+## Features, target, and evaluation
+
+Features use only the current and prior trades within one UTC-day continuity
+segment: one-trade return; signed volume, total volume, and imbalance over 5,
+20, and 100 trades; 50-trade count and intensity; and 100-trade realized
+volatility. The target is whether trade price 20 aggregate trades later is
+higher. Segment tails are censored.
+
+The candidate ladder is the historical prior, unpenalized logistic regression,
+the declared L2-regularized logistic grid, and the declared shallow-tree grid.
+Only August 5–6 may select and fit the final selected/prior states. Both symbol
+locks and one aggregate lock must be persisted before either August 7 or August
+8 CSV member opens. No refit is allowed afterward.
+
+Selected-minus-prior log-loss differences are reported separately for both test
+dates and with equal-date weighting. Seeded 40-trade paired block intervals are
+descriptive dependence diagnostics only; no p-values or significance claim are
+authorized. BTCUSDT and ETHUSDT are never pooled.
+
+## Explicit exclusions
+
+Execution, fills, fees, capacity, queue position, market impact, profitability,
+and live-L2 conclusions are `NOT_RUN` or unauthorized. A favorable point
+estimate is evidence only about these four retrospective trade archives.

Microstructure/docs/M8_L2_ANALYSIS_CONTRACT.md

@@ -0,0 +1,183 @@
+# M8 live-L2 analysis contract
+
+## Authority and status
+
+This document is a human-readable, field-complete rendering of
+`configs/m8_l2_analysis.toml`. It does not amend or supersede those bytes. The
+strict loader rejects a changed, missing, or additional field.
+
+| Authority | SHA-256 |
+| --- | --- |
+| Analysis TOML source bytes | `0d786d5f4109bb5bf773a6197df3fa861c9b7eb61c16c957bd49fb56147fd7d8` |
+| Analysis TOML canonical semantics | `17c91f64765f35195ab03a4caac93d8ff9c5f009c16e785fd84ebd9569d6f84b` |
+| Bound capture-config source bytes | `b1bf3b4e2820e24e4555bfeb9cb0957f9a0bcdef62039f7d92360e0a97d0dd39` |
+| Bound capture-protocol source bytes | `4c77a2099a4cabd049d10e0f8264d3b4c66704d8e87cbaf0c817fd085f4bbd83` |
+
+The calendar, capture gates, model candidate grid, fee, and decision/order
+latency event-count grid remain authoritative in the bound capture config and
+`docs/M8_L2_PROTOCOL.md`; they are not silently restated as analysis-config
+fields here. At freeze time, this contract contained no observed session data or
+model outcome. It therefore authorizes no empirical conclusion by itself.
+
+## Operational enforcement
+
+The implemented producer consumes four explicit session bundle paths, manifest
+SHA-256 values, and checksum-file SHA-256 values. Development locking additionally
+binds its aggregate SHA, and final verification/reporting additionally binds the
+run manifest and checksum-file SHA. The campaign authority ties every date to one
+outcome-blind nonce, canonical filesystem root identity, clean source/import
+origin, and hashed Python/platform/production-dependency fingerprint. A final
+bundle snapshots these authorities for self-contained audit while recursively
+revalidating the external originals. Report re-rendering occurs outside the
+immutable run and leaves it unchanged. These enforcement facts implement the
+frozen contract; they are not additional TOML fields or empirical outcomes.
+
+## Study fields
+
+| TOML path | Frozen value |
+| --- | --- |
+| `study.name` | `binance-m8-live-l2-analysis` |
+| `study.protocol_version` | `1.0.0` |
+| `study.seed` | `20260807` |
+| `study.source` | `verified_m8_l2_session_bundles` |
+| `study.capture_config_source_sha256` | `491b14727a3e8bad907d1ad64072f6ebc14e407f98a5c31fca7b0a9e6801e758` |
+| `study.capture_protocol_sha256` | `fe6d4aea5af3e9c529486b7e108afefeba623bf5ad3cc0743c0426a5e62e1fa7` |
+| `study.symbols` | `BTCUSDT`, `ETHUSDT` |
+| `study.training_role` | `train` |
+| `study.selection_role` | `validation` |
+| `study.primary_endpoint_role` | `primary_test` |
+| `study.replication_endpoint_role` | `replication_test` |
+
+Only checksum-verified session bundles with the exact bound capture authorities
+are eligible. All per-symbol decisions operate inside verified observed
+continuity intervals; reconnects, gaps, excluded state, and invalid intervals
+are never bridged.
+
+## Feature and label fields
+
+| TOML path | Frozen value |
+| --- | --- |
+| `features.decision_scope` | `per_symbol_verified_observed_intervals` |
+| `features.flat_direction_policy` | `flat_is_non_up` |
+| `features.rolling_windows` | `20`, `100` |
+| `features.volatility_window` | `100` |
+| `features.clock_max_state_age_ms` | `500` |
+| `features.clock_target_policy` | `exact_target_locf_same_valid_observed_interval` |
+| `features.clock_label_information_end` | `exact_target` |
+| `features.clock_record_target_sequence` | `true` |
+| `features.clock_censor_if_no_eligible_state` | `true` |
+
+The exact ordered `features.model_feature_columns` value is:
+
+1. `spread_bps`
+2. `depth_total_l1`
+3. `depth_total_l5`
+4. `depth_total_l10`
+5. `queue_imbalance_l1`
+6. `queue_imbalance_l5`
+7. `queue_imbalance_l10`
+8. `microprice_deviation_bps`
+9. `ofi_l1`
+10. `ofi_w20`
+11. `ofi_w100`
+12. `cancellation_intensity_w20`
+13. `cancellation_intensity_w100`
+14. `realized_volatility_w20`
+15. `realized_volatility_w100`
+16. `volatility_regime_low`
+17. `volatility_regime_high`
+18. `liquidity_regime_liquid`
+19. `liquidity_regime_stressed`
+
+For a clock endpoint, the target is the exact horizon time. The eligible future
+book is the most recent state at or before that target, must be no more than 500
+ms old, and must belong to the same valid observed interval. Otherwise the label
+is censored. Its information end remains the exact target, and the chosen target
+sequence is recorded. A zero future return is assigned to the non-up class.
+
+## Endpoint fields
+
+| `endpoints` row | `domain` | `horizon_value` | `unit` | `paired_block_width` | `paired_block_unit` | `nominal_event_block_width` |
+| --- | --- | ---: | --- | ---: | --- | ---: |
+| `event_20` | `event` | 20 | `events` | 40 | `events` | 40 |
+| `event_100` | `event` | 100 | `events` | 200 | `events` | 200 |
+| `clock_1000ms` | `clock` | 1000 | `milliseconds` | 2000 | `milliseconds` | 20 |
+| `clock_5000ms` | `clock` | 5000 | `milliseconds` | 10000 | `milliseconds` | 100 |
+
+These four rows are the complete `[[endpoints]]` array; each table column maps
+one-for-one to a TOML field. Dependency blocks cannot cross a verified observed
+interval.
+
+## Regime, calibration, bootstrap, and signed-impact fields
+
+| TOML path | Frozen value |
+| --- | --- |
+| `regimes.fit_role` | `train` |
+| `regimes.feature` | `realized_volatility_w100` |
+| `regimes.quantile_numerators` | `1`, `2` |
+| `regimes.quantile_denominator` | `3` |
+| `calibration.bins` | `10` |
+| `bootstrap.method` | `paired_moving_block` |
+| `bootstrap.samples` | `2000` |
+| `signed_impact.metric` | `ofi_signed_future_mid_markout` |
+| `signed_impact.side_rule` | `sign_of_horizon_matched_ofi` |
+| `signed_impact.price_rule` | `ofi_sign_times_future_log_mid_return_bps` |
+
+Regime cutoffs are the training-role one-third and two-thirds quantiles of
+`realized_volatility_w100`. They are fit once and then applied without update.
+Here “horizon-matched OFI” means decision-time observable rolling OFI matched to
+the endpoint window, never OFI measured during or after the label interval:
+`event_20` and `clock_1000ms` use `ofi_w20`; `event_100` and `clock_5000ms` use
+`ofi_w100`.
+Those columns come from the causal decision feature frame, and their maximum
+source timestamp is validated not to exceed the decision timestamp. The signed-
+impact estimand multiplies that decision-time OFI sign by the strictly future
+log-mid return in basis points. The 2,000-draw paired moving-block design uses
+each endpoint's frozen block width; it does not authorize a p-value or a cross-
+symbol pooled significance claim.
+
+## Execution fields
+
+| TOML path | Frozen value |
+| --- | --- |
+| `execution.market_orders_only` | `true` |
+| `execution.probability_threshold` | `0.55` |
+| `execution.symmetric_probability_thresholds` | `true` |
+| `execution.order_notional_usd` | `100.0` |
+| `execution.max_l1_participation` | `0.10` |
+| `execution.inventory_order_multiples` | `10` |
+| `execution.reference_price_fit_role` | `train` |
+| `execution.reference_depth_fit_role` | `train` |
+| `execution.reference_price_statistic` | `train_median_mid_price` |
+| `execution.reference_depth_statistic` | `train_q05_min_bid_ask_l1_depth` |
+| `execution.reference_quantity_policy` | `min_100usd_and_10pct_train_q05_l1_depth_rounded_down_to_lot` |
+| `execution.l1_fill_policy` | `fill_up_to_recorded_l1_depth_cancel_remainder` |
+| `execution.scenario_reset_policy` | `per_symbol_session_endpoint_latency_pair` |
+| `execution.extra_slippage_bps` | `0.0` |
+| `execution.liquidate_at_end` | `true` |
+
+The symmetric threshold means long above `0.55`, short below `0.45`, and no
+order otherwise. Reference price and depth are fitted on training data only. The
+reference quantity is the smaller of USD 100 at the training median mid and 10%
+of the training fifth percentile of minimum bid/ask L1 depth, rounded down to the
+exchange lot. Recorded L1 depth caps each fill; any residual is cancelled.
+Inventory is capped at ten reference-order multiples. State resets for every
+symbol, session, endpoint, and latency pair, and end inventory is liquidated.
+Latency values and taker fee are consumed from the separately bound capture
+config; latency is measured in events, not milliseconds. Zero extra slippage is
+a frozen scenario assumption, not a claim that endogenous impact is zero.
+
+## Claim fields
+
+| TOML path | Frozen value |
+| --- | --- |
+| `claims.allow_capacity_claim` | `false` |
+| `claims.allow_realized_execution_claim` | `false` |
+| `claims.allow_profitability_claim` | `false` |
+
+Accordingly, eventual reports may describe predictive diagnostics and
+serialized market-order scenarios only. They cannot call those scenarios
+realized fills, deployable capacity, or evidence of profitability. Any missing
+or invalid declared session may instead produce `INSUFFICIENT_DATA`; that
+terminal is not replaced and does not count as a test of the economic
+hypothesis unless the required evaluation actually occurred.

Microstructure/docs/M8_L2_PROTOCOL.md

@@ -0,0 +1,103 @@
+# M8 prospective live-L2 protocol — replacement campaign v2
+
+## Scope and frozen calendar
+
+This replacement protocol was fixed before any v2 live session occurred. Both symbols
+must be captured concurrently from Binance Spot diff-depth at the requested
+100 ms stream interval:
+
+| UTC session | Role |
+| --- | --- |
+| 2026-08-10 14:00–15:00 | Train |
+| 2026-08-11 14:00–15:00 | Validation |
+| 2026-08-12 14:00–15:00 | Primary test |
+| 2026-08-13 14:00–15:00 | Replication test |
+
+The dates are the four consecutive UTC dates beginning after the v2 reset on
+2026-08-09, and the common hour was chosen before observing those sessions. Missing,
+quiet, volatile, disconnected, corrupt, or unfavorable sessions are never
+replaced. They produce an explicit `INSUFFICIENT_DATA` status. The superseded
+Aug 8–11 campaign and its evidence remain immutable and are not inputs to this
+study. The exact config
+bytes in `configs/m8_l2_capture_study.toml`, this protocol, their hashes, and the
+freeze Git commit must enter every resulting bundle.
+
+This is a research-only public market-data capture. It authenticates to no
+account and has no order-entry path.
+
+## Capture and continuity acceptance
+
+Each symbol receives its own snapshot and diff-depth stream, started as close to
+the common boundary as the public network allows. Raw websocket bytes must be
+journaled before UTF-8/JSON parsing. Every continuity epoch begins from a fresh
+REST snapshot and may use only buffered deltas satisfying Binance `U/u`
+bridging. Gaps, malformed ranges, crossed books, or scale mismatches terminate
+that epoch; they are recorded rather than repaired.
+
+A session is usable only when both symbols satisfy all of the following:
+
+- capture-specific completion status is `COMPLETE` and reconstruction ends
+  `LIVE`;
+- requested duration is 3,600 seconds and overlapping receipt-time coverage is
+  at least 3,300 seconds;
+- at least one valid continuity epoch spans 1,800 seconds;
+- sequence gaps and quality errors/warnings are all zero;
+- no raw frame exceeds 1 MiB and no Arrow batch estimate exceeds 16 MiB;
+- message, normalized-row, reconstructed-row, and excluded-row reconciliation
+  is exact;
+- every epoch has a raw snapshot anchor and every raw/normalized/quality file is
+  checksum-manifested.
+
+The 60,000-message ceiling is a safety bound, not a stopping target. A
+duration-aware graceful stop must publish completion evidence; SIGINT/cancellation
+or hitting the message ceiling early is not a complete one-hour session.
+
+## Causal dataset
+
+Continuity is never bridged across reconnects or gaps. At each decision book
+event, features may use only locally received snapshot/delta state available at
+or before that event. Frozen features are absolute/relative spread, L1/L5/L10
+depth, OFI, L1/L5/L10 queue imbalance, microprice displacement, observable
+zero-quantity cancellation intensity, short realized volatility, and regimes
+whose thresholds are fit on the training session only.
+
+Labels begin strictly after the decision event and are censored at continuity
+boundaries. Report future mid-price direction/return and signed price impact at
+20/100-event and 1/5-second horizons. Limit-fill and adverse-selection labels are
+not authorized without contemporaneous trade prints that prove depletion; this
+book-only protocol does not infer them from cancellation alone.
+
+## Evaluation and hypotheses
+
+Per symbol, train on Aug 10, select the fixed prior/logistic/L2/tree ladder by Aug
+11 log loss, lock the specification, then evaluate it without refit on Aug 12 and
+Aug 13. Probability calibration and regime thresholds use development data only.
+All declared horizons and model comparison rows are published; no final period
+is used for selection.
+
+The primary book hypothesis is that observable OFI, imbalance, microprice, and
+liquidity state reduce future-mid-direction log loss relative to a historical
+prior on both untouched sessions. Report paired dependency-block differences by
+symbol, session, horizon, and train-defined regime, plus equal-session-weighted
+stability. A result is directionally replicated only if both untouched sessions
+favor the selected model. No p-value, H0 rejection, cross-symbol pooled alpha,
+or significance claim is authorized.
+
+## Execution boundary
+
+Only scenario-based market-order evaluation is permitted: recorded best quotes,
+frozen taker fee, decision/order latency grids, inventory bounds, and end-of-run
+liquidation. It may show whether a predictive markout survives those serialized
+assumptions, but it is not realized execution. Limit fills, true queue priority,
+hidden liquidity, endogenous impact, and deployable capacity remain unsupported.
+Every report must keep predictive scores, simulated execution assumptions, and
+scenario P&L separate and must state that profitability is not established.
+
+## Immutable outputs
+
+The study requires capture-specific raw journals and snapshots, capture and
+normalized manifests, DQ/exclusion summaries, causal frames, analysis lock,
+frozen predictions/comparisons, regime/stability diagnostics, scenario execution
+ledgers, generated reports, config/protocol/input/Git provenance, checksums, and
+`_SUCCESS` written last. A missing session or failed gate may produce a failure
+bundle, but never a promoted result bundle.

Microstructure/docs/M8_MULTIDATE_TRADE_PROTOCOL.md

@@ -0,0 +1,269 @@
+# M8 prospective multi-date aggregate-trade protocol
+
+## Freeze and scope
+
+This protocol is outcome-blind: it is frozen before inspecting any declared
+date's price, quantity, aggressor side, class balance, feature, label, model, or
+economic result. During a parallel feasibility audit before the first protocol
+commit, the official Jan 3–5 archive availability, checksums, byte/row counts,
+aggregate-trade-ID boundaries, and timestamp boundaries were inspected. A
+stop-message race then allowed the same coverage-only checks for Jan 6 after the
+outcome-blind freeze; no economic field or result was read. These coverage-only
+facts were not supplied when the dates were chosen, and the mechanically
+selected calendar below was not changed after they became known. The previously
+inspected 2024-01-02 sample is
+protocol-development evidence only and is excluded from every fit, threshold,
+validation score, and test result below.
+
+The study is a prospective stability test of the trade-only hypothesis. It is
+not an order-book, execution, profitability, or capacity study. Even a favorable
+result cannot answer the repository's book-dependent or trading-cost questions;
+those require separately frozen, contemporaneous, continuous L2 evidence.
+
+The machine-readable specification is
+`configs/m8_multidate_trade_study.toml`. Its exact bytes, Git commit, and SHA-256
+must be copied into the final study bundle. Changing a date, role, feature,
+model, endpoint, or interpretation rule creates a new protocol version and may
+not overwrite this study.
+
+### Protocol-boundary clarification
+
+The acquisition/locking rules below are an operational hardening of the
+existing outcome-blind protocol, not an outcome-driven amendment. They change
+no date, role, feature, label, candidate, hypothesis, estimand, or interpretation
+rule. No declared economic outcome was opened to motivate this clarification:
+in particular, no declared price, quantity, buyer-maker value, class balance,
+feature, label, fit, score, or test result has been inspected. The historical
+coverage-only disclosure above remains the complete exception. An
+implementation that cannot enforce the hardened boundary does not execute this
+protocol.
+
+## Data calendar and completeness
+
+Use the complete Binance Spot daily aggregate-trade archive for both BTCUSDT and
+ETHUSDT on each UTC date:
+
+| UTC date | Frozen role | Permitted use |
+| --- | --- | --- |
+| 2024-01-03 | Train | Feature construction, fitting, train-only thresholds |
+| 2024-01-04 | Validation | Candidate selection only |
+| 2024-01-05 | Primary test | Open once after the selected specification is locked |
+| 2024-01-06 | Replication test | Open with the same locked specification; no refit |
+
+The dates were chosen mechanically as the four adjacent dates immediately after
+the inspected 2024-01-02 development sample, not because of observed economic
+outcomes. Pre-freeze coverage-only inspection does not authorize any calendar
+change. Do not replace a quiet, volatile, missing, inconvenient, or unfavorable
+date.
+
+All eight symbol/date archives must be present, checksum-verified, and complete
+for `[00:00:00Z, 24:00:00Z)`. A missing archive, truncated response, failed
+checksum, row cap, noncontiguous aggregate-trade ID inside a symbol/date, or data
+quality error makes the study `INSUFFICIENT_DATA`. Such a failure is reported;
+it is not repaired by choosing another date. Raw archives remain immutable and
+uncommitted. Normalized data is partitioned by venue, symbol, and UTC date.
+
+Acquisition of all eight archives is **raw-only**. It may verify the exact
+official `CHECKSUM` response, response lengths and hashes, and bounded ZIP
+end-of-central-directory/central-directory metadata for exactly one
+expected-name member and its declared sizes. It must not open, extract, or read
+the CSV member; stream decompressed member bytes; parse even its header; expose
+an economic field; or derive row, ID, timestamp, or class-balance coverage.
+Those operations constitute economic-data opening and belong to the staged
+normalization boundary below. Public `exchangeInfo` may be parsed only for the
+declared symbol's status and exact tick/lot filters, with its exact response and
+response sidecar preserved.
+
+Archive transfer and later CSV normalization must both be streaming and
+byte-bounded. The byte ceilings in the machine-readable protocol are hard
+safety limits, not sampling rules:
+
+- `max_archive_compressed_bytes` bounds each archive ZIP response body while it
+  is transferred; an asserted `Content-Length` does not replace streamed byte
+  accounting.
+- `max_archive_uncompressed_bytes` bounds both the central-directory-declared
+  size and the actual expanded bytes of each sole CSV member. The limit is
+  rechecked while the member is normalized.
+- `max_total_download_bytes` bounds the total immutable raw-evidence bytes
+  accepted for this study. The total includes every retained ZIP body, official
+  `CHECKSUM` body, raw-response sidecar, `exchangeInfo` metadata body and
+  sidecar, and every retained rejected-response prefix and its rejection
+  sidecar. A failed attempt or retry does not reset this total. A
+  content-addressed file is counted once if it is physically retained once;
+  distinct retained copies are counted separately. Derived normalized files,
+  quality reports, and aggregate manifest/checksum indexes are not raw-response
+  evidence and do not enter this ceiling.
+
+The smaller `CHECKSUM`, metadata, and rejected-prefix responses also have fixed
+per-response bounds in the adapter and remain subject to the hard total above.
+Before accepting another raw artifact, the acquisition layer must reserve and
+account for its bounded body and sidecar; no published raw acquisition manifest
+may exceed the total. Crossing any per-response, expanded, or total limit fails
+closed before a research result is produced. Every accepted and rejected raw
+artifact is immutable, byte-counted, hashed, and enumerated by the raw
+acquisition manifest.
+
+## Prospective materialization and lock boundary
+
+The study executes in the following one-way order:
+
+1. Acquire and authenticate all eight raw ZIPs, all eight official `CHECKSUM`
+   responses, and the exact symbol-metadata responses. Publish the immutable raw
+   acquisition manifest without opening any CSV member.
+2. Open, stream-normalize, and quality-check only the train and validation CSV
+   members. Publish an immutable development normalized manifest that binds
+   every normalized part, sidecar, quality artifact, and its raw source.
+3. Select and refit using only those development rows. Persist one lock per
+   symbol, then an aggregate lock that commits the exact bytes and SHA-256 of
+   both symbol locks. Each symbol lock commits its selected specification,
+   development-frame identity, and deterministic final-fit policy; the aggregate
+   lock also commits the frozen
+   protocol/config, raw acquisition manifest, development normalized manifest,
+   and clean real Git revision. Close and `fsync` every lock and digest file and
+   `fsync` its containing directory. The aggregate lock is not durable until
+   all child locks and their directories are durable.
+4. Immediately before the first decompressed CSV byte of every primary or
+   replication archive is read, re-read and re-hash the exact durable aggregate
+   lock and all identities it commits. Only then may that member be
+   stream-normalized and quality-checked. Both untouched dates use the same
+   locked fit and transformation state; there is no reselection, refit,
+   recalibration, threshold change, feature change, or model update after the
+   lock, including between primary and replication.
+5. On success, publish a final normalized manifest covering all eight declared
+   symbol/dates. Only that final manifest may authorize endpoint evaluation and
+   final-bundle publication.
+
+For this boundary, "opened" means the first decompressed byte of a CSV member,
+not a later Parquet scan. Inspecting ZIP directory metadata is not opening the
+member. Merely writing a lock path is not persistence: exact bytes, hashes,
+file descriptors, and containing directories must meet the durability rule
+above before a held-out member-open callback can succeed.
+
+## Timing and continuity
+
+Each symbol/date is a separate continuity segment. Features reset at its first
+trade, labels are censored at its final trade, and neither lookbacks nor labels
+cross midnight or a sequence gap. Exchange event time is only an availability
+proxy; aggregate-trade ID breaks tied timestamps. No local receipt-time claim is
+permitted.
+
+At decision trade `i`, a feature may use `i` and earlier trades from the same
+verified segment. The target is one only when the price at `i + 20` is greater
+than the decision price. The target trade ID and information-end timestamp are
+serialized. The longest 100-trade lookback and 20-trade label tail determine
+feature readiness and right censoring.
+
+## Frozen features, candidates, and selection
+
+The feature set is fixed before acquisition:
+
+- one-trade log return;
+- signed quantity, absolute quantity, and signed-volume imbalance over 5, 20,
+  and 100 trades;
+- trade count and event-time intensity over 50 trades;
+- realized trade-price volatility over 100 trades.
+
+Evaluate, separately for each symbol, the historical-prior classifier,
+unpenalized logistic regression, L2 logistic regression with
+`C in {0.1, 1, 10}`, and shallow decision trees with depth in `{2, 4, 6}` and
+minimum leaf size 40. Median imputation, standardization where applicable, and
+sigmoid calibration are learned only from chronologically earlier rows.
+
+The 2024-01-03 fit predicts 2024-01-04. Mean validation log loss selects one
+candidate per symbol; stable candidate order is the tie breaker. After selection,
+the selected candidate is refit once on 2024-01-03 plus 2024-01-04 using the
+same chronological calibration rule. The selected specification and its hash
+are written to an analysis lock before either test date is evaluated. The same
+locked fit predicts both test dates; there is no update between primary and
+replication tests. All candidate validation rows and all locked-model test rows
+are published.
+
+## Hypotheses and estimands
+
+For each symbol:
+
+- **H0:** the validation-selected model does not reduce held-out log loss versus
+  the historical-prior classifier on the untouched dates.
+- **H1:** the validation-selected model reduces held-out log loss versus the
+  prior on both the primary and replication dates.
+
+The primary estimands are selected-model minus prior log loss for each
+symbol/date and the equal-date-weighted mean across the two test dates for each
+symbol. Negative values favor the selected model. A result is
+`directionally_replicated` only when both date-level point differences are
+negative. Otherwise it is `mixed`, `failed`, or `insufficient_data` according to
+the serialized observations. This status is descriptive and is not a
+significance decision.
+
+Uncertainty uses paired, contiguous 40-trade blocks, resetting at every UTC date.
+The same resampled blocks are used for selected and prior predictions. Report
+2,000 seeded percentile draws for each date and an equal-date-weighted paired
+draw for each symbol. Every interval must contain observations from the two
+nonoverlapping test dates before the aggregate is emitted.
+
+No p-values are computed and no H0 rejection or statistical-significance claim
+is authorized. The two symbol hypotheses are not pooled. Candidate, feature,
+date, and regime diagnostics beyond the endpoints above are secondary and are
+reported without selective omission.
+
+## Stability and failed-result reporting
+
+The run must publish, by symbol and date:
+
+- row counts, UTC bounds, class balance, and all exclusions/censoring;
+- prior and selected-model proper scores and paired loss differences;
+- feature distribution stability using bins fitted on the training date only;
+- validation, primary-test, and replication-test direction consistency;
+- every declared model candidate's validation score;
+- explicit `supported`, `mixed`, `failed`, or `insufficient_data` status.
+
+No date or instrument may disappear because its result is unfavorable. Any
+aggregate row must be accompanied by its component date rows.
+
+If primary or replication normalization, completeness validation, or data
+quality fails after the aggregate lock is durable, the run stops at the first
+deterministic failure and publishes immutable `INSUFFICIENT_DATA` terminal
+evidence. That evidence binds the same protocol/config, clean Git revision, raw
+acquisition manifest, development normalized manifest, per-symbol locks, and
+aggregate lock; it records the failing symbol/date/role, typed reason, retained
+partial evidence hashes, and which later members remained unopened. It contains
+no endpoint result. Its checksum manifest and terminal marker are written last,
+and publication uses a new atomic target followed by directory durability.
+
+The same run identity may only verify and reuse that terminal evidence. It may
+not overwrite or delete it, reopen candidate selection, substitute an input,
+replace a date, relax quality, or continue with a partial aggregate. A source
+fix has a different clean Git revision and therefore a different run identity;
+it still cannot erase the original failed evidence. A failure before locking is
+also reported as `INSUFFICIENT_DATA`, but it cannot create a test-evaluation
+bundle or claim that held-out data was opened under a lock.
+
+## Explicit exclusions and promotion boundary
+
+Aggregate trades contain no contemporaneous bid/ask, depth, cancellation,
+queue, or local receipt clock. Therefore this study must serialize execution,
+fills, P&L, fees-to-alpha conversion, and capacity as `NOT_RUN`. It cannot
+promote a book, fill, latency, execution, or profitability claim.
+
+`FULL_DATA` means only that every byte of every predeclared daily trade archive
+was verified and included for this narrowly defined trade-only study. It does
+not mean full market observability, external validity, or deployable evidence.
+The overall M8 milestone remains incomplete until a separately frozen protocol
+has at least two nonoverlapping, continuous, contemporaneous L2 capture periods
+per reported interval and connects their gap-safe book states to causal research
+and execution artifacts.
+
+## Required immutable outputs
+
+The atomic final bundle must contain the frozen protocol and machine spec,
+per-symbol and aggregate analysis locks, raw acquisition manifest, development
+and final normalized manifests, exact official `CHECKSUM` responses and
+sidecars, exact exchange metadata responses and sidecars, per-date quality
+summary, research/evaluation frames, predictions, candidate comparison, paired
+hypothesis artifact, feature stability, generated report/memo/table, resolved
+configuration, and a clean real Git revision/source-tree identity. The final
+manifest binds all of those exact bytes and hashes. The checksum manifest and
+`_SUCCESS` are written last only after atomic publication and directory
+durability. Corruption, input relocation without matching bytes, a dirty,
+unborn, synthetic, or different source identity, or any incomplete date must
+fail verification and reuse.

Microstructure/docs/PROJECT_PLAN.md

@@ -0,0 +1,135 @@
+# Project plan
+
+## Objective
+
+Answer, with defensible event-time evidence, when order-flow imbalance and
+liquidity conditions predict short-horizon price movement, and how much apparent
+value remains after fees, latency, fill uncertainty, adverse selection, and
+inventory constraints. The system is research-only and has no live-order path.
+
+## Delivery strategy
+
+The first deliverable is one narrow, fully reproducible vertical slice. Broader
+market coverage and more sophisticated models follow only after its contracts,
+timing, and execution accounting are tested.
+
+| Milestone | State | Depends on | Deliverable | Acceptance evidence |
+|---|---|---|---|---|
+| M0 Repository contract | Complete | None | Instructions, plan, decisions, status, packaging | Required files exist; Python 3.12 environment installed; config/provenance tests, Ruff, and mypy pass |
+| M1 Event data foundation | Complete | M0 | Binance trade adapter, optional L2 collector, schemas, manifest/checksum, partitioned Parquet | Mocked retries/metadata/pagination; UTC/schema and content-addressed storage tests pass |
+| M2 Book and quality controls | Complete | M1 | Snapshot/delta replay, sequence validation, quality findings | Gap, overlap, crossed-book, duplicate, ordering, invalid value, spread, silence, and clock tests pass |
+| M3 Leakage-safe dataset | Complete | M1-M2 | Trade-flow/book features and future labels | Causal lineage, future-label, censoring, and gap-isolation tests pass |
+| M4 Model evaluation | Complete | M3 | Baseline, logistic/regularized linear, tree; purged walk-forward evaluation | Prior/unpenalized/L2/tree ladder, calibration, bootstrap, purge, and OOT tests pass |
+| M5 Execution research | Complete | M3-M4 | Market/limit fills, latency, partial fills, costs, inventory, liquidation, sensitivity | Deterministic accounting, OOS, volume-conservation, continuity, partial-fill, and liquidation tests pass |
+| M6 Reproducible vertical slice | Complete | M1-M5 | One CLI-driven sample run and machine-readable artifacts | Atomic producer and corruption/idempotence tests pass; canonical smoke requires no network |
+| M7 Research communication | Complete | M6 | Generated technical report/table, IC memo, limitations, dashboard, portfolio material | Render/dashboard tests read only verified artifacts and visibly label evidence tier |
+| M8 Broader empirical study | In progress | M6-M7 | Closed trade-only study plus complete software for the replacement four-date live-L2 capture/analysis campaign | Canonical trade and superseded L2-v1 authorities remain immutable; capture Aug 10--13 under one new campaign authority, publish the Aug 10/11 `LOCKED` or `NOT_CREATED` development authority before Aug 12, and publish a recursively verified result or protocol-declared insufficiency |
+
+## First vertical slice
+
+```text
+small documented event fixture
+  -> normalized partitioned Parquet + manifest
+  -> explicit data-quality findings
+  -> causal trade-flow / liquidity-state features
+  -> strictly future return and direction labels
+  -> purged walk-forward baseline, logistic, and tree models
+  -> latency- and cost-aware simulation
+  -> JSON/CSV/Markdown run artifacts and dashboard inputs
+```
+
+The offline fixture is an explicitly synthetic smoke test for software
+reproducibility, not empirical market evidence. `make download-sample` adds a
+small public-data path without making the test suite depend on network access.
+
+## Dependencies
+
+- Python 3.12; Polars/PyArrow for bounded-memory transformation and Parquet.
+- DuckDB for partition inspection and aggregation.
+- scikit-learn for transparent, CPU-friendly models and calibration.
+- pytest, Ruff, and mypy for verification.
+- Streamlit for a local read-only research dashboard.
+- Public Binance market-data endpoints only; no API key or account connection.
+
+## Risks and mitigations
+
+| Risk | Consequence | Mitigation / acceptance test |
+|---|---|---|
+| Snapshot/delta mismatch or sequence gap | Corrupt book state and false imbalance | Halt the affected segment, emit a finding, require a new snapshot; replay gap tests |
+| Exchange timestamp is not local observability | Optimistic latency and feature timing | Retain event and receipt times; model configurable decision/order latency |
+| Trade-only fixture cannot identify queue dynamics | Fill estimates are assumption-driven | Label fill results as proxy-based; keep book model interface separate |
+| Overlapping horizons leak across folds | Inflated validation estimates | Purge by label end time plus optional embargo; boundary tests |
+| Small/nonstationary sample | Unstable or meaningless inference | Report uncertainty and evidence tier; defer economic claims until M8 |
+| Class imbalance/calibration drift | Misleading probabilities | Persist class rates, Brier/log loss, calibration diagnostics by fold/regime |
+| Fee/latency/fill assumptions dominate P&L | Fragile strategy result | Publish assumption grid and sensitivity; never collapse it into model quality |
+| Public endpoint/schema changes | Broken ingestion | Version adapter/schema, capture response metadata/checksum, contract tests |
+| Memory/disk pressure | Local run failure | Byte-bounded response streams, hard retained-evidence reservations, disk-backed incremental DQ, batch Parquet, verified spill-capable scans, explicit eager guards; measure peak RSS on any successful full L2 production before promotion |
+| Multiple testing | False discoveries | Predeclare core hypotheses, report all tested variants, use adjusted interpretation |
+| Missed or invalid prospective L2 session | Outcome-driven replacement or false continuity | One frozen calendar and campaign identity; atomic `INSUFFICIENT_DATA`; no replacement date; require observed-interval and cross-symbol coverage gates |
+| Source/runtime/root changes across the four captures | Sessions are not one prospective campaign | Root campaign authority binds config/protocol, outcome-blind nonce, canonical output-root filesystem identity, clean source/import origin, and hashed Python/platform/dependency runtime; reject drift before network access |
+| Held-out L2 economic access without a development authority | Selection leakage | Verify Aug 10/11 control authorities and first persist either eight child locks plus one aggregate `LOCKED` authority or a control-only `NOT_CREATED` authority; only the `LOCKED` branch may expose Aug 12/13 frames, and its evaluator has no fit path |
+
+## Acceptance test matrix
+
+1. **Reproduction:** a clean environment follows `README.md`, runs
+   `make reproduce-sample`, and receives a run directory with provenance,
+   validation, folds, metrics, trades, sensitivities, and reports.
+2. **Data:** normalization is deterministic; timestamps are UTC; manifest hashes
+   match bytes on disk; Parquet is partitioned by source/symbol/date.
+3. **Book:** snapshot-plus-delta replay enforces side sorting, nonnegative depth,
+   sequence continuity, and uncrossed top of book.
+4. **Timing:** deliberately shifted future values cause leakage tests to fail;
+   label intervals never enter feature windows or training folds.
+5. **Models:** historical/majority, logistic or regularized linear, and tree models
+   run on identical time folds without selecting on the final test set.
+6. **Execution:** fees, two latency components, fill probability/queue proxy,
+   partial fills, adverse selection, inventory cap, liquidation, turnover, and
+   size/capacity sensitivity are represented and unit tested.
+7. **Reports:** model table and technical report are rendered from serialized
+   results; each carries data interval, config hash, manifests, and Git state.
+8. **Claims:** synthetic and smoke outputs contain an explicit non-empirical
+   banner; no unverified profitability or significance claim is emitted.
+
+## Definition of done
+
+The objective's ten acceptance criteria have reproducible evidence for M0-M7:
+
+1. `README.md` provides a clean setup and reproduction path.
+2. The canonical workflow is deterministic synthetic data and needs no download.
+3. Snapshot/delta sequence, stale/overlap/gap, crossed-book, and invariant tests pass.
+4. Feature/label lineage, strict-before joins, censoring, and deliberate leakage tests pass.
+5. Unpenalized and regularized logistic models plus a shallow tree share frozen OOT folds.
+6. Execution records fees, two latency stages, queue/fill uncertainty, partial fills,
+   adverse selection, inventory, liquidation, turnover, and size sensitivity.
+7. Reports are rendered from serialized, checksum-verified outputs.
+8. Run provenance records actual UTC coverage, config/input hashes, seed, runtime,
+   Git revision, dirty state, and exact tracked/non-ignored source-tree digest.
+9. Synthetic watermarks and claim checks prevent an unverified profitability claim.
+10. Limitations, evidence promotion rules, and the absence of evaluable failed
+    hypotheses are documented.
+
+Passing M0-M7 completes the portfolio-quality system and first vertical slice.
+M8 remains the active empirical milestone. Its prospective calendar,
+hypotheses, selection rule, untouched tests, uncertainty, failure policy, and
+lock-before-open boundary are frozen in
+`docs/M8_MULTIDATE_TRADE_PROTOCOL.md`. The raw-only acquirer and terminal
+producer are implemented and adversarially tested. All eight full daily archives
+and their official evidence are bound by one verified raw-only manifest, without
+opening a CSV member during acquisition. The subsequent clean-commit economic
+run reached a verified `INSUFFICIENT_DATA` terminal at the ETHUSDT training DQ
+gate: no selection or held-out member access occurred, so the trade hypothesis
+was not evaluated and the date/policy cannot be replaced.
+
+Book claims now depend on the separately frozen live-L2 campaign. The immutable
+capture rules are in `docs/M8_L2_PROTOCOL.md`; the exhaustive downstream rules
+and their exact source/semantic hashes are in
+`docs/M8_L2_ANALYSIS_CONTRACT.md`. Remaining acceptance evidence is: the four
+exact session terminals sharing one clean campaign authority; a durable
+`LOCKED | NOT_CREATED` development authority before held-out access; unchanged
+no-refit evaluation on the `LOCKED` branch;
+generated descriptive/predictive/execution artifacts or an honest
+`INSUFFICIENT_DATA` terminal; peak-RSS evidence below the local ceiling; and
+clean-room reproduction. The producer, recursive verifier, CLI/Make interfaces,
+self-contained authority snapshots, and external non-mutating report renderer
+are implemented and covered by offline tests. The existing public sample remains
+exploratory only.

Microstructure/docs/PUBLICATION.md

@@ -0,0 +1,29 @@
+# Publication policy
+
+## Approved public scope
+
+The Git-reachable source history is approved for public release under the MIT
+License. The release includes source code, tests, configuration, documentation,
+and small non-market fixtures or placeholders only.
+
+Ignored local exchange data, normalized and derived tables, fitted states,
+ingestion authorities, generated dashboards, and run artifacts are excluded.
+The detailed boundary is recorded in [DATA_POLICY.md](DATA_POLICY.md).
+
+## Evidence language
+
+- `SYNTHETIC_SMOKE` verifies software behavior only.
+- `PUBLIC_SAMPLE_PARTIAL` supports bounded pipeline observations, not persistent
+  alpha, profitability, or capacity claims.
+- The frozen trade-only M8 study ended at `INSUFFICIENT_DATA` after a predeclared
+  zero-warning gate failed. Selection, held-out evaluation, execution, and P&L
+  did not run.
+- Superseded campaign calendars remain historical records and are not presented
+  as current authority.
+
+## Permanent destinations
+
+- Website: <https://yangxiaoshawn.github.io/projects/microstructure/>
+- GitHub: <https://github.com/YangXiaoShawn/open-economic-quant-microstructure>
+- Dataset mirror: <https://huggingface.co/datasets/ShawnChamberlain/open-economic-quant-research-data/tree/main/Microstructure>
+- Interactive Space: <https://huggingface.co/spaces/ShawnChamberlain/open-economic-quant-research-observatory>

Microstructure/docs/PUBLIC_TRADE_PROTOCOL.md

@@ -0,0 +1,99 @@
+# Public aggregate-trade exploratory protocol
+
+## Evidence status
+
+This protocol governs the first real-data research run built from the fixed,
+capped Binance Spot aggregate-trade sample already acquired for 2024-01-02. It
+is **retrospective and exploratory**, not a preregistered confirmatory study. The
+data availability, per-symbol coverage, and class balance were inspected before
+this document was frozen; model comparison and held-out results were not.
+
+Every output must retain the `PUBLIC_SAMPLE_PARTIAL` evidence tier. The run may
+support a sample-specific data and predictability diagnostic, but it cannot
+support a claim about persistent alpha, statistical significance, execution,
+profitability, or capacity.
+
+## Question and hypotheses
+
+The narrow question is whether recently observed aggregate-trade direction and
+size contain out-of-time information about the sign of the trade price 20
+aggregate trades later.
+
+- **H0:** the transparent model ladder does not improve held-out log loss over a
+  historical-prior classifier in this capped sample.
+- **H1 (exploratory):** causal signed-volume and trade-imbalance features improve
+  held-out log loss relative to that prior.
+
+All tested model rows are published. The final test is not used for feature,
+hyperparameter, calibration, or model selection. A favorable point estimate is
+not called significant; the block bootstrap is a dependence diagnostic, not a
+confirmatory p-value procedure.
+
+## Data and coverage policy
+
+- Instruments are BTCUSDT and ETHUSDT, evaluated separately because the fixed
+  5,000-row caps produce different observed clock-time endpoints.
+- The exact ingestion manifest and normalized part hashes are inputs to the run.
+- Internal aggregate-trade IDs must be unique and step by one within each symbol;
+  the availability clock must not reverse. Only after those checks may the
+  derived research view assign one continuity epoch per symbol. Raw normalized
+  rows remain unchanged.
+- Exchange event time is the only historical availability proxy. No local
+  receipt-time or colocated-latency claim is allowed.
+- Tied exchange timestamps retain aggregate-trade-ID ordering and remain in the
+  same time split.
+
+## Causal feature and label contract
+
+At decision trade `i`, features may use trade `i` and earlier trades from the
+same verified continuity epoch:
+
+- signed trade volume and absolute volume over 5, 20, and 100 trades;
+- signed-volume imbalance over the same windows;
+- trade count and event-time intensity;
+- one-trade log return;
+- realized trade-price volatility over 100 trades.
+
+The target is `1` when the trade price at `i + 20` is above the price at `i`, and
+`0` otherwise. The target trade ID and availability timestamp are serialized.
+Segment tails are right-censored. Feature-ready rows require the full longest
+lookback.
+
+## Evaluation
+
+- Each instrument receives its own expanding time-ordered walk-forward plan.
+- Configuration: 1,200 initial decision-time buckets, 400 validation buckets,
+  400 final-test buckets, 400-bucket steps, and a 20-bucket embargo.
+- Label information ending at or after an evaluation boundary is purged.
+- The model ladder is historical prior, unpenalized logistic regression, the
+  declared L2 grid, and the declared shallow-tree grid.
+- Selection metric is validation log loss. Calibration is trained only from the
+  chronological training/calibration region.
+- The primary H0/H1 diagnostic is the paired difference in held-out log loss:
+  validation-selected model minus historical prior on identical `row_id`
+  observations. It uses the same seeded resample draw for both models within
+  each fixed, contiguous 40-trade block (twice the label horizon), separately
+  by instrument. Five hundred draws, the seed, row count, block count, point
+  difference, and percentile interval are serialized. Marginal per-model
+  intervals are secondary and are never compared as a substitute for the
+  paired loss difference.
+
+## Explicit exclusions
+
+There is no contemporaneous bid/ask, depth, cancellation, queue, or local
+receipt-time history in this dataset. Therefore this run does not calculate:
+
+- order-book imbalance, microprice, spread, or liquidity recovery;
+- limit-fill probability or queue position;
+- market/limit execution, fees-to-alpha conversion, P&L, or capacity.
+
+Those analyses require continuous snapshot-plus-delta L2 epochs collected and
+validated separately.
+
+## Promotion criteria
+
+This exploratory run cannot be promoted to `FULL_DATA`. A later confirmatory
+study must freeze its protocol before model outcomes are inspected, use multiple
+complete nontruncated dates, preserve adjacent untouched dates for final testing,
+report per-date and cross-instrument stability, and add continuous L2 evidence
+before making book-dependent or execution claims.

Microstructure/docs/RESEARCH_PROTOCOL.md

@@ -0,0 +1,129 @@
+# Research protocol
+
+## Question and estimands
+
+The primary question is not whether a classifier can fit event data. It is
+whether an order-flow or liquidity signal predicts a strictly future price state
+out of time, whether that relationship is stable across symbols and regimes, and
+whether its scale exceeds execution frictions under declared—not inferred—fill
+assumptions.
+
+The primary predictive estimands are:
+
+1. the change in future mid-price direction probability associated with a
+   one-standard-deviation change in causal order-flow imbalance;
+2. the conditional future log-mid return across predeclared event horizons;
+3. the decay of that relationship as the horizon increases;
+4. the interaction of order flow with contemporaneous spread, depth, volatility,
+   and trade intensity.
+
+Economic evaluation is a separate conditional exercise: given frozen OOS
+predictions and a declared execution model, measure gross edge, explicit fees,
+arrival cost, post-fill adverse selection, fill fraction, turnover, inventory,
+and marked or liquidated net P&L. It is not an estimate of deployable capacity.
+
+## Predeclared core hypotheses
+
+- **H1 — Order-flow direction:** positive trailing signed flow and L1 OFI are
+  associated with positive strictly future mid returns, and vice versa.
+- **H2 — Decay:** predictive association is strongest at short horizons and
+  decays rather than monotonically increasing with horizon.
+- **H3 — Liquidity interaction:** a given flow shock has larger price impact when
+  displayed depth is low or relative spread/volatility is high.
+- **H4 — Recovery:** after a large signed trade or spread/depth shock, liquidity
+  recovery time varies with the pre-shock volatility/liquidity regime.
+- **H5 — Stability:** effect direction is not assumed transferable; BTCUSDT and
+  ETHUSDT are reported separately before any pooled conclusion.
+
+Rejecting or failing to support a hypothesis is a valid result and belongs in
+the generated report. Synthetic smoke data cannot support or reject any market
+hypothesis; it can only verify that the estimands and controls are computed.
+
+## Descriptive analysis contract
+
+The run producer persists intraday liquidity, OFI/return association, signal
+decay and half-life, event-time signed impact, large-trade impact, liquidity
+recovery, market regimes, model diagnostics by regime, cross-instrument effect
+stability, and train-versus-test feature stability. Large-trade, shock, recovery,
+and regime thresholds are fitted on the final training rows only and serialized.
+These outputs carry `descriptive_only=true`; synthetic values cannot support or
+reject the hypotheses above.
+
+## Information set
+
+A decision sample is keyed by `(available_ts_ns, sequence, event_id)` within a
+continuous segment. A source timestamp is only an availability proxy unless a
+local receipt timestamp exists. Features use observations whose availability key
+is no later than the decision key. Labels start after the decision and end at
+their persisted information-end key. No feature, label, or fold crosses a known
+feed gap.
+
+Tied observations from different streams have no assumed causal ordering unless
+the source supplies one. As-of joins therefore use the last strictly observable
+state. Missing future targets are right-censored; they are never filled with the
+last observation.
+
+## Evaluation protocol
+
+- Splits follow global UTC/event order with expanding training windows.
+- Training observations whose label interval overlaps the next evaluation
+  boundary are purged; a configured embargo adds separation.
+- Imputation, scaling, regime thresholds, feature selection, calibration, and
+  hyperparameter choice use training/calibration/validation data only.
+- The final held-out period is evaluated once after model choice is frozen.
+- Baseline, unpenalized/regularized linear, and shallow tree models share the same
+  features, folds, and final test observations.
+- Classification reporting includes class support, log loss, Brier score,
+  ROC-AUC when defined, accuracy/balanced accuracy, and calibration diagnostics.
+- Return models, when supported, report MAE and rank correlation without treating
+  statistical fit as tradable value.
+- Dependent uncertainty uses contiguous event or UTC-day blocks. Fewer than two
+  independent blocks produces an `insufficient_blocks` result rather than a
+  confidence interval.
+
+## Multiple testing and model selection
+
+The core family is the two symbols × predeclared horizons × core OFI association.
+Exploratory regimes, feature variants, model variants, and sensitivity grids are
+reported as exploratory and are not promoted to confirmatory evidence. Where
+p-values are later added for a full-data study, false-discovery-rate adjustment
+is applied within the declared family and both raw and adjusted values are kept.
+
+Models are selected on aggregate validation log loss (classification) or MAE
+(regression). Prefer the simpler model when performance is statistically
+indistinguishable under the predeclared rule. The final test cannot change the
+model, signal threshold, calibration, size, latency, or fee assumption.
+
+The frozen trade-only public protocol is narrower and is specified separately
+in `docs/PUBLIC_TRADE_PROTOCOL.md`. It evaluates each symbol independently and
+uses the same held-out rows and identical contiguous bootstrap draws for the
+validation-selected model-minus-historical-prior log-loss difference. Marginal
+model intervals are not substituted for that paired estimand. Because the input
+has no contemporaneous book, execution, fill, P&L, and capacity artifacts are
+serialized as `NOT_RUN`, not zero.
+
+## Execution scenarios
+
+Base market orders use the book observable at order-arrival time after separate
+decision and order latencies. Available L1 depth caps fills; missing deeper depth
+is not extrapolated. Passive orders join behind a declared queue proxy, fill only
+against eligible opposing printed flow, can fill partially, and remain exposed
+during cancel latency. Maker/taker fees, inventory caps, and end liquidation are
+explicit.
+
+Latency, queue position, cancellation ordering, and endogenous impact are not
+identified by archived exchange data. They are scenario inputs and must be shown
+as sensitivity axes. A strategy that works only under the most favorable fill or
+latency scenario fails the economic robustness test.
+
+## Promotion criteria for empirical claims
+
+No market conclusion may appear in “main findings” until a manifested public or
+institutional data run has:
+
+- at least two non-overlapping UTC dates per reported confidence interval;
+- a frozen final test period not used for selection;
+- acceptable sequence/data-quality coverage for every book-based feature;
+- results for both default instruments or an explicit single-instrument scope;
+- cost/latency/fill sensitivity and failed-hypothesis disclosure;
+- a clean evidence label, config hash, input checksums, and Git state.

Microstructure/portfolio/interview_story.md

@@ -0,0 +1,125 @@
+# Interview story: Order Flow to Price Impact
+
+> **Historical calendar note (2026-08-23):** Any Aug 8–11 live-L2 schedule in
+> this narrative is superseded by the v2 Aug 10–13 protocol recorded in the
+> README and `docs/M8_L2_ANALYSIS_CONTRACT.md`. It is retained as research
+> history, not current campaign authority.
+
+## One-sentence version
+
+I designed a reproducibility-first market-microstructure research system that
+keeps leakage-safe prediction, execution assumptions, and simulated performance
+separate—and refuses to turn synthetic smoke output into an alpha claim.
+
+## The problem
+
+Short-horizon market prediction is unusually easy to overstate. Events are
+serially dependent, labels overlap, exchange time is not necessarily receipt
+time, and an accurate forecast can still be untradeable after spread, fees,
+latency, queue uncertainty, adverse selection, and inventory liquidation. Public
+data also varies in depth and quality, while the target machine has 16 GB of RAM
+and no paid data feed.
+
+The research question therefore had two parts: under what observable conditions
+does order flow predict a future price change, and how much of that relationship
+survives a separately specified execution model?
+
+## My approach
+
+I organized the project around immutable event and run contracts rather than a
+large notebook. Raw observations remain unchanged. Normalized timestamps and
+sequence identifiers make ordering explicit. Features stop at decision event
+`t`; labels begin after `t`. Time-ordered folds purge overlapping label horizons
+and apply an embargo before held-out evaluation.
+
+The model ladder begins with a historical or majority baseline, then transparent
+linear and regularized alternatives, followed by bounded nonlinear models. The
+execution layer records fees, two latency components, fill and queue proxies,
+partial fills, adverse selection, inventory limits, liquidation, turnover, and
+size sensitivity independently of predictive metrics.
+
+Each run freezes its resolved configuration, input checksums, actual UTC period,
+random seed, runtime, and Git state. Reports and the read-only Streamlit dashboard
+consume that bundle; they cannot retrain a preferred model. Synthetic input
+forces a prominent software-test watermark everywhere.
+
+## A difficult design choice
+
+The initial compact data path may contain trades without complete historical
+depth. It would have been easy to present a precise-looking queue simulator, but
+the data cannot identify true queue priority. I treated queue position and fills
+as explicit assumptions, kept the interface replaceable by later Level-2 data,
+and made sensitivity—not a single fill estimate—the relevant output.
+
+That decision reduced the apparent sophistication of the first result while
+making the inference more honest.
+
+## Verification strategy
+
+The offline smoke path is deterministic and network-free. Focused tests cover
+bundle completion, checksum integrity, evidence-tier consistency, synthetic
+watermarks, held-out-only comparison tables, deterministic rendering, and clear
+dashboard failures for incomplete runs. Research tests separately target event
+ordering, leakage, purged folds, fee accounting, latency, partial fills, and
+inventory constraints.
+
+## What the empirical work actually produced
+
+The capped public trade sample remained exploratory and explicitly skipped
+execution because it had no contemporaneous book. The predeclared full-archive
+trade study then produced a useful negative operational result: BTCUSDT training
+data passed, while ETHUSDT training data produced 53 long-silence warnings
+against a zero-warning gate. The pipeline published a checksummed
+`INSUFFICIENT_DATA` terminal before selection and before either held-out date was
+opened. I did not relax the rule, substitute a date, or describe the absence of
+a model result as a failed market hypothesis.
+
+For the book extension I froze four simultaneous BTCUSDT/ETHUSDT sessions and a
+field-complete analysis contract before capture. The implementation binds all
+dates to one outcome-blind campaign, clean source/import/runtime identity, and
+canonical storage root; limits features and labels to verified observed
+intervals; locks the Aug 8/9 development state before Aug 10/11; and provides
+no-refit evaluation and market-only scenarios. The final producer recursively
+verifies explicit path and digest authorities, snapshots them into an immutable
+terminal, and renders reports externally without changing the run. Those are
+software controls, not empirical L2 evidence: at the pre-capture source freeze,
+no declared L2 result had been promoted. Tracked source remains unchanged during
+the four-session campaign; immutable session/final bundles carry live status.
+
+## Evidence boundary
+
+No empirical economic result is claimed merely because a pipeline ran. A
+synthetic smoke run proves only that the software contracts and accounting
+execute as intended. The bounded public trade run supports exploratory,
+interval-specific diagnostics but no execution or broad claim. The canonical
+full-archive result supports only data insufficiency because evaluation never
+began. Generalization still requires valid adjacent periods, both instruments,
+regimes, uncertainty, and transparent failed hypotheses.
+
+## What I would do next
+
+I would operate the completed producer on the already-frozen Aug 8--11 sessions
+without changing their calendar or analysis contract, then complete the
+clean-room and peak-memory audits on the resulting terminal. Aug 8/9 choices
+must be durably locked before Aug 10/11 data is exposed. I would accept a missed
+or invalid session as `INSUFFICIENT_DATA`, not search for a replacement. Only
+after stable no-refit evidence would I consider point-process models; the
+criterion for complexity would be out-of-time economic evidence, not an improved
+in-sample score.
+
+## Likely follow-up questions
+
+**Why not random cross-validation?** It mixes regimes and leaks information across
+overlapping future horizons. Walk-forward folds better match deployment order.
+
+**Why report calibration?** Thresholded execution decisions consume
+probabilities, so ranking alone is insufficient. Miscalibration changes trade
+frequency, inventory, and cost exposure.
+
+**What would make you stop?** Leakage, an invalid book reconstruction, failure on
+the untouched period, instability without an economic explanation, or economics
+that require implausible fills or latency.
+
+**What makes this portfolio-quality?** The result is auditable: assumptions,
+failures, provenance, and evidence boundaries are first-class artifacts rather
+than caveats added after seeing performance.

Microstructure/portfolio/resume_bullets.md

@@ -0,0 +1,26 @@
+# Resume bullet variants
+
+These bullets intentionally make no unverified claim about alpha, profitability,
+statistical significance, throughput, or data volume. Add a measured result only
+after a checksum-verified public-data run supports it.
+
+## Research-focused
+
+- Designed a leakage-aware event-time market-microstructure study of order-flow
+  imbalance, liquidity state, future price impact, and recovery, using purged
+  walk-forward evaluation, calibrated baselines, uncertainty, and explicit
+  evidence tiers to separate synthetic tests from empirical findings.
+
+## Quant-trading-focused
+
+- Built a research-only signal-to-execution framework that separates predictive
+  diagnostics from fee-, latency-, fill-, adverse-selection-, inventory-, and
+  liquidation-aware simulation, with gross-to-net and capacity sensitivities
+  designed to falsify fragile short-horizon strategies.
+
+## Data-engineering-focused
+
+- Engineered a reproducible Python 3.12 microstructure platform around typed
+  configuration, immutable manifests, UTC event ordering, partitioned columnar
+  data, checksummed run bundles, deterministic reports, and a read-only Streamlit
+  dashboard suitable for bounded-memory local analysis.

Microstructure/portfolio/ten_minute_presentation_outline.md

@@ -0,0 +1,89 @@
+# Ten-minute presentation outline
+
+> **Historical calendar note (2026-08-23):** Any Aug 8–11 live-L2 schedule in
+> this outline is superseded by the v2 Aug 10–13 protocol recorded in the
+> README and `docs/M8_L2_ANALYSIS_CONTRACT.md`. It is retained as research
+> history, not current campaign authority.
+
+## 0:00–0:50 — The question and the trap
+
+- Ask when order-flow imbalance and liquidity predict a strictly future move.
+- Then ask whether the effect survives costs and uncertain execution.
+- State the central trap: predictability, executability, and profitability are
+  different claims.
+
+## 0:50–1:50 — Evidence hierarchy
+
+- `SYNTHETIC_SMOKE`: software behavior only.
+- `PUBLIC_SAMPLE_PARTIAL`: fixed interval, limited inference.
+- `FULL_DATA`: broader manifested study, still simulated and venue-specific.
+- `INSUFFICIENT_DATA`: a declared gate prevented evaluation; no missing estimate
+  is replaced with zero or a substitute date.
+- Pre-capture source-freeze status: synthetic vertical slice and bounded public trade
+  study completed at their stated tiers; full-archive trade M8 stopped on 53
+  ETHUSDT training warnings before selection or held-out access; no performance
+  claim and no promoted L2 result.
+
+## 1:50–3:05 — Event-driven data architecture
+
+- Public trades and optional Level-2 snapshot/delta adapters.
+- UTC nanoseconds plus sequence/event identifiers establish stable order.
+- Streaming normalization and partitioned Parquet keep memory bounded.
+- Manifests retain source, actual period, schema version, row counts, and hashes.
+
+## 3:05–4:15 — Data quality and leakage controls
+
+- Detect duplicates, ordering and sequence gaps, crossed books, invalid values,
+  abnormal spreads, silence, and clock discontinuities without silent repair.
+- Features use observations available through decision event `t`; labels start
+  after `t`.
+- Use expanding walk-forward folds with purge and embargo for overlapping labels.
+
+## 4:15–5:30 — Economic features and model ladder
+
+- Spread, depth, OFI, queue imbalance, microprice, signed volume, intensity,
+  volatility, impact, recovery, and regimes when observable.
+- Compare historical/majority, linear or logistic, regularized, and tree models.
+- Select on validation only; report calibration and uncertainty on held-out data.
+
+## 5:30–6:55 — From prediction to execution
+
+- Keep model metrics and execution artifacts separate.
+- Record maker/taker fees, decision and order latency, market versus limit fills,
+  queue proxy, partial fills, adverse selection, inventory cap, and liquidation.
+- Show gross-to-net and fee/fill/latency/size sensitivity rather than one favored
+  P&L number.
+
+## 6:55–8:05 — Reproducibility and reporting
+
+- One frozen run bundle records resolved config, input hashes, actual UTC period,
+  seed, runtime, Git commit or `UNBORN`, and dirty state.
+- Checksums plus exact `_SUCCESS` or typed `INSUFFICIENT_DATA` markers prevent
+  readers from treating partial output as a terminal bundle.
+- Technical report, model table, IC memo, and Streamlit app read frozen artifacts;
+  they do not retrain or backfill missing metrics.
+- The four-date L2 path adds an outcome-blind campaign/runtime/storage identity,
+  explicit session/lock/run digests, recursive verification, and external report
+  rendering that never mutates the empirical bundle.
+
+## 8:05–9:10 — What would count as evidence?
+
+- Stable held-out effect across BTCUSDT and ETHUSDT, adjacent periods, and regimes.
+- Calibration and uncertainty, not ROC-AUC alone.
+- Net economics robust to defensible fees, latency, fills, and liquidation.
+- Transparent failures and multiplicity-aware interpretation.
+- For frozen L2: one clean campaign identity, valid simultaneous observed
+  intervals, and an Aug 8/9 `LOCKED | NOT_CREATED` development authority that
+  predates all Aug 10/11 access; only `LOCKED` permits economic-frame access.
+
+## 9:10–10:00 — Limitations and next experiment
+
+- Public event time, queue visibility, hidden liquidity, and venue generalization
+  remain limitations.
+- Next: use the completed frozen L2 producer to capture only the Aug 8--11
+  simultaneous sessions, then run all four horizons without refit or a
+  replacement date and complete peak-memory/clean-room verification. Market-only
+  scenarios are not realized execution; capacity and profitability claims
+  remain forbidden.
+- Close with the governance boundary: research and simulation only; no live-order
+  path.

Microstructure/project.yaml

@@ -0,0 +1,45 @@
+title: Order Flow to Price Impact
+slug: microstructure
+summary: Reproducibility-first market-microstructure research that separates data quality, leakage-safe prediction, execution assumptions, and simulated outcomes.
+research_question: When do order-flow imbalance, liquidity, and limit-order-book conditions predict short-horizon price movement, and which claims survive predeclared data-quality and execution gates?
+why_it_matters: Short-horizon market research is easy to overstate. The project makes observability, temporal leakage, data gaps, fees, latency, uncertain fills, adverse selection, and inventory risk explicit before any economic claim is promoted.
+research_fields:
+  - Market microstructure
+  - Quantitative finance
+  - Time-series machine learning
+project_type: empirical-research-system
+status: public-live
+authors:
+  - Repository owner and maintainer
+original_source: Microstructure workspace project
+original_sample_period: Public BTCUSDT and ETHUSDT market-data studies use fixed UTC intervals declared in their protocols; deterministic synthetic fixtures exercise the software path.
+updated_sample_period: The published source snapshot includes the frozen trade-only M8 terminal and the replacement live-L2 protocol through the current repository HEAD.
+data_sources:
+  - Binance Spot public aggregate-trade endpoints and official archive metadata
+  - Optional public live diff-depth and REST snapshots for locally captured L2 sessions
+  - Deterministic synthetic fixtures for software verification
+data_license: No exchange raw observations, normalized events, derived tables, fitted models, or generated run bundles are redistributed. Users obtain public market data independently under provider terms; see docs/DATA_POLICY.md.
+code_license: MIT
+reproduction_command: make reproduce-sample
+expected_runtime: The deterministic synthetic vertical slice is suitable for a local laptop. Public-data and live-L2 studies require independent acquisition, explicit immutable authorities, and substantially more storage and compute.
+outputs:
+  - src/
+  - tests/
+  - configs/
+  - reports/
+  - dashboard/
+  - docs/
+github_url: https://github.com/YangXiaoShawn/open-economic-quant-microstructure
+site_url: https://yangxiaoshawn.github.io/projects/microstructure/
+dataset_url: https://huggingface.co/datasets/ShawnChamberlain/open-economic-quant-research-data/tree/main/Microstructure
+space_url: https://huggingface.co/spaces/ShawnChamberlain/open-economic-quant-research-observatory
+last_updated: 2026-08-23
+limitations: The public package contains code and documentation, not exchange observations or generated run bundles. Synthetic results are software evidence only. The full-archive trade study terminated at a predeclared data-quality gate, so it published no prediction, execution, profit, capacity, or significance claim.
+catalog:
+  field: market-microstructure
+  accent: violet
+  tags:
+    - Market Microstructure
+    - Order Flow
+    - Reproducible Research
+  metric: Predeclared evidence gates

Microstructure/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "event-driven-microstructure"
+version = "0.1.0"
+description = "Research-only event-driven order-flow and price-impact platform"
+readme = "README.md"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+authors = [{ name = "Microstructure Research Project" }]
+dependencies = [
+  "duckdb>=1.1,<2",
+  "numpy>=2,<3",
+  "polars>=1.20,<2",
+  "pyarrow>=18,<24",
+  "requests>=2.32,<3",
+  "scikit-learn>=1.5,<2",
+  "streamlit>=1.40,<2",
+  "websockets>=14,<17",
+]
+
+[project.optional-dependencies]
+dev = [
+  "mypy>=1.13,<2",
+  "pytest>=8.3,<10",
+  "pytest-cov>=6,<8",
+  "ruff>=0.8,<1",
+  "types-requests>=2.32,<3",
+]
+
+[project.scripts]
+microstructure = "microstructure.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/microstructure"]
+
+[tool.pytest.ini_options]
+addopts = "-ra --strict-markers --strict-config"
+testpaths = ["tests"]
+markers = [
+  "integration: exercises more than one package boundary",
+]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 100
+src = ["src", "tests", "dashboard"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP", "SIM", "RUF"]
+ignore = ["E501"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = ["S101"]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+packages = ["microstructure"]
+warn_unreachable = true

Microstructure/reports/executive_memo.md

@@ -0,0 +1,95 @@
+# Investment committee research memo
+
+> **STATUS: SOURCE-CONTROLLED GOVERNANCE MEMO — RUN-SPECIFIC MEMOS ARE GENERATED BY CODE**
+
+> **Historical calendar note (2026-08-23):** Any Aug 8–11 live-L2 schedule in
+> this memo is superseded by the v2 Aug 10–13 protocol recorded in the README
+> and `docs/M8_L2_ANALYSIS_CONTRACT.md`. It is retained as research history, not
+> current campaign authority.
+
+## Page 1 — Decision and current evidence
+
+**Recommendation:** Continue research construction only. Authorize no capital
+allocation, live trading, or connection to an account capable of placing orders.
+
+**Decision requested.** The proposed research asks whether order-flow imbalance
+and liquidity state forecast short-horizon price movements and, separately,
+whether any measured effect can survive realistic implementation frictions. The
+decision today is not whether to trade a strategy. It is whether the research
+design is sufficiently falsifiable, reproducible, and execution-aware to finish
+the frozen four-session live-L2 campaign without changing its specification.
+
+**Current evidence.** The completed synthetic vertical slice supports a software
+reproducibility claim only. The bounded public acquisition supports a data-
+pipeline observation plus exploratory per-symbol diagnostics only: both symbol
+ranges reached their declared row cap, and execution was `NOT_RUN`. The complete-
+archive trade study reached a valid `INSUFFICIENT_DATA` terminal when ETHUSDT
+training normalization produced 53 warnings against a zero-warning gate.
+Selection never started and neither held-out date was opened. This is a supported
+data-insufficiency conclusion, not an economic-model result. There is no
+supported simulated return, capacity, profitability, or statistical-significance
+claim. This source document therefore contains no substituted performance
+figures; run-specific memos are rendered from frozen artifacts.
+
+**Required analytical separation.** The work will preserve three distinct layers.
+First, predictive quality asks whether features observable at decision time
+forecast strictly future labels on time-ordered held-out data. Second, economic
+stability asks whether the relationship persists across horizons, instruments,
+and liquidity or volatility regimes. Third, execution research applies fees,
+spread, decision and order latency, uncertain or partial fills, adverse
+selection, inventory constraints, liquidation, turnover, and size sensitivity.
+Success in one layer does not establish success in another.
+
+**Evidence standard.** Model selection must use training and validation periods,
+with purging and embargo where labels overlap. Final test results remain untouched
+until specifications are fixed. Reports must identify every tested model or
+sensitivity relevant to interpretation, include uncertainty, and avoid presenting
+an isolated favorable specification. Every published number must trace to a
+checksum-verified bundle containing actual UTC coverage, configuration and input
+hashes, code state, and evidence tier.
+
+<div style="page-break-after: always;"></div>
+
+## Page 2 — Risks, kill criteria, and next evidence
+
+**Principal risks.** Exchange timestamps may not represent local observability.
+Public trade data may be adequate for signed-flow research but cannot reveal true
+queue position, hidden liquidity, or cancellation priority. Snapshot and delta
+gaps can corrupt reconstructed books. A short or selected interval can confound
+signal with regime. Repeated features, horizons, and thresholds create
+multiple-testing risk. Fee, latency, fill, and liquidation assumptions can
+dominate simulated results. Venue-specific cryptocurrency behavior may not
+generalize to institutional instruments or other matching engines.
+
+**Controls.** Preserve raw events; emit validation findings without silent repair;
+make ordering and label boundaries explicit; persist fold definitions; compare
+against simple baselines; calibrate probabilities; report bootstrap intervals;
+and show results by regime and instrument. Execution assumptions must be
+configuration-controlled and shown alongside gross-to-net attribution. The
+dashboard must read frozen, bounded artifacts and cannot trigger trading or
+recompute a preferred result. The four L2 sessions must share one clean
+campaign, runtime/import fingerprint, and canonical storage-root identity. Every
+development/final command consumes explicit path plus manifest/checksum/lock
+authorities. Reports are re-rendered outside the immutable run only after
+recursive verification.
+
+**Kill criteria.** Do not escalate the research if a result depends on future
+information, fails sequence or checksum validation, disappears on the untouched
+test period, reverses across instruments or adjacent periods without an economic
+explanation, requires implausibly favorable latency or fills, or fails to remain
+competitive with the declared baseline after recorded costs. A high predictive
+score without calibration or executable economics is also insufficient.
+
+**Next evidence requested.** Preserve the trade insufficiency terminal without a
+replacement date or relaxed quality rule. Use the completed frozen
+BTCUSDT/ETHUSDT live-L2 software path to collect only the declared Aug 8--11 UTC
+sessions under one clean campaign identity. Publish every session gate and
+quality exception; lock Aug 8/9 model, regime, calibration, and execution-
+reference state before either Aug 10/11 frame is opened; then publish all
+predeclared horizons, dependency-block uncertainty, equal-session stability,
+market-only sensitivity scenarios, failed hypotheses, and remaining
+limitations—or publish `INSUFFICIENT_DATA` if a declared gate fails. At this
+pre-capture source freeze, no L2 data or metric had been promoted; the tracked
+memo remains unchanged during the campaign. Only after those checks should the
+committee consider broader research. Live deployment remains outside scope
+regardless of the outcome.

Microstructure/reports/methodology_limitations.md

@@ -0,0 +1,189 @@
+# Methodology and limitations
+
+> **Historical calendar note (2026-08-23):** Any Aug 8–11 live-L2 schedule in
+> this document is superseded by the v2 Aug 10–13 protocol recorded in the
+> README and `docs/M8_L2_ANALYSIS_CONTRACT.md`. It is retained as research
+> history, not current campaign authority.
+
+## Evidence tiers
+
+- `SYNTHETIC_SMOKE` verifies deterministic software behavior only. Its values are
+  neither market observations nor investment evidence.
+- `PUBLIC_SAMPLE_PARTIAL` describes a fixed, bounded public-data interval. It may
+  support interval-specific research observations but not broad generalization.
+- `FULL_DATA` is reserved for a manifested empirical study meeting its declared
+  coverage and acceptance tests. It still represents research and simulation,
+  not realized live performance.
+- `INSUFFICIENT_DATA` is a terminal evidence status, not a lower-quality set of
+  model estimates. It means a predeclared input or quality gate prevented the
+  required evaluation; absent predictions and execution fields remain absent
+  rather than being imputed, rerun on replacement dates, or reported as zeros.
+
+Evidence tier is derived from data manifests. A synthetic source cannot be
+promoted by changing a report label.
+
+## Time and observability
+
+All reported intervals are UTC. Stable event ordering uses the normalized event
+timestamp plus sequence and event identifiers; tied timestamps are not reordered
+arbitrarily. Exchange event time is not automatically equivalent to local receipt
+time. A feature at decision event `t` may contain only values observable at or
+before `t`; its label begins strictly after `t`. Decision and order latency are
+separate assumptions.
+
+Time-ordered evaluation is necessary but not sufficient. When label intervals
+overlap a fold boundary, affected training rows must be purged. Configured embargo
+separates adjacent folds. The final test period is not used for model selection,
+feature selection, hyperparameter tuning, threshold choice, or probability
+calibration.
+
+## Data lineage and quality
+
+External raw data is immutable and excluded from Git. Each download or fixture
+requires a source, retrieval time or deterministic generation rule, requested and
+observed period, schema version, row count, and checksum. Normalization and later
+exclusions create new artifacts rather than rewriting raw observations.
+
+Validation covers duplicates, out-of-order timestamps, missing sequence ranges,
+crossed books, nonpositive price or quantity, abnormal spread, long silence, and
+clock discontinuities. A warning does not prove an observation is harmless. A
+fatal gap can require abandoning an affected reconstruction segment rather than
+interpolating it.
+
+Public endpoints can change schema, retention, throttling, or geographic
+availability. Download success does not establish completeness. Exchange
+maintenance, symbol-rule changes, clock behavior, delistings, and missing markets
+can bias a selected sample.
+
+The canonical full-archive trade M8 result illustrates this boundary. BTCUSDT
+training normalization completed on 2,071,461 rows with no findings. ETHUSDT
+training normalization completed on 987,297 rows with zero errors but 53 long-
+silence warnings, violating the frozen zero-warning gate. Selection did not
+start, neither held-out date was opened, and execution was not run. This supports
+the conclusion that the declared trade study was data-insufficient; it neither
+supports nor refutes the economic hypothesis. Relaxing the warning rule or
+choosing another date after seeing that terminal would invalidate the protocol.
+
+## Market-state and feature measurement
+
+Order-flow imbalance, signed volume, intensity, spread, depth, queue imbalance,
+microprice, volatility, price impact, liquidity recovery, and regime features are
+conditional on the event types actually observed. Trade signing can be wrong.
+Displayed depth can be cancelled before execution. Aggregated or trade-only data
+cannot identify hidden orders, matching-engine priority, or individual queue
+position. Cancellation intensity is unavailable unless the feed exposes enough
+book history to measure it defensibly.
+
+Feature windows create serial dependence, and overlapping future labels reduce
+effective sample size. Intraday and volatility regimes may be unbalanced. A
+relationship can reflect a common response to news rather than a causal effect of
+order flow on price.
+
+## Statistical modeling
+
+Simple historical or majority baselines anchor the model ladder. Linear and
+regularized models provide interpretable comparisons; a tree model tests bounded
+nonlinearity. More complex time-series or point-process models require a stated
+economic reason and evidence that simpler models leave meaningful structure.
+
+ROC-AUC alone can obscure calibration and class imbalance. Classification reports
+should include log loss, Brier score, precision-recall diagnostics where useful,
+class rates, and calibration. Regression reports require scale-aware errors and a
+baseline comparison. Bootstrap confidence intervals must respect temporal
+dependence. Repeated instruments, horizons, regimes, features, thresholds, and
+models create multiplicity; an unadjusted favorable result is exploratory.
+
+Model importance is not structural causality. Feature rankings can be unstable
+under correlation or regime shift. A selected model may decay after the observed
+period, and cryptocurrency venue behavior may not transfer to equities, futures,
+or fragmented markets.
+
+## Execution and fills
+
+Predictive metrics are not execution results. Simulated economics depend on maker
+and taker fees, half-spread and slippage, decision and order latency, order size,
+fill probability, queue proxy, partial fills, adverse selection, inventory cap,
+liquidation, and capacity assumptions. Each assumption must be serialized and
+sensitivity-tested.
+
+A queue proxy is not true priority. A fill inferred from subsequent traded volume
+can be optimistic when cancellations, hidden liquidity, competing orders, and
+matching rules are unknown. Limit-order simulations can suffer severe adverse
+selection; market-order simulations can understate impact. Forced end-of-period
+liquidation may dominate a short sample. Capacity extrapolation from public top-of-
+book data is especially uncertain.
+
+Annualized return or Sharpe-like statistics are inappropriate for synthetic or
+very short runs. Simulated P&L excludes operational failures, exchange outages,
+funding and financing where omitted, taxes, custody, counterparty risk, and live
+model drift. The project contains no order-entry path and is not a deployment
+system.
+
+The frozen live-L2 extension narrows execution further. It permits market-order
+scenarios only, with threshold, reference notional/depth, lot rounding, L1 fill
+cap, inventory, liquidation, fee, and decision/order latency rules fixed before
+held-out access. Latencies in this campaign are event counts, not milliseconds.
+Recorded L1 limits the scenario fill and any residual is cancelled; no deeper
+walk, hidden liquidity, endogenous reaction, or true impact is modeled. The
+frozen zero-extra-slippage setting is one transparent scenario, not evidence
+that slippage is zero. Capacity, realized execution, limit-fill, queue-priority,
+and profitability claims remain forbidden.
+
+## Prospective live-L2 boundary
+
+The Aug 8--11 BTCUSDT/ETHUSDT sessions must share one clean capture runtime
+identity and pass the exact simultaneous observed-interval gates. Raw websocket
+receipt time is available, but it is internet-path receipt time—not a colocated
+clock or matching-engine acknowledgment. A long nominal session cannot conceal
+gaps: features and labels are limited to verified observed intervals, and clock
+targets are censored if no sufficiently fresh same-interval state exists.
+
+The campaign authority also binds an outcome-blind nonce, the one canonical
+output-root path and filesystem identity, the loaded package/module origin, and
+a hashed Python/platform/production-dependency fingerprint. These controls make
+environment and storage substitution visible, but they do not make public-
+internet latency colocated or prove that the exchange feed was complete.
+
+Regime thresholds are fit on Aug 8 only. When both development sessions are
+complete, model selection and calibration use Aug 8/9 only and must be committed
+in eight symbol-by-endpoint child locks plus one aggregate `LOCKED` authority
+before Aug 10/11 frames are exposed. If either development session is
+insufficient, a control-only `NOT_CREATED` authority is committed instead and no
+economic frame from any session is opened. Held-out evaluation restores only a
+`LOCKED` state without refit. Paired moving-block intervals
+partially address serial dependence but do not prove independence, solve all
+overlapping-horizon dependence, correct every model/horizon/regime comparison,
+or authorize a p-value. Directional agreement across two adjacent one-hour
+sessions is still a narrow venue- and period-specific result.
+
+At the pre-capture source freeze, these were software and governance controls,
+not book evidence: no declared L2 session bundle or downstream L2 metric had
+been promoted. This tracked file is intentionally unchanged during the four-day
+campaign. The exact field-level authority is
+`docs/M8_L2_ANALYSIS_CONTRACT.md`; any eventual numbers must come from a verified
+generated bundle rather than this source-controlled limitations file.
+
+The completed final producer takes four explicit session path/manifest/checksum
+authorities plus the development-authority path and SHA. A development or
+held-out session failure
+or no eligible label produces a checksummed `INSUFFICIENT_DATA` terminal with no
+promoted evaluation or execution, rather than an opportunistic retry. A complete
+run copies exact control authorities into a self-contained snapshot but still
+revalidates their external originals. Reports are re-rendered from a checksummed
+report-input snapshot into a separate directory; report generation cannot mutate
+the immutable empirical bundle. These are integrity and governance guarantees,
+not proof that the economic design or market conclusion is correct.
+
+## Reporting and generalizability
+
+Generated reports read serialized artifacts; they do not recalculate statistics.
+Every surface shows evidence tier, observed UTC interval, configuration hash,
+input-manifest hashes, Git commit or `UNBORN`, and dirty state. Missing values are
+`N/A`, never zero. Checksums demonstrate byte integrity, not correctness of the
+economic design.
+
+Results from BTCUSDT and ETHUSDT on one venue cannot be assumed to apply to other
+symbols, venues, asset classes, tick sizes, participant mixes, or regulatory
+settings. Robustness requires predeclared adjacent periods, cross-instrument and
+regime comparisons, alternative defensible execution assumptions, and careful
+documentation of results that fail.

Microstructure/reports/model_comparison.md

@@ -0,0 +1,12 @@
+# Model comparison
+
+> **STATUS: SOURCE-CONTROLLED TEMPLATE — RUN-SPECIFIC TABLES ARE GENERATED BY CODE**
+
+This file intentionally contains no copied model or execution numbers. Run-
+specific held-out tables are rendered from the frozen bundle by `make report`.
+
+The generated table will be built from serialized run artifacts and will include
+the evidence tier, instrument, horizon, model, held-out split, sample count,
+actual UTC test period, predictive diagnostics, gross and net execution
+diagnostics, fill rate, turnover, drawdown, and the validation-only selection
+criterion. Unsupported values will render as `N/A`, not zero.

Microstructure/reports/technical_report.md

@@ -0,0 +1,80 @@
+# Technical report
+
+> **STATUS: SOURCE-CONTROLLED TEMPLATE — RUN-SPECIFIC REPORTS ARE GENERATED BY CODE**
+
+This is the canonical report location for *Order Flow to Price Impact*. It does
+not contain manually copied empirical or synthetic performance results.
+`make reproduce-sample` produces a checksum-verified frozen bundle containing its
+evidence tier, configuration/input hashes, observed UTC interval and Git state;
+`make report` then renders a run-specific document without retraining or
+recomputing statistics.
+
+## Research question
+
+When do order-flow imbalance, liquidity, and observable limit-order-book state
+predict short-horizon price changes, and how much apparent predictive value
+survives fees, latency, uncertain fills, adverse selection, and inventory risk?
+
+## Planned evidence structure
+
+The study separates three questions that are often conflated:
+
+1. Does an observable feature predict a strictly future outcome on an untouched,
+   time-ordered test period?
+2. Is the effect stable across instruments, horizons, and liquidity or volatility
+   regimes, with uncertainty and multiple testing acknowledged?
+3. Does any apparent effect survive a separately specified execution model?
+
+The model ladder begins with historical-mean or majority baselines, followed by
+transparent linear and regularized models and a bounded tree model. Model choice
+uses training and validation data only. Overlapping label intervals require
+purging and embargo before final held-out comparison.
+
+## Data and temporal integrity
+
+No data period is hard-coded in this source template. A generated report takes
+its actual minimum and maximum event timestamps from the frozen bundle—not merely
+from requested configuration dates. Raw observations remain
+unchanged; validation findings and any downstream exclusions are recorded
+separately.
+
+At decision event `t`, features may use only information proven observable at or
+before `t`. Labels begin strictly after `t`. Exchange event time and local receipt
+time are distinct where both exist.
+
+## Predictive model quality
+
+No model metrics are embedded in this template. The generated comparison reports
+held-out sample size and period, ROC-AUC or regression diagnostics as applicable,
+log loss, Brier score, expected calibration error, and serialized fixed-block
+bootstrap intervals. Regime-level outcomes and model diagnostics are persisted as
+separate descriptive analysis artifacts rather than folded into the comparison
+table. Missing metrics will display as `N/A`, never as zero.
+
+## Execution and simulated performance
+
+No execution result is embedded here. Generated simulation results state maker
+and taker fees, decision and order latency, queue/fill proxy, partial fills,
+adverse selection, inventory limits, liquidation, turnover, and trade-size or
+capacity sensitivity. Predictive metrics and execution metrics remain separate.
+
+## Economic interpretation
+
+There is currently no supported claim about predictability, profitability,
+statistical significance, or deployability. The synthetic smoke run validates
+software plumbing only and carries the mandatory
+`SYNTHETIC_SMOKE` warning on every output surface.
+
+## Limitations
+
+See [methodology_limitations.md](methodology_limitations.md) for the maintained
+methodology and limitations register. Even a completed public-data analysis will
+remain venue-specific, sensitive to timestamp and fill assumptions, and distinct
+from realized live execution.
+
+## Reproduction record
+
+Run `make reproduce-sample && make verify-run && make report`. The generated
+report records run ID, evidence tier, observed UTC period, configuration SHA-256,
+input-manifest SHA-256 values, Git commit, dirty state and runtime metadata. The
+source-controlled template intentionally remains free of copied metrics.

Microstructure/src/microstructure/__init__.py

@@ -0,0 +1,10 @@
+"""Event-driven market-microstructure research package."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("event-driven-microstructure")
+except PackageNotFoundError:  # pragma: no cover - editable source without metadata
+    __version__ = "0+unknown"
+
+__all__ = ["__version__"]

Microstructure/src/microstructure/cli.py

@@ -0,0 +1,2003 @@
+"""Command-line interface for research data, reproduction, and reporting."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import base64
+import hashlib
+import json
+import os
+import sys
+import tempfile
+import time
+from collections.abc import AsyncIterator, Callable, Iterator, Mapping, Sequence
+from contextlib import suppress
+from dataclasses import asdict, dataclass
+from decimal import Decimal
+from pathlib import Path
+from typing import Any, Literal, cast
+
+import pyarrow as pa  # type: ignore[import-untyped]
+
+from microstructure import __version__
+from microstructure.config import ProjectConfig, datetime_to_ns, load_config
+from microstructure.data.binance import (
+    BinanceLiveDepthCollector,
+    BinancePublicClient,
+    CapturedDepth,
+    RawDepthFrame,
+)
+from microstructure.data.book import BookSnapshot, IncrementalBookReconstructor
+from microstructure.data.quality import IncrementalQualityValidator, ValidationReport
+from microstructure.data.schemas import get_schema, table_from_records
+from microstructure.data.storage import write_capture_parquet, write_source_manifest
+from microstructure.data.synthetic import generate_synthetic_market
+from microstructure.ingestion import (
+    IngestionResult,
+    ingest_from_config,
+    validate_configured_input,
+)
+from microstructure.m8_acquisition import (
+    M8AcquisitionFailureResult,
+    M8AcquisitionResult,
+    acquire_m8_archives,
+)
+from microstructure.m8_config import load_m8_config
+from microstructure.m8_l2_analysis_config import (
+    M8L2AnalysisConfig,
+    load_m8_l2_analysis_config,
+)
+from microstructure.m8_l2_binance import BinanceM8L2Capture
+from microstructure.m8_l2_capture import (
+    M8L2SessionBundle,
+    capture_m8_l2_session,
+    verify_m8_l2_session_bundle,
+)
+from microstructure.m8_l2_config import M8L2StudyConfig, load_m8_l2_config
+from microstructure.m8_l2_development import (
+    L2DevelopmentInputVerifier,
+    L2DevelopmentLockResult,
+    lock_m8_l2_development,
+    verify_m8_l2_development_lock,
+)
+from microstructure.m8_l2_inputs import (
+    L2CampaignRuntimeIdentity,
+    L2SessionFileAuthority,
+    verify_m8_l2_development_input,
+)
+from microstructure.m8_l2_pipeline import (
+    L2StudySessionAuthority,
+    M8L2StudyRunResult,
+    load_m8_l2_report_data,
+    reproduce_m8_l2_study,
+    verify_m8_l2_study_run,
+)
+from microstructure.m8_pipeline import M8RunResult, reproduce_m8, verify_m8_result
+from microstructure.pipeline import reproduce
+from microstructure.provenance import read_json, sha256_file, utc_now_iso, write_json
+from microstructure.reporting import (
+    canonical_report_data_sha256,
+    load_run_bundle,
+    verify_checksums,
+    write_l2_report_set,
+    write_report_set,
+)
+
+
+def _json_default(value: object) -> object:
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, Decimal):
+        return str(value)
+    raise TypeError(f"cannot serialize {type(value).__name__}")
+
+
+def _print_json(payload: object) -> None:
+    print(json.dumps(payload, indent=2, sort_keys=True, default=_json_default))
+
+
+def _ingestion_payload(result: IngestionResult) -> dict[str, Any]:
+    return {
+        "mode": result.mode,
+        "evidence_tier": result.evidence_tier,
+        "output_root": result.output_root,
+        "ingestion_manifest": result.ingestion_manifest_path,
+        "ingestion_manifest_sha256": result.ingestion_manifest_sha256,
+        "rows": result.rows,
+        "datasets": [
+            {
+                "schema": dataset.schema_name,
+                "rows": dataset.rows,
+                "manifest": dataset.storage.manifest_path,
+                "manifest_sha256": dataset.storage.manifest_sha256,
+                "quality_errors": dataset.validation.error_count,
+                "quality_warnings": dataset.validation.warning_count,
+            }
+            for dataset in result.datasets
+        ],
+        "raw_artifacts": len(result.raw_artifacts),
+        "symbols": [
+            {
+                "symbol": item.symbol,
+                "rows": item.rows,
+                "complete_range": item.complete_range,
+                "tick_size": item.metadata.tick_size,
+                "lot_size": item.metadata.lot_size,
+            }
+            for item in result.symbols
+        ],
+        "quality": {
+            "passed": result.validation.passed,
+            "rows_checked": result.validation.rows_checked,
+            "errors": result.validation.error_count,
+            "warnings": result.validation.warning_count,
+        },
+    }
+
+
+def _cmd_ingest(args: argparse.Namespace) -> int:
+    config = load_config(args.config)
+    output_root = (
+        Path(args.output_root).resolve() if args.output_root else config.data.partition_root.parent
+    )
+    result = ingest_from_config(config, output_root)
+    _print_json(_ingestion_payload(result))
+    return 0
+
+
+def _m8_acquisition_payload(result: M8AcquisitionResult) -> dict[str, Any]:
+    return {
+        "status": "acquired",
+        "scope": "raw_only",
+        "output_root": result.output_root,
+        "raw_manifest": result.manifest_path,
+        "raw_manifest_sha256": result.manifest_sha256,
+        "metadata_responses": result.metadata_count,
+        "archives": result.archive_count,
+        "total_raw_evidence_bytes": result.total_raw_evidence_bytes,
+        "csv_members_opened": False,
+        "economic_fields_inspected": False,
+    }
+
+
+def _m8_acquisition_failure_payload(result: M8AcquisitionFailureResult) -> dict[str, Any]:
+    failed_date = result.failed_date
+    return {
+        "status": "INSUFFICIENT_DATA",
+        "scope": "raw_only",
+        "output_root": result.output_root,
+        "attempt_dir": result.attempt_dir,
+        "failure_manifest": result.attempt_manifest_path,
+        "failure_manifest_sha256": result.attempt_manifest_sha256,
+        "checksums": result.checksums_path,
+        "checksums_sha256": result.checksums_sha256,
+        "terminal_marker": result.terminal_path,
+        "reason_code": result.reason_code,
+        "diagnostic": result.diagnostic,
+        "failed_symbol": result.failed_symbol,
+        "failed_date": None if failed_date is None else failed_date.isoformat(),
+        "failed_role": result.failed_role,
+        "completed_steps": result.completed_count,
+        "remaining_steps": result.remaining_count,
+        "retained_inventory_sha256": result.retained_inventory_sha256,
+        "retained_artifacts": result.retained_artifact_count,
+        "total_raw_evidence_bytes": result.total_raw_evidence_bytes,
+        "csv_members_opened": False,
+        "economic_fields_inspected": False,
+    }
+
+
+def _cmd_acquire_m8(args: argparse.Namespace) -> int:
+    config = load_m8_config(args.config)
+    result = acquire_m8_archives(config, Path(args.output_root).resolve())
+    if isinstance(result, M8AcquisitionFailureResult):
+        _print_json(_m8_acquisition_failure_payload(result))
+        return 1
+    _print_json(_m8_acquisition_payload(result))
+    return 0
+
+
+def _synthetic_tables(config: ProjectConfig) -> dict[str, Any]:
+    events = config.data.events_per_symbol
+    if events is None:
+        raise ValueError("synthetic validation requires data.events_per_symbol")
+    generated = generate_synthetic_market(
+        symbols=config.data.symbols,
+        events_per_symbol=events,
+        start_ts_ns=datetime_to_ns(config.data.start),
+        seed=config.run.seed,
+    )
+    return {"trades": generated.trades, "book_observations": generated.book_observations}
+
+
+def _cmd_validate(args: argparse.Namespace) -> int:
+    config = load_config(args.config)
+    tables = _synthetic_tables(config) if config.data.mode == "synthetic" else None
+    summary = validate_configured_input(config, tables=tables)
+    _print_json(
+        {
+            "passed": summary.passed,
+            "rows_checked": summary.rows_checked,
+            "errors": summary.error_count,
+            "warnings": summary.warning_count,
+            "reports": [
+                {
+                    "dataset": report.dataset,
+                    "rows_checked": report.rows_checked,
+                    "errors": report.error_count,
+                    "warnings": report.warning_count,
+                }
+                for report in summary.reports
+            ],
+            "mutation_policy": "validation did not repair or replace observations",
+        }
+    )
+    return 0 if summary.passed else 1
+
+
+def _cmd_reproduce(args: argparse.Namespace) -> int:
+    config = load_config(args.config)
+    output = reproduce(
+        config,
+        Path(args.run_dir),
+        ingestion_manifest_path=args.ingestion_manifest,
+        ingestion_manifest_sha256=args.ingestion_manifest_sha256,
+    )
+    bundle = load_run_bundle(output)
+    _print_json(
+        {
+            "run_dir": output,
+            "run_id": bundle.run_id,
+            "evidence_tier": bundle.evidence_tier,
+            "observed_start_utc": bundle.observed_start_utc,
+            "observed_end_utc": bundle.observed_end_utc,
+            "status": "complete",
+        }
+    )
+    return 0
+
+
+def _cmd_reproduce_m8(args: argparse.Namespace) -> int:
+    config = load_m8_config(args.config)
+    result = reproduce_m8(
+        config,
+        Path(args.run_dir),
+        raw_manifest_path=Path(args.raw_manifest),
+        raw_manifest_sha256=str(args.raw_manifest_sha256),
+    )
+    if result.status == "INSUFFICIENT_DATA":
+        _print_json(_m8_run_result_payload(result))
+        return 1
+    bundle = load_run_bundle(result.path)
+    _print_json(
+        {
+            "run_dir": result.path,
+            "run_id": bundle.run_id,
+            "evidence_tier": bundle.evidence_tier,
+            "observed_start_utc": bundle.observed_start_utc,
+            "observed_end_utc": bundle.observed_end_utc,
+            "status": result.status,
+            "raw_manifest_sha256": result.raw_manifest_sha256,
+            "normalized_manifest_sha256": result.normalized_manifest_sha256,
+        }
+    )
+    return 0
+
+
+def _m8_run_result_payload(result: M8RunResult) -> dict[str, Any]:
+    return {
+        "run_dir": result.path,
+        "status": result.status,
+        "raw_manifest_sha256": result.raw_manifest_sha256,
+        "normalized_manifest_sha256": result.normalized_manifest_sha256,
+    }
+
+
+def _cmd_verify_m8(args: argparse.Namespace) -> int:
+    config = load_m8_config(args.config)
+    result = verify_m8_result(
+        args.run_dir,
+        config,
+        raw_manifest_path=args.raw_manifest,
+        raw_manifest_sha256=args.raw_manifest_sha256,
+    )
+    payload = _m8_run_result_payload(result)
+    payload.update(
+        {
+            "integrity": "verified",
+            "protected_files": verify_checksums(result.path),
+        }
+    )
+    _print_json(payload)
+    return 0
+
+
+def _external_report_dir(run_root: Path, requested: Path | None) -> Path:
+    frozen_root = run_root.resolve()
+    output = (
+        requested.resolve()
+        if requested is not None
+        else frozen_root.with_name(f"{frozen_root.name}-reports")
+    )
+    if output == frozen_root or frozen_root in output.parents:
+        raise ValueError("report output directory must be outside the immutable run bundle")
+    return output
+
+
+def _atomic_text(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary_name = tempfile.mkstemp(
+        dir=path.parent,
+        prefix=f".{path.name}.",
+        suffix=".tmp",
+        text=True,
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8", newline="\n") as handle:
+            handle.write(content)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary, path)
+        directory = os.open(path.parent, os.O_RDONLY)
+        try:
+            os.fsync(directory)
+        finally:
+            os.close(directory)
+    except BaseException:
+        temporary.unlink(missing_ok=True)
+        raise
+
+
+def _report_mapping(value: object, label: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise ValueError(f"verified M8 {label} is not a JSON object")
+    return cast(Mapping[str, Any], value)
+
+
+def _report_value(value: object) -> str:
+    if isinstance(value, (dict, list, tuple)):
+        rendered = json.dumps(value, sort_keys=True, separators=(",", ":"))
+    elif value is None:
+        rendered = "null"
+    elif value is True:
+        rendered = "true"
+    elif value is False:
+        rendered = "false"
+    else:
+        rendered = str(value)
+    return " ".join(rendered.replace("`", "'").split())
+
+
+def _m8_failure_period(failure: Mapping[str, Any]) -> tuple[str, str]:
+    dates: list[str] = []
+    for key in ("completed_normalizations", "stopped_before"):
+        rows = failure.get(key)
+        if isinstance(rows, list):
+            dates.extend(
+                str(row["date"])
+                for row in rows
+                if isinstance(row, Mapping)
+                and isinstance(row.get("date"), str)
+                and len(str(row["date"])) == 10
+            )
+    failed_date = failure.get("failed_date")
+    if isinstance(failed_date, str) and len(failed_date) == 10:
+        dates.append(failed_date)
+    if not dates:
+        raise ValueError("verified M8 failure does not declare its study period")
+    return min(dates), max(dates)
+
+
+def _render_m8_insufficient_report(run_root: Path) -> str:
+    failure = _report_mapping(read_json(run_root / "failure.json"), "failure record")
+    provenance = _report_mapping(read_json(run_root / "provenance.json"), "provenance")
+    manifest = _report_mapping(read_json(run_root / "run_manifest.json"), "run manifest")
+    research = _report_mapping(manifest.get("research"), "run research section")
+    execution = _report_mapping(
+        manifest.get("execution_assumptions"),
+        "execution-assumptions section",
+    )
+    git = _report_mapping(provenance.get("git"), "Git identity")
+    period_start, period_end = _m8_failure_period(failure)
+    completed_symbols = failure.get("selection_completed_symbols")
+    evaluated_symbols = failure.get("endpoint_evaluation_completed_symbols")
+    heldout_member = failure.get("held_out_member_opened", "not separately recorded")
+    return f"""# M8 study result: INSUFFICIENT_DATA
+
+> VERIFIED TERMINAL TRADE-ONLY RESEARCH RESULT — NO DATE REPLACEMENT, LIVE TRADING, OR PERFORMANCE CLAIM
+
+## Frozen scope and failure
+
+- Observed/attempted archive date span: `{period_start}` through `{period_end}` (UTC daily archives)
+- Failed coordinate: symbol=`{_report_value(failure.get("failed_symbol"))}`, date=`{_report_value(failure.get("failed_date"))}`, role=`{_report_value(failure.get("failed_role"))}`
+- Failure stage: `{_report_value(failure.get("failure_stage"))}`
+- Reason code: `{_report_value(failure.get("reason_code"))}`
+- Diagnostic: `{_report_value(failure.get("reason"))}`
+- Replacement date selected: `{_report_value(failure.get("replacement_date_selected"))}`; reselection performed: `{_report_value(failure.get("reselection_performed"))}`
+
+## Immutable authority
+
+- Config semantic SHA-256: `{_report_value(failure.get("config_sha256"))}`
+- Config source SHA-256: `{_report_value(failure.get("config_source_sha256"))}`
+- Raw acquisition manifest SHA-256: `{_report_value(failure.get("raw_acquisition_manifest_sha256"))}`
+- Bundled raw acquisition manifest SHA-256: `{_report_value(failure.get("bundled_raw_acquisition_manifest_sha256"))}`
+- Protocol SHA-256: `{_report_value(failure.get("protocol_sha256"))}`
+- Git commit: `{_report_value(git.get("commit"))}`
+- Git dirty: `{_report_value(git.get("dirty"))}`
+- Source-tree SHA-256: `{_report_value(git.get("source_tree_sha256"))}`
+
+## Terminal analysis states
+
+- Candidate selection started: `{_report_value(failure.get("selection_started"))}`; completed symbols: `{_report_value(completed_symbols)}`
+- Aggregate analysis lock committed: `{_report_value(failure.get("aggregate_lock_committed"))}`
+- Held-out member opened: `{_report_value(heldout_member)}`
+- Endpoint evaluation started: `{_report_value(failure.get("endpoint_evaluation_started"))}`; completed: `{_report_value(failure.get("endpoint_evaluation_completed"))}`; completed symbols: `{_report_value(evaluated_symbols)}`
+- Predictions published: `{_report_value(failure.get("predictions_published"))}`; endpoint artifacts published: `{_report_value(failure.get("endpoint_artifacts_published"))}`
+- Research endpoint status: `{_report_value(research.get("endpoint_status"))}`
+- Execution status: `{_report_value(execution.get("status"))}`; fills calculated: `{_report_value(execution.get("fills_calculated"))}`; P&L calculated: `{_report_value(execution.get("pnl_calculated"))}`; capacity calculated: `{_report_value(execution.get("capacity_calculated"))}`
+
+This terminal result preserves the frozen calendar and failure evidence. It authorizes no execution, profitability, capacity, statistical-significance, or persistent-alpha claim.
+"""
+
+
+def _cmd_report_m8(args: argparse.Namespace) -> int:
+    config = load_m8_config(args.config)
+    result = verify_m8_result(
+        args.run_dir,
+        config,
+        raw_manifest_path=args.raw_manifest,
+        raw_manifest_sha256=args.raw_manifest_sha256,
+    )
+    output = _external_report_dir(result.path, args.output_dir)
+    if result.status == "COMPLETE":
+        bundle = load_run_bundle(result.path)
+        paths = write_report_set(bundle, output)
+        _print_json(
+            {
+                **_m8_run_result_payload(result),
+                "output_dir": output,
+                "reports_regenerated": True,
+                **asdict(paths),
+            }
+        )
+    else:
+        rendered = _render_m8_insufficient_report(result.path)
+        confirmed = verify_m8_result(
+            args.run_dir,
+            config,
+            raw_manifest_path=args.raw_manifest,
+            raw_manifest_sha256=args.raw_manifest_sha256,
+        )
+        if (
+            confirmed.status != "INSUFFICIENT_DATA"
+            or confirmed.path.resolve() != result.path.resolve()
+            or confirmed.raw_manifest_sha256 != result.raw_manifest_sha256
+            or confirmed.normalized_manifest_sha256 is not None
+        ):
+            raise ValueError("M8 failure authority changed while rendering its report")
+        failure_report = output / "insufficient_data.md"
+        _atomic_text(failure_report, rendered)
+        _print_json(
+            {
+                **_m8_run_result_payload(result),
+                "output_dir": output,
+                "report": failure_report,
+                "report_sha256": sha256_file(failure_report),
+                "reports_regenerated": True,
+                "source_bundle_modified": False,
+            }
+        )
+    return 0
+
+
+def _lowercase_sha256(value: str) -> str:
+    if len(value) != 64 or any(character not in "0123456789abcdef" for character in value):
+        raise argparse.ArgumentTypeError("must be a 64-character lowercase SHA-256 digest")
+    return value
+
+
+def _cmd_verify(args: argparse.Namespace) -> int:
+    bundle = load_run_bundle(args.run_dir)
+    protected = verify_checksums(args.run_dir)
+    _print_json(
+        {
+            "run_dir": bundle.root,
+            "run_id": bundle.run_id,
+            "evidence_tier": bundle.evidence_tier,
+            "protected_files": protected,
+            "integrity": "verified",
+        }
+    )
+    return 0
+
+
+def _cmd_report(args: argparse.Namespace) -> int:
+    bundle = load_run_bundle(args.run_dir)
+    output = (
+        Path(args.output_dir).resolve()
+        if args.output_dir
+        else bundle.root.with_name(f"{bundle.root.name}-reports")
+    )
+    paths = write_report_set(bundle, output)
+    _print_json({"run_id": bundle.run_id, "output_dir": output, **asdict(paths)})
+    return 0
+
+
+_LIVE_BATCH_ROWS = 1_024
+_MAX_LIVE_RAW_MESSAGE_BYTES = 1 * 1024 * 1024
+_LIVE_BATCH_ESTIMATED_BYTES = 16 * 1024 * 1024
+_VARIABLE_RECORD_OVERHEAD_FACTOR = 8
+
+
+@dataclass(frozen=True, slots=True)
+class DepthCaptureResult:
+    symbol: str
+    messages: int
+    continuity_epochs: int
+    reconstruction_status: Literal["LIVE", "GAPPED", "INVALID"]
+    book_observations: int
+    sequence_gaps: int
+    stale_events: int
+    excluded_messages: int
+    final_update_id: int
+    quality_errors: int
+    quality_warnings: int
+    raw_path: Path
+    raw_manifest_path: Path
+    raw_manifest_sha256: str
+    summary_path: Path
+    completion_reason: str
+    requested_duration_seconds: float | None
+    elapsed_monotonic_seconds: float
+    receipt_coverage_seconds: float
+    max_continuity_epoch_seconds: float
+
+
+@dataclass(slots=True)
+class _DepthCaptureStop:
+    reason: str = "not_started"
+    elapsed_monotonic_seconds: float = 0.0
+
+
+@dataclass(slots=True)
+class _DepthEpochCoverage:
+    continuity_id: str
+    snapshot_id: str
+    first_received_ns: int
+    last_received_ns: int
+    messages: int = 0
+    book_observations: int = 0
+    excluded_messages: int = 0
+    sequence_gaps: int = 0
+    reconstruction_status: Literal["LIVE", "GAPPED", "INVALID"] = "LIVE"
+    final_update_id: int = 0
+
+    @property
+    def duration_seconds(self) -> float:
+        return max(0.0, (self.last_received_ns - self.first_received_ns) / 1_000_000_000.0)
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "continuity_id": self.continuity_id,
+            "snapshot_id": self.snapshot_id,
+            "first_received_ns": self.first_received_ns,
+            "last_received_ns": self.last_received_ns,
+            "duration_seconds": self.duration_seconds,
+            "messages": self.messages,
+            "book_observations": self.book_observations,
+            "excluded_messages": self.excluded_messages,
+            "sequence_gaps": self.sequence_gaps,
+            "reconstruction_status": self.reconstruction_status,
+            "final_update_id": self.final_update_id,
+        }
+
+
+async def _bounded_depth_items(
+    collector: BinanceLiveDepthCollector,
+    *,
+    max_messages: int,
+    duration_seconds: float | None,
+    stop: _DepthCaptureStop,
+) -> AsyncIterator[CapturedDepth]:
+    """Yield a live stream until its safety cap or a graceful duration deadline."""
+
+    started = time.monotonic()
+    yielded = 0
+    iterator = collector.stream(max_messages=max_messages).__aiter__()
+    try:
+        if duration_seconds is None:
+            async for item in iterator:
+                yielded += 1
+                yield item
+            stop.reason = "message_limit" if yielded == max_messages else "stream_ended_early"
+            return
+
+        deadline = started + duration_seconds
+        while True:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                stop.reason = "duration_elapsed"
+                return
+            try:
+                item = await asyncio.wait_for(anext(iterator), timeout=remaining)
+            except TimeoutError:
+                stop.reason = "duration_elapsed"
+                return
+            except StopAsyncIteration:
+                stop.reason = (
+                    "message_safety_ceiling" if yielded == max_messages else "stream_ended_early"
+                )
+                return
+            yielded += 1
+            yield item
+    finally:
+        stop.elapsed_monotonic_seconds = max(0.0, time.monotonic() - started)
+        with suppress(BaseException):
+            closer = getattr(iterator, "aclose", None)
+            if callable(closer):
+                await closer()
+
+
+@dataclass(frozen=True, slots=True)
+class _PublishedRawCapture:
+    path: Path
+    sha256: str
+    manifest_path: Path
+    manifest_sha256: str
+
+
+class _ArrowBatchSpool:
+    """Bounded record buffer backed by a temporary Arrow IPC stream."""
+
+    def __init__(
+        self,
+        *,
+        root: Path,
+        schema_name: str,
+        batch_rows: int,
+        max_buffer_bytes: int,
+        on_batch: Callable[[pa.RecordBatch], None] | None = None,
+    ) -> None:
+        if batch_rows < 1:
+            raise ValueError("batch_rows must be positive")
+        if max_buffer_bytes < 1:
+            raise ValueError("max_buffer_bytes must be positive")
+        self.schema_name = schema_name
+        self.batch_rows = batch_rows
+        self.max_buffer_bytes = max_buffer_bytes
+        self.path = root / f"{schema_name}.arrow"
+        self._handle = self.path.open("wb")
+        self._writer = pa.ipc.new_stream(self._handle, get_schema(schema_name))
+        self._on_batch = on_batch
+        self._records: list[Mapping[str, object]] = []
+        self.rows = 0
+        self.max_buffered_rows = 0
+        self.max_buffered_estimated_bytes = 0
+        self._buffered_estimated_bytes = 0
+        self._closed = False
+
+    def append(self, record: Mapping[str, object], *, estimated_bytes: int) -> None:
+        if self._closed:
+            raise RuntimeError("cannot append to a closed Arrow spool")
+        if estimated_bytes < 1:
+            raise ValueError("estimated_bytes must be positive")
+        if estimated_bytes > self.max_buffer_bytes:
+            raise RuntimeError(f"one {self.schema_name} record exceeds the bounded batch estimate")
+        if (
+            self._records
+            and self._buffered_estimated_bytes + estimated_bytes > self.max_buffer_bytes
+        ):
+            self._flush()
+        self._records.append(record)
+        self._buffered_estimated_bytes += estimated_bytes
+        self.max_buffered_rows = max(self.max_buffered_rows, len(self._records))
+        self.max_buffered_estimated_bytes = max(
+            self.max_buffered_estimated_bytes,
+            self._buffered_estimated_bytes,
+        )
+        if len(self._records) >= self.batch_rows:
+            self._flush()
+
+    def _flush(self) -> None:
+        if not self._records:
+            return
+        table = table_from_records(self.schema_name, self._records)
+        batches = table.to_batches(max_chunksize=self.batch_rows)
+        if len(batches) != 1 or batches[0].num_rows > self.batch_rows:
+            raise RuntimeError(f"failed to construct one bounded {self.schema_name} batch")
+        batch = batches[0]
+        if self._on_batch is not None:
+            self._on_batch(batch)
+        self._writer.write_batch(batch)
+        self.rows += batch.num_rows
+        self._records.clear()
+        self._buffered_estimated_bytes = 0
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._flush()
+        self._writer.close()
+        if not self._handle.closed:
+            self._handle.flush()
+            os.fsync(self._handle.fileno())
+            self._handle.close()
+        self._closed = True
+
+    def iter_batches(self) -> Iterator[pa.RecordBatch]:
+        if not self._closed:
+            raise RuntimeError("Arrow spool must be closed before it can be read")
+        with self.path.open("rb") as handle:
+            reader = pa.ipc.open_stream(handle)
+            for batch in reader:
+                if batch.num_rows > self.batch_rows:
+                    raise RuntimeError(
+                        f"spooled {self.schema_name} batch exceeds {self.batch_rows} rows"
+                    )
+                yield batch
+
+
+class _RawMessageSpool:
+    """Incrementally persist an exact, typed live-capture journal."""
+
+    def __init__(self, *, root: Path, symbol: str, source_uri: str) -> None:
+        self.root = root
+        self.symbol = symbol
+        self.source_uri = source_uri
+        self.directory = root / "raw" / "binance_spot" / "depth_stream" / symbol
+        self.directory.mkdir(parents=True, exist_ok=True)
+        descriptor, temporary_name = tempfile.mkstemp(
+            dir=self.directory,
+            prefix=".capture-",
+            suffix=".ndjson.tmp",
+            text=True,
+        )
+        self._temporary_path = Path(temporary_name)
+        self._handle = os.fdopen(descriptor, "w", encoding="utf-8", newline="\n")
+        self.messages = 0
+        self.snapshot_anchors = 0
+        self.first_received_ns: int | None = None
+        self.last_received_ns: int | None = None
+        self._closed = False
+        self.published_path: Path | None = None
+        self._last_frame_identity: tuple[str, int, int, str] | None = None
+
+    @property
+    def evidence_path(self) -> Path:
+        """Return the durable path, or the fsynced temporary path after publish failure."""
+        return self.published_path or self._temporary_path
+
+    def _write_event(self, event: Mapping[str, object]) -> None:
+        if self._closed:
+            raise RuntimeError("cannot append to a closed raw capture")
+        json.dump(event, self._handle, sort_keys=True, separators=(",", ":"))
+        self._handle.write("\n")
+
+    def append_frame(self, frame: RawDepthFrame) -> int:
+        """Journal one exact frame before any UTF-8 or JSON parsing."""
+        payload_size = len(frame.payload)
+        payload_sha256 = hashlib.sha256(frame.payload).hexdigest()
+        self._write_event(
+            {
+                "capture_seq": frame.capture_seq,
+                "continuity_id": frame.continuity_id,
+                "event_kind": "websocket_frame",
+                "payload_base64": base64.b64encode(frame.payload).decode("ascii"),
+                "payload_bytes": payload_size,
+                "payload_sha256": payload_sha256,
+                "received_ts_ns": frame.received_ts_ns,
+                "websocket_message_type": "text" if frame.was_text else "binary",
+            }
+        )
+        self.messages += 1
+        if self.first_received_ns is None:
+            self.first_received_ns = frame.received_ts_ns
+        self.last_received_ns = frame.received_ts_ns
+        self._last_frame_identity = (
+            frame.continuity_id,
+            frame.capture_seq,
+            frame.received_ts_ns,
+            payload_sha256,
+        )
+        # The oversize frame is intentionally journaled before capture fails.
+        if payload_size > _MAX_LIVE_RAW_MESSAGE_BYTES:
+            raise RuntimeError(
+                f"live depth message exceeds {_MAX_LIVE_RAW_MESSAGE_BYTES} raw bytes"
+            )
+        return payload_size
+
+    def append_captured(self, item: CapturedDepth) -> int:
+        """Verify callback lineage, with a fallback for injected legacy collectors."""
+        received_ts_ns = item.delta.received_ts_ns
+        capture_seq = item.delta.capture_seq
+        if received_ts_ns is None or capture_seq is None:
+            raise RuntimeError("captured depth messages require receipt time and capture sequence")
+        payload = item.raw_payload.encode("utf-8")
+        payload_sha256 = hashlib.sha256(payload).hexdigest()
+        identity = (
+            item.delta.continuity_id,
+            capture_seq,
+            received_ts_ns,
+            payload_sha256,
+        )
+        if self._last_frame_identity != identity:
+            self.append_frame(
+                RawDepthFrame(
+                    payload=payload,
+                    was_text=True,
+                    received_ts_ns=received_ts_ns,
+                    capture_seq=capture_seq,
+                    continuity_id=item.delta.continuity_id,
+                )
+            )
+        if item.delta.source_artifact_id != payload_sha256:
+            raise RuntimeError("normalized depth delta is not bound to its raw frame SHA-256")
+        return len(payload)
+
+    def append_snapshot(self, snapshot: BookSnapshot) -> None:
+        """Bind one REST snapshot raw artifact into the capture journal."""
+        raw_path = (
+            self.root
+            / "raw"
+            / "binance_spot"
+            / "depth_snapshots"
+            / snapshot.symbol
+            / f"{snapshot.source_artifact_id}.json"
+        )
+        if not raw_path.is_file() or sha256_file(raw_path) != snapshot.source_artifact_id:
+            raise RuntimeError("book snapshot is not bound to its preserved raw response")
+        manifest_path: Path | None = None
+        for candidate in raw_path.parent.glob(f"{raw_path.name}.manifest-*.json"):
+            payload = read_json(candidate)
+            if (
+                isinstance(payload, dict)
+                and payload.get("path") == raw_path.name
+                and isinstance(payload.get("checksum"), dict)
+                and payload["checksum"].get("value") == snapshot.source_artifact_id
+                and (manifest_path is None or candidate.name > manifest_path.name)
+            ):
+                manifest_path = candidate
+        if manifest_path is None:
+            raise RuntimeError("book snapshot raw response has no valid source manifest")
+        self._write_event(
+            {
+                "continuity_id": snapshot.continuity_id,
+                "event_kind": "rest_snapshot_anchor",
+                "last_update_id": snapshot.last_update_id,
+                "raw_manifest_path": str(manifest_path),
+                "raw_manifest_sha256": sha256_file(manifest_path),
+                "raw_path": str(raw_path),
+                "raw_sha256": snapshot.source_artifact_id,
+                "received_ts_ns": snapshot.received_ts_ns,
+                "snapshot_id": snapshot.snapshot_id,
+            }
+        )
+        self.snapshot_anchors += 1
+
+    def _close(self) -> None:
+        if self._closed:
+            return
+        self._handle.flush()
+        os.fsync(self._handle.fileno())
+        self._handle.close()
+        self._closed = True
+
+    def publish(
+        self,
+        *,
+        status: str,
+        error: BaseException | None = None,
+    ) -> _PublishedRawCapture:
+        self._close()
+        if self.published_path is not None:
+            destination = self.published_path
+            digest = sha256_file(destination)
+        else:
+            digest = sha256_file(self._temporary_path)
+            prefix = "capture" if status == "raw_capture_complete" else "capture-failed"
+            destination = self.directory / f"{prefix}-{digest}.ndjson"
+            if destination.exists():
+                if sha256_file(destination) != digest:
+                    raise RuntimeError(f"raw depth capture collision at {destination}")
+                self._temporary_path.unlink(missing_ok=True)
+            else:
+                os.replace(self._temporary_path, destination)
+            self.published_path = destination
+        response_headers = {
+            "x-local-capture-status": status,
+            "x-local-journal-format": "typed-base64-frames-v1",
+            "x-local-message-count": str(self.messages),
+            "x-local-snapshot-anchor-count": str(self.snapshot_anchors),
+        }
+        if error is not None:
+            response_headers["x-local-error-type"] = type(error).__name__
+            response_headers["x-local-error"] = str(error)[:512]
+        manifest_path, manifest_sha = write_source_manifest(
+            destination,
+            source="binance_spot_public_live_capture_journal",
+            source_uri=self.source_uri,
+            downloaded_at_utc=utc_now_iso(),
+            requested_start_ns=self.first_received_ns,
+            requested_end_ns=(
+                self.last_received_ns + 1 if self.last_received_ns is not None else None
+            ),
+            response_headers=response_headers,
+        )
+        return _PublishedRawCapture(
+            path=destination,
+            sha256=digest,
+            manifest_path=manifest_path,
+            manifest_sha256=manifest_sha,
+        )
+
+    def close_without_deleting(self) -> None:
+        self._close()
+
+
+def _status_max(
+    current: Literal["LIVE", "GAPPED", "INVALID"],
+    observed: Literal["LIVE", "GAPPED", "INVALID"],
+) -> Literal["LIVE", "GAPPED", "INVALID"]:
+    rank = {"LIVE": 0, "GAPPED": 1, "INVALID": 2}
+    return observed if rank[observed] > rank[current] else current
+
+
+def _failure_record(
+    *,
+    output_root: Path,
+    capture_id: str,
+    symbol: str,
+    raw_spool: _RawMessageSpool,
+    raw_evidence: _PublishedRawCapture | None,
+    error: BaseException,
+) -> None:
+    write_json(
+        output_root / "quality" / f"live_depth_capture.{capture_id}.failed.json",
+        {
+            "generated_at_utc": utc_now_iso(),
+            "capture_id": capture_id,
+            "capture_status": "FAILED",
+            "symbol": symbol,
+            "messages_preserved": raw_spool.messages,
+            "raw_path": str(
+                raw_evidence.path if raw_evidence is not None else raw_spool.evidence_path
+            ),
+            "raw_manifest": (str(raw_evidence.manifest_path) if raw_evidence is not None else None),
+            "error_type": type(error).__name__,
+            "error": str(error),
+            "completion_manifest_published": False,
+        },
+    )
+
+
+async def _capture_depth(
+    *,
+    symbol: str,
+    max_messages: int,
+    output_root: Path,
+    duration_seconds: float | None = None,
+) -> DepthCaptureResult:
+    if max_messages < 1:
+        raise ValueError("max_messages must be positive")
+    if duration_seconds is not None and duration_seconds <= 0:
+        raise ValueError("duration_seconds must be positive when supplied")
+    output_root.mkdir(parents=True, exist_ok=True)
+    capture_id = f"{symbol.lower()}-{time.time_ns()}"
+    client = BinancePublicClient()
+    metadata = client.fetch_exchange_info(symbol=symbol, raw_root=output_root / "raw")
+    raw_spool_holder: list[_RawMessageSpool] = []
+
+    def preserve_raw_frame(frame: RawDepthFrame) -> None:
+        if not raw_spool_holder:  # pragma: no cover - collector cannot run during construction
+            raise RuntimeError("raw capture journal is not initialized")
+        raw_spool_holder[0].append_frame(frame)
+
+    collector = BinanceLiveDepthCollector(
+        symbols=(symbol,),
+        tick_size=metadata.tick_size,
+        lot_size=metadata.lot_size,
+        on_raw_frame=preserve_raw_frame,
+    )
+    raw_spool = _RawMessageSpool(root=output_root, symbol=symbol, source_uri=collector.url)
+    raw_spool_holder.append(raw_spool)
+    raw_evidence: _PublishedRawCapture | None = None
+    delta_validator = IncrementalQualityValidator(
+        "depth_deltas",
+        row_chunk_size=_LIVE_BATCH_ROWS,
+    )
+    observation_validator = IncrementalQualityValidator(
+        "book_observations",
+        row_chunk_size=_LIVE_BATCH_ROWS,
+    )
+    validators_finished = False
+    with tempfile.TemporaryDirectory(
+        dir=output_root,
+        prefix=f".{capture_id}.spool-",
+    ) as temporary_root_name:
+        temporary_root = Path(temporary_root_name)
+        spools = {
+            "book_snapshots": _ArrowBatchSpool(
+                root=temporary_root,
+                schema_name="book_snapshots",
+                batch_rows=_LIVE_BATCH_ROWS,
+                max_buffer_bytes=_LIVE_BATCH_ESTIMATED_BYTES,
+            ),
+            "depth_deltas": _ArrowBatchSpool(
+                root=temporary_root,
+                schema_name="depth_deltas",
+                batch_rows=_LIVE_BATCH_ROWS,
+                max_buffer_bytes=_LIVE_BATCH_ESTIMATED_BYTES,
+                on_batch=delta_validator.update,
+            ),
+            "book_observations": _ArrowBatchSpool(
+                root=temporary_root,
+                schema_name="book_observations",
+                batch_rows=_LIVE_BATCH_ROWS,
+                max_buffer_bytes=_LIVE_BATCH_ESTIMATED_BYTES,
+                on_batch=observation_validator.update,
+            ),
+            "sequence_gaps": _ArrowBatchSpool(
+                root=temporary_root,
+                schema_name="sequence_gaps",
+                batch_rows=_LIVE_BATCH_ROWS,
+                max_buffer_bytes=_LIVE_BATCH_ESTIMATED_BYTES,
+            ),
+        }
+        current_continuity_id: str | None = None
+        reconstructor: IncrementalBookReconstructor | None = None
+        continuity_epochs = 0
+        status: Literal["LIVE", "GAPPED", "INVALID"] = "LIVE"
+        stale_events = 0
+        excluded_messages = 0
+        final_update_id = 0
+        capture_stop = _DepthCaptureStop()
+        epoch_coverage: list[_DepthEpochCoverage] = []
+        current_epoch_coverage: _DepthEpochCoverage | None = None
+        try:
+            async for item in _bounded_depth_items(
+                collector,
+                max_messages=max_messages,
+                duration_seconds=duration_seconds,
+                stop=capture_stop,
+            ):
+                raw_message_bytes = raw_spool.append_captured(item)
+                if item.delta.continuity_id != current_continuity_id:
+                    snapshot = client.fetch_depth_snapshot(
+                        symbol=symbol,
+                        raw_root=output_root / "raw",
+                        continuity_id=item.delta.continuity_id,
+                        tick_size=metadata.tick_size,
+                        lot_size=metadata.lot_size,
+                    )
+                    raw_spool.append_snapshot(snapshot)
+                    snapshot_estimated_bytes = max(
+                        4_096,
+                        128 * (len(snapshot.bids) + len(snapshot.asks)),
+                    )
+                    spools["book_snapshots"].append(
+                        snapshot.to_record(),
+                        estimated_bytes=snapshot_estimated_bytes,
+                    )
+                    reconstructor = IncrementalBookReconstructor(snapshot)
+                    current_continuity_id = item.delta.continuity_id
+                    continuity_epochs += 1
+                    received_ts_ns = item.delta.received_ts_ns
+                    if received_ts_ns is None:  # pragma: no cover - append_captured validates
+                        raise RuntimeError("live depth delta has no receipt timestamp")
+                    current_epoch_coverage = _DepthEpochCoverage(
+                        continuity_id=item.delta.continuity_id,
+                        snapshot_id=snapshot.snapshot_id,
+                        first_received_ns=received_ts_ns,
+                        last_received_ns=received_ts_ns,
+                    )
+                    epoch_coverage.append(current_epoch_coverage)
+                if reconstructor is None:  # pragma: no cover - guarded by epoch creation
+                    raise RuntimeError("live depth epoch has no reconstructor")
+                if current_epoch_coverage is None:  # pragma: no cover - guarded by epoch creation
+                    raise RuntimeError("live depth epoch has no coverage tracker")
+                spools["depth_deltas"].append(
+                    item.delta.to_record(),
+                    estimated_bytes=max(
+                        4_096,
+                        raw_message_bytes * _VARIABLE_RECORD_OVERHEAD_FACTOR,
+                    ),
+                )
+                step = reconstructor.update(item.delta)
+                if step.observation is not None:
+                    spools["book_observations"].append(
+                        step.observation,
+                        estimated_bytes=4_096,
+                    )
+                else:
+                    excluded_messages += 1
+                if step.gap is not None:
+                    spools["sequence_gaps"].append(
+                        step.gap.to_record(),
+                        estimated_bytes=2_048,
+                    )
+                if step.outcome == "STALE":
+                    stale_events += 1
+                status = _status_max(status, reconstructor.status)
+                final_update_id = reconstructor.final_update_id
+                received_ts_ns = item.delta.received_ts_ns
+                if received_ts_ns is None:  # pragma: no cover - append_captured validates
+                    raise RuntimeError("live depth delta has no receipt timestamp")
+                current_epoch_coverage.last_received_ns = received_ts_ns
+                current_epoch_coverage.messages += 1
+                current_epoch_coverage.book_observations += int(step.observation is not None)
+                current_epoch_coverage.excluded_messages += int(step.observation is None)
+                current_epoch_coverage.sequence_gaps += int(step.gap is not None)
+                current_epoch_coverage.reconstruction_status = reconstructor.status
+                current_epoch_coverage.final_update_id = reconstructor.final_update_id
+
+            if duration_seconds is None:
+                if raw_spool.messages != max_messages or capture_stop.reason != "message_limit":
+                    raise RuntimeError(
+                        f"live depth stream ended after {raw_spool.messages} of "
+                        f"{max_messages} requested messages"
+                    )
+            else:
+                if capture_stop.reason == "message_safety_ceiling":
+                    raise RuntimeError(
+                        "live depth message safety ceiling was reached before the requested "
+                        "capture duration elapsed"
+                    )
+                if capture_stop.reason != "duration_elapsed":
+                    raise RuntimeError(
+                        "live depth stream ended before the requested capture duration "
+                        f"({capture_stop.reason})"
+                    )
+                if raw_spool.messages == 0:
+                    raise RuntimeError("duration-bounded live depth capture received no messages")
+            if raw_spool.snapshot_anchors != continuity_epochs:
+                raise RuntimeError("not every continuity epoch has a raw snapshot anchor")
+            for spool in spools.values():
+                spool.close()
+            if spools["depth_deltas"].rows != raw_spool.messages:
+                raise RuntimeError("captured and normalized depth-message counts diverged")
+            if spools["book_observations"].rows + excluded_messages != raw_spool.messages:
+                raise RuntimeError("not every normalized depth message has an explicit outcome")
+            delta_quality = delta_validator.finish()
+            observation_quality = observation_validator.finish()
+            validators_finished = True
+            raw_evidence = raw_spool.publish(status="raw_capture_complete")
+
+            normalized_root = output_root / "normalized" / "captures" / capture_id
+            time_columns = {
+                "book_snapshots": "received_ts_ns",
+                "depth_deltas": "event_ts_ns",
+                "book_observations": "event_ts_ns",
+                "sequence_gaps": "detected_ts_ns",
+            }
+            dataset_manifests: dict[str, dict[str, object]] = {}
+            for schema_name, spool in spools.items():
+                stored = write_capture_parquet(
+                    spool.iter_batches(),
+                    root=normalized_root,
+                    dataset=schema_name,
+                    schema_name=schema_name,
+                    venue="binance_spot",
+                    symbol=symbol,
+                    capture_id=capture_id,
+                    source="binance_spot_public_live_capture_journal",
+                    source_uri=str(raw_evidence.path),
+                    source_checksum_sha256=raw_evidence.sha256,
+                    requested_start_ns=raw_spool.first_received_ns,
+                    requested_end_ns=(
+                        raw_spool.last_received_ns + 1
+                        if raw_spool.last_received_ns is not None
+                        else None
+                    ),
+                    time_column=time_columns[schema_name],
+                    max_input_batch_rows=_LIVE_BATCH_ROWS,
+                )
+                if stored.rows != spool.rows:
+                    raise RuntimeError(
+                        f"stored {schema_name} row count does not match its verified spool"
+                    )
+                dataset_manifests[schema_name] = {
+                    "data_path": str(stored.data_path) if stored.data_path is not None else None,
+                    "data_sha256": stored.data_sha256,
+                    "manifest_path": str(stored.manifest_path),
+                    "manifest_sha256": stored.manifest_sha256,
+                    "rows": stored.rows,
+                }
+
+            quality_reports: tuple[ValidationReport, ...] = (
+                delta_quality,
+                observation_quality,
+            )
+            quality_errors = sum(report.error_count for report in quality_reports)
+            quality_warnings = sum(report.warning_count for report in quality_reports)
+            quality_root = output_root / "quality"
+            quality_root.mkdir(parents=True, exist_ok=True)
+            quality_report_paths: dict[str, str] = {}
+            for report in quality_reports:
+                report_path = quality_root / f"live_{report.dataset}.{capture_id}.validation.json"
+                report.write_json(report_path)
+                quality_report_paths[report.dataset] = str(report_path)
+            summary_path = quality_root / f"live_depth_capture.{capture_id}.summary.json"
+            receipt_coverage_seconds = (
+                (raw_spool.last_received_ns - raw_spool.first_received_ns) / 1_000_000_000.0
+                if raw_spool.first_received_ns is not None
+                and raw_spool.last_received_ns is not None
+                else 0.0
+            )
+            max_continuity_epoch_seconds = max(
+                (epoch.duration_seconds for epoch in epoch_coverage),
+                default=0.0,
+            )
+            summary_payload = {
+                "generated_at_utc": utc_now_iso(),
+                "capture_id": capture_id,
+                "capture_status": "COMPLETE",
+                "messages": raw_spool.messages,
+                "continuity_epochs": continuity_epochs,
+                "normalized_messages": spools["depth_deltas"].rows,
+                "book_observations": spools["book_observations"].rows,
+                "sequence_gaps": spools["sequence_gaps"].rows,
+                "stale_events": stale_events,
+                "excluded_messages": excluded_messages,
+                "reconstruction_status": status,
+                "quality_errors": quality_errors,
+                "quality_warnings": quality_warnings,
+                "completion_reason": capture_stop.reason,
+                "requested_duration_seconds": duration_seconds,
+                "message_safety_ceiling": max_messages,
+                "elapsed_monotonic_seconds": capture_stop.elapsed_monotonic_seconds,
+                "receipt_coverage_seconds": receipt_coverage_seconds,
+                "continuity_epoch_coverage": [epoch.to_dict() for epoch in epoch_coverage],
+                "max_continuity_epoch_seconds": max_continuity_epoch_seconds,
+                "quality_reports": quality_report_paths,
+                "raw_path": str(raw_evidence.path),
+                "raw_manifest": str(raw_evidence.manifest_path),
+                "raw_manifest_sha256": raw_evidence.manifest_sha256,
+                "normalized_dataset_manifests": dataset_manifests,
+                "max_buffered_rows_per_dataset": {
+                    name: spool.max_buffered_rows for name, spool in spools.items()
+                },
+                "max_buffered_estimated_bytes_per_dataset": {
+                    name: spool.max_buffered_estimated_bytes for name, spool in spools.items()
+                },
+                "policy": (
+                    "every continuity transition receives a fresh snapshot; every captured "
+                    "delta is normalized, and non-observed deltas are counted or gap-audited"
+                ),
+            }
+            # The capture-ID-specific completion marker is authoritative and published last.
+            write_json(summary_path, summary_payload)
+            with suppress(BaseException):
+                write_json(
+                    quality_root / "live_depth_capture.summary.json",
+                    {
+                        **summary_payload,
+                        "capture_status": "LATEST_POINTER",
+                        "latest_capture_status": summary_payload["capture_status"],
+                        "authoritative_summary_path": str(summary_path),
+                        "authoritative_summary_sha256": sha256_file(summary_path),
+                    },
+                )
+            return DepthCaptureResult(
+                symbol=symbol,
+                messages=raw_spool.messages,
+                continuity_epochs=continuity_epochs,
+                reconstruction_status=status,
+                book_observations=spools["book_observations"].rows,
+                sequence_gaps=spools["sequence_gaps"].rows,
+                stale_events=stale_events,
+                excluded_messages=excluded_messages,
+                final_update_id=final_update_id,
+                quality_errors=quality_errors,
+                quality_warnings=quality_warnings,
+                raw_path=raw_evidence.path,
+                raw_manifest_path=raw_evidence.manifest_path,
+                raw_manifest_sha256=raw_evidence.manifest_sha256,
+                summary_path=summary_path,
+                completion_reason=capture_stop.reason,
+                requested_duration_seconds=duration_seconds,
+                elapsed_monotonic_seconds=capture_stop.elapsed_monotonic_seconds,
+                receipt_coverage_seconds=receipt_coverage_seconds,
+                max_continuity_epoch_seconds=max_continuity_epoch_seconds,
+            )
+        except BaseException as error:
+            if raw_evidence is None:
+                try:
+                    raw_evidence = raw_spool.publish(
+                        status="incomplete_capture_failure",
+                        error=error,
+                    )
+                except BaseException:
+                    raw_spool.close_without_deleting()
+            else:
+                with suppress(BaseException):
+                    raw_evidence = raw_spool.publish(
+                        status="normalization_failure",
+                        error=error,
+                    )
+            with suppress(BaseException):
+                _failure_record(
+                    output_root=output_root,
+                    capture_id=capture_id,
+                    symbol=symbol,
+                    raw_spool=raw_spool,
+                    raw_evidence=raw_evidence,
+                    error=error,
+                )
+            raise
+        finally:
+            for spool in spools.values():
+                with suppress(BaseException):
+                    spool.close()
+            if not validators_finished:
+                delta_validator.close()
+                observation_validator.close()
+
+
+def _cmd_collect_l2(args: argparse.Namespace) -> int:
+    output_root = Path(args.output_root).resolve()
+    result = asyncio.run(
+        _capture_depth(
+            symbol=str(args.symbol).upper(),
+            max_messages=int(args.max_messages),
+            output_root=output_root,
+            duration_seconds=(
+                float(args.duration_seconds) if args.duration_seconds is not None else None
+            ),
+        )
+    )
+    _print_json(
+        {
+            "symbol": result.symbol,
+            "messages": result.messages,
+            "reconstruction_status": result.reconstruction_status,
+            "book_observations": result.book_observations,
+            "sequence_gaps": result.sequence_gaps,
+            "stale_events": result.stale_events,
+            "excluded_messages": result.excluded_messages,
+            "final_update_id": result.final_update_id,
+            "quality_errors": result.quality_errors,
+            "quality_warnings": result.quality_warnings,
+            "raw_manifest": result.raw_manifest_path,
+            "raw_manifest_sha256": result.raw_manifest_sha256,
+            "capture_summary": result.summary_path,
+            "completion_reason": result.completion_reason,
+            "requested_duration_seconds": result.requested_duration_seconds,
+            "elapsed_monotonic_seconds": result.elapsed_monotonic_seconds,
+            "receipt_coverage_seconds": result.receipt_coverage_seconds,
+            "max_continuity_epoch_seconds": result.max_continuity_epoch_seconds,
+            "output_root": output_root,
+            "live_trading": False,
+        }
+    )
+    return 0 if result.reconstruction_status == "LIVE" and result.quality_errors == 0 else 1
+
+
+def _m8_l2_session_payload(result: M8L2SessionBundle) -> dict[str, object]:
+    return {
+        "status": result.status,
+        "session_id": result.session_id,
+        "session_date": result.session_date,
+        "role": result.role,
+        "output_root": result.root,
+        "session_manifest": result.manifest_path,
+        "session_manifest_sha256": result.manifest_sha256,
+        "checksums": result.checksum_path,
+        "terminal_marker": result.marker_path,
+        "reason_codes": list(getattr(result, "reason_codes", ())),
+        "source": "binance_spot_public_live_diff_depth",
+        "live_trading": False,
+    }
+
+
+def _cmd_capture_m8_l2_session(args: argparse.Namespace) -> int:
+    config = load_m8_l2_config(args.config)
+    result = asyncio.run(
+        capture_m8_l2_session(
+            config,
+            str(args.date),
+            Path(args.output_root).resolve(),
+            BinanceM8L2Capture(),
+        )
+    )
+    _print_json(_m8_l2_session_payload(result))
+    return 0 if result.status == "COMPLETE" else 1
+
+
+def _cmd_verify_m8_l2_session(args: argparse.Namespace) -> int:
+    config = load_m8_l2_config(args.config)
+    result = verify_m8_l2_session_bundle(args.bundle_dir, expected_config=config)
+    payload = _m8_l2_session_payload(result)
+    payload["integrity"] = "verified"
+    _print_json(payload)
+    return 0
+
+
+def _m8_l2_development_payload(
+    result: L2DevelopmentLockResult,
+    *,
+    integrity: str | None = None,
+) -> dict[str, object]:
+    payload: dict[str, object] = {
+        "status": getattr(result, "status", "LOCKED"),
+        "development_lock_dir": result.root,
+        "development_lock": result.aggregate_path,
+        "development_lock_sha256": result.aggregate_sha256,
+        "terminal_marker": result.marker_path,
+        "created_at_utc": result.created_at_utc,
+        "children": [
+            {
+                "symbol": child.symbol,
+                "endpoint": child.endpoint,
+                "lock": child.path,
+                "lock_sha256": child.sha256,
+                "selection_lock_sha256": child.selection_lock_sha256,
+                "fitted_state_sha256": child.fitted_state_sha256,
+            }
+            for child in result.children
+        ],
+        "reason_codes": list(getattr(result, "reason_codes", ())),
+        "heldout_accessed": False,
+        "source": "binance_spot_public_live_diff_depth",
+        "live_trading": False,
+    }
+    if integrity is not None:
+        payload["integrity"] = integrity
+    return payload
+
+
+def _verify_m8_l2_session_authority(
+    bundle_dir: Path,
+    *,
+    expected_config: M8L2StudyConfig,
+    expected_date: str,
+    expected_role: str,
+    manifest_sha256: str,
+    checksums_sha256: str,
+) -> M8L2SessionBundle:
+    bundle = verify_m8_l2_session_bundle(bundle_dir, expected_config=expected_config)
+    if bundle.session_date != expected_date or bundle.role != expected_role:
+        raise ValueError(
+            f"explicit L2 session coordinate differs from {expected_date} {expected_role}"
+        )
+    if bundle.manifest_sha256 != manifest_sha256:
+        raise ValueError(f"explicit {expected_role} session manifest differs from expected SHA-256")
+    if sha256_file(bundle.checksum_path) != checksums_sha256:
+        raise ValueError(f"explicit {expected_role} session checksums differ from expected SHA-256")
+    return bundle
+
+
+def _m8_l2_insufficient_development_payload(
+    sessions: Sequence[M8L2SessionBundle],
+) -> dict[str, object]:
+    return {
+        "status": "INSUFFICIENT_DATA",
+        "stage": "development_lock",
+        "reason_code": "DEVELOPMENT_SESSION_NOT_COMPLETE",
+        "sessions": [
+            {
+                "session_id": session.session_id,
+                "session_date": session.session_date,
+                "role": session.role,
+                "status": session.status,
+                "session_manifest": session.manifest_path,
+                "session_manifest_sha256": session.manifest_sha256,
+                "checksums": session.checksum_path,
+                "checksums_sha256": sha256_file(session.checksum_path),
+                "reason_codes": list(session.reason_codes),
+            }
+            for session in sessions
+        ],
+        "heldout_accessed": False,
+        "source": "binance_spot_public_live_diff_depth",
+        "live_trading": False,
+    }
+
+
+def _development_session_authorities(
+    args: argparse.Namespace,
+) -> dict[str, L2SessionFileAuthority]:
+    return {
+        "2026-08-10": L2SessionFileAuthority(
+            manifest_sha256=args.train_manifest_sha256,
+            checksums_sha256=args.train_checksums_sha256,
+        ),
+        "2026-08-11": L2SessionFileAuthority(
+            manifest_sha256=args.validation_manifest_sha256,
+            checksums_sha256=args.validation_checksums_sha256,
+        ),
+    }
+
+
+def _explicit_development_input_loader(
+    authorities: Mapping[str, L2SessionFileAuthority],
+) -> L2DevelopmentInputVerifier:
+    def load(
+        bundle_dir: str | Path,
+        *,
+        expected_config: M8L2StudyConfig,
+        expected_date: str,
+        expected_role: str,
+        expected_file_authority: object | None = None,
+        expected_campaign: object | None = None,
+    ) -> Any:
+        authority = authorities.get(expected_date)
+        if authority is None:
+            raise ValueError("development input date is outside the explicit authority set")
+        if expected_role not in ("train", "validation"):
+            raise ValueError("development input role is outside the explicit authority set")
+        if expected_file_authority is not None and expected_file_authority != authority:
+            raise ValueError("development input authority differs from the explicit CLI authority")
+        return verify_m8_l2_development_input(
+            bundle_dir,
+            expected_config=expected_config,
+            expected_date=expected_date,
+            expected_role=cast(Literal["train", "validation"], expected_role),
+            expected_file_authority=authority,
+            expected_campaign=cast(L2CampaignRuntimeIdentity | None, expected_campaign),
+        )
+
+    return load
+
+
+def _load_explicit_development_sessions(
+    args: argparse.Namespace,
+    capture_config: M8L2StudyConfig,
+) -> tuple[M8L2SessionBundle, M8L2SessionBundle]:
+    train = _verify_m8_l2_session_authority(
+        args.train_bundle_dir.absolute(),
+        expected_config=capture_config,
+        expected_date="2026-08-10",
+        expected_role="train",
+        manifest_sha256=args.train_manifest_sha256,
+        checksums_sha256=args.train_checksums_sha256,
+    )
+    validation = _verify_m8_l2_session_authority(
+        args.validation_bundle_dir.absolute(),
+        expected_config=capture_config,
+        expected_date="2026-08-11",
+        expected_role="validation",
+        manifest_sha256=args.validation_manifest_sha256,
+        checksums_sha256=args.validation_checksums_sha256,
+    )
+    return train, validation
+
+
+def _cmd_lock_m8_l2_development(args: argparse.Namespace) -> int:
+    capture_config = load_m8_l2_config(args.capture_config)
+    analysis_config = load_m8_l2_analysis_config(args.analysis_config)
+    _load_explicit_development_sessions(args, capture_config)
+    result = lock_m8_l2_development(
+        capture_config,
+        analysis_config,
+        args.train_bundle_dir.absolute(),
+        args.validation_bundle_dir.absolute(),
+        args.lock_dir.absolute(),
+        input_loader=_explicit_development_input_loader(_development_session_authorities(args)),
+        expected_session_file_authorities=_development_session_authorities(args),
+    )
+    _print_json(_m8_l2_development_payload(result))
+    return 0 if getattr(result, "status", "LOCKED") == "LOCKED" else 1
+
+
+def _cmd_verify_m8_l2_development_lock(args: argparse.Namespace) -> int:
+    capture_config = load_m8_l2_config(args.capture_config)
+    analysis_config = load_m8_l2_analysis_config(args.analysis_config)
+    _load_explicit_development_sessions(args, capture_config)
+    result = verify_m8_l2_development_lock(
+        capture_config,
+        analysis_config,
+        args.train_bundle_dir.absolute(),
+        args.validation_bundle_dir.absolute(),
+        args.lock_dir.absolute(),
+        expected_lock_sha256=args.development_lock_sha256,
+    )
+    _print_json(_m8_l2_development_payload(result, integrity="verified"))
+    return 0 if getattr(result, "status", "LOCKED") == "LOCKED" else 1
+
+
+def _m8_l2_study_authorities(
+    args: argparse.Namespace,
+) -> tuple[
+    L2StudySessionAuthority,
+    L2StudySessionAuthority,
+    L2StudySessionAuthority,
+    L2StudySessionAuthority,
+]:
+    def authority(role: str) -> L2StudySessionAuthority:
+        return L2StudySessionAuthority(
+            bundle_path=getattr(args, f"{role}_bundle_dir").absolute(),
+            manifest_sha256=getattr(args, f"{role}_manifest_sha256"),
+            checksums_sha256=getattr(args, f"{role}_checksums_sha256"),
+        )
+
+    return (
+        authority("train"),
+        authority("validation"),
+        authority("primary"),
+        authority("replication"),
+    )
+
+
+def _m8_l2_study_payload(
+    result: M8L2StudyRunResult,
+    *,
+    integrity: str | None = None,
+) -> dict[str, object]:
+    payload: dict[str, object] = {
+        "status": result.status,
+        "run_dir": result.root,
+        "run_manifest": result.manifest_path,
+        "run_manifest_sha256": result.manifest_sha256,
+        "checksums": result.checksum_path,
+        "checksums_sha256": result.checksum_sha256,
+        "terminal_marker": result.marker_path,
+        "reason_codes": list(result.reason_codes),
+        "source": "binance_spot_public_live_diff_depth",
+        "live_trading": False,
+    }
+    if integrity is not None:
+        payload["integrity"] = integrity
+    return payload
+
+
+def _m8_l2_study_arguments(
+    args: argparse.Namespace,
+    capture_config: M8L2StudyConfig,
+    analysis_config: M8L2AnalysisConfig,
+) -> tuple[
+    M8L2StudyConfig,
+    M8L2AnalysisConfig,
+    L2StudySessionAuthority,
+    L2StudySessionAuthority,
+    Path,
+    str,
+    L2StudySessionAuthority,
+    L2StudySessionAuthority,
+    Path,
+]:
+    train, validation, primary, replication = _m8_l2_study_authorities(args)
+    return (
+        capture_config,
+        analysis_config,
+        train,
+        validation,
+        args.development_lock_dir.absolute(),
+        args.development_lock_sha256,
+        primary,
+        replication,
+        args.run_dir.absolute(),
+    )
+
+
+def _cmd_reproduce_m8_l2(args: argparse.Namespace) -> int:
+    capture_config = load_m8_l2_config(args.capture_config)
+    analysis_config = load_m8_l2_analysis_config(args.analysis_config)
+    result = reproduce_m8_l2_study(*_m8_l2_study_arguments(args, capture_config, analysis_config))
+    _print_json(_m8_l2_study_payload(result))
+    return 0 if result.status == "COMPLETE" else 1
+
+
+def _verify_m8_l2_study_from_args(
+    args: argparse.Namespace,
+    *,
+    capture_config: M8L2StudyConfig,
+    analysis_config: M8L2AnalysisConfig,
+) -> M8L2StudyRunResult:
+    return verify_m8_l2_study_run(
+        *_m8_l2_study_arguments(args, capture_config, analysis_config),
+        expected_manifest_sha256=args.run_manifest_sha256,
+        expected_checksums_sha256=args.run_checksums_sha256,
+    )
+
+
+def _cmd_verify_m8_l2_run(args: argparse.Namespace) -> int:
+    capture_config = load_m8_l2_config(args.capture_config)
+    analysis_config = load_m8_l2_analysis_config(args.analysis_config)
+    result = _verify_m8_l2_study_from_args(
+        args,
+        capture_config=capture_config,
+        analysis_config=analysis_config,
+    )
+    _print_json(_m8_l2_study_payload(result, integrity="verified"))
+    return 0 if result.status == "COMPLETE" else 1
+
+
+def _cmd_report_m8_l2(args: argparse.Namespace) -> int:
+    capture_config = load_m8_l2_config(args.capture_config)
+    analysis_config = load_m8_l2_analysis_config(args.analysis_config)
+    positional = _m8_l2_study_arguments(args, capture_config, analysis_config)
+    result = verify_m8_l2_study_run(
+        *positional,
+        expected_manifest_sha256=args.run_manifest_sha256,
+        expected_checksums_sha256=args.run_checksums_sha256,
+    )
+    output = _external_report_dir(result.root, args.output_dir)
+    report_data = load_m8_l2_report_data(
+        *positional,
+        expected_manifest_sha256=args.run_manifest_sha256,
+        expected_checksums_sha256=args.run_checksums_sha256,
+    )
+    technical, memo, comparison = write_l2_report_set(output, report_data)
+    payload = _m8_l2_study_payload(result, integrity="verified")
+    payload.update(
+        {
+            "output_dir": output,
+            "technical_report": technical,
+            "executive_memo": memo,
+            "model_comparison": comparison,
+            "report_inputs_sha256": canonical_report_data_sha256(report_data),
+            "source_bundle_modified": False,
+        }
+    )
+    _print_json(payload)
+    return 0 if result.status == "COMPLETE" else 1
+
+
+def _add_m8_l2_development_authority_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--capture-config", required=True, type=Path)
+    parser.add_argument("--analysis-config", required=True, type=Path)
+    parser.add_argument("--train-bundle-dir", required=True, type=Path)
+    parser.add_argument(
+        "--train-manifest-sha256",
+        required=True,
+        type=_lowercase_sha256,
+    )
+    parser.add_argument(
+        "--train-checksums-sha256",
+        required=True,
+        type=_lowercase_sha256,
+    )
+    parser.add_argument("--validation-bundle-dir", required=True, type=Path)
+    parser.add_argument(
+        "--validation-manifest-sha256",
+        required=True,
+        type=_lowercase_sha256,
+    )
+    parser.add_argument(
+        "--validation-checksums-sha256",
+        required=True,
+        type=_lowercase_sha256,
+    )
+    parser.add_argument("--lock-dir", required=True, type=Path)
+
+
+def _add_m8_l2_study_authority_args(
+    parser: argparse.ArgumentParser,
+    *,
+    require_run_authority: bool,
+) -> None:
+    parser.add_argument("--capture-config", required=True, type=Path)
+    parser.add_argument("--analysis-config", required=True, type=Path)
+    for role in ("train", "validation", "primary", "replication"):
+        parser.add_argument(f"--{role}-bundle-dir", required=True, type=Path)
+        parser.add_argument(
+            f"--{role}-manifest-sha256",
+            required=True,
+            type=_lowercase_sha256,
+        )
+        parser.add_argument(
+            f"--{role}-checksums-sha256",
+            required=True,
+            type=_lowercase_sha256,
+        )
+    parser.add_argument("--development-lock-dir", required=True, type=Path)
+    parser.add_argument(
+        "--development-lock-sha256",
+        required=True,
+        type=_lowercase_sha256,
+    )
+    parser.add_argument("--run-dir", required=True, type=Path)
+    if require_run_authority:
+        parser.add_argument(
+            "--run-manifest-sha256",
+            required=True,
+            type=_lowercase_sha256,
+        )
+        parser.add_argument(
+            "--run-checksums-sha256",
+            required=True,
+            type=_lowercase_sha256,
+        )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="microstructure",
+        description="Research-only event-driven market-microstructure system",
+    )
+    parser.add_argument("--version", action="version", version=__version__)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    ingest = subparsers.add_parser("ingest", help="ingest configured synthetic or public data")
+    ingest.add_argument("--config", required=True, type=Path)
+    ingest.add_argument("--output-root", type=Path)
+    ingest.set_defaults(handler=_cmd_ingest)
+
+    acquire_m8 = subparsers.add_parser(
+        "acquire-m8",
+        help="acquire raw M8 evidence without opening any archive CSV member",
+    )
+    acquire_m8.add_argument("--config", required=True, type=Path)
+    acquire_m8.add_argument("--output-root", required=True, type=Path)
+    acquire_m8.set_defaults(handler=_cmd_acquire_m8)
+
+    validate = subparsers.add_parser("validate", help="run non-mutating data validation")
+    validate.add_argument("--config", required=True, type=Path)
+    validate.set_defaults(handler=_cmd_validate)
+
+    reproduce_parser = subparsers.add_parser(
+        "reproduce", help="produce or verify an immutable end-to-end sample run"
+    )
+    reproduce_parser.add_argument("--config", required=True, type=Path)
+    reproduce_parser.add_argument("--run-dir", required=True, type=Path)
+    reproduce_parser.add_argument(
+        "--ingestion-manifest",
+        type=Path,
+        help="explicit public ingestion manifest; required with its SHA-256 for public mode",
+    )
+    reproduce_parser.add_argument(
+        "--ingestion-manifest-sha256",
+        help="SHA-256 of --ingestion-manifest; required for public mode",
+    )
+    reproduce_parser.set_defaults(handler=_cmd_reproduce)
+
+    reproduce_m8_parser = subparsers.add_parser(
+        "reproduce-m8",
+        help="produce the frozen M8 study from one explicit raw acquisition authority",
+    )
+    reproduce_m8_parser.add_argument("--config", required=True, type=Path)
+    reproduce_m8_parser.add_argument("--run-dir", required=True, type=Path)
+    reproduce_m8_parser.add_argument("--raw-manifest", required=True, type=Path)
+    reproduce_m8_parser.add_argument(
+        "--raw-manifest-sha256",
+        required=True,
+        type=_lowercase_sha256,
+    )
+    reproduce_m8_parser.set_defaults(handler=_cmd_reproduce_m8)
+
+    verify_m8_parser = subparsers.add_parser(
+        "verify-m8",
+        help="verify a complete or INSUFFICIENT_DATA M8 result and its raw authority",
+    )
+    verify_m8_parser.add_argument("--config", required=True, type=Path)
+    verify_m8_parser.add_argument("--run-dir", required=True, type=Path)
+    verify_m8_parser.add_argument("--raw-manifest", required=True, type=Path)
+    verify_m8_parser.add_argument(
+        "--raw-manifest-sha256",
+        required=True,
+        type=_lowercase_sha256,
+    )
+    verify_m8_parser.set_defaults(handler=_cmd_verify_m8)
+
+    report_m8_parser = subparsers.add_parser(
+        "report-m8",
+        help="render a complete M8 result or expose its frozen failure report",
+    )
+    report_m8_parser.add_argument("--config", required=True, type=Path)
+    report_m8_parser.add_argument("--run-dir", required=True, type=Path)
+    report_m8_parser.add_argument("--raw-manifest", required=True, type=Path)
+    report_m8_parser.add_argument(
+        "--raw-manifest-sha256",
+        required=True,
+        type=_lowercase_sha256,
+    )
+    report_m8_parser.add_argument("--output-dir", type=Path)
+    report_m8_parser.set_defaults(handler=_cmd_report_m8)
+
+    verify = subparsers.add_parser("verify", help="verify a frozen run and all checksums")
+    verify.add_argument("--run-dir", required=True, type=Path)
+    verify.set_defaults(handler=_cmd_verify)
+
+    report = subparsers.add_parser("report", help="render reports from a frozen run")
+    report.add_argument("--run-dir", required=True, type=Path)
+    report.add_argument("--output-dir", type=Path)
+    report.set_defaults(handler=_cmd_report)
+
+    collect = subparsers.add_parser(
+        "collect-l2", help="capture and reconstruct public live L2 data; never place orders"
+    )
+    collect.add_argument("--symbol", choices=("BTCUSDT", "ETHUSDT"), required=True)
+    collect.add_argument("--max-messages", type=int, default=1_000)
+    collect.add_argument(
+        "--duration-seconds",
+        type=float,
+        help=(
+            "gracefully complete after this wall duration; max-messages remains a safety "
+            "ceiling and fails the capture if reached first"
+        ),
+    )
+    collect.add_argument("--output-root", type=Path, default=Path("data"))
+    collect.set_defaults(handler=_cmd_collect_l2)
+
+    capture_m8_l2 = subparsers.add_parser(
+        "capture-m8-l2-session",
+        help="capture one frozen concurrent BTCUSDT/ETHUSDT prospective L2 session",
+    )
+    capture_m8_l2.add_argument("--config", required=True, type=Path)
+    capture_m8_l2.add_argument("--date", required=True)
+    capture_m8_l2.add_argument("--output-root", required=True, type=Path)
+    capture_m8_l2.set_defaults(handler=_cmd_capture_m8_l2_session)
+
+    verify_m8_l2 = subparsers.add_parser(
+        "verify-m8-l2-session",
+        help="verify a complete or INSUFFICIENT_DATA frozen L2 session bundle",
+    )
+    verify_m8_l2.add_argument("--config", required=True, type=Path)
+    verify_m8_l2.add_argument("--bundle-dir", required=True, type=Path)
+    verify_m8_l2.set_defaults(handler=_cmd_verify_m8_l2_session)
+
+    lock_m8_l2_development_parser = subparsers.add_parser(
+        "lock-m8-l2-development",
+        help="fit and freeze the Aug 8/9 L2 development state before held-out access",
+    )
+    _add_m8_l2_development_authority_args(lock_m8_l2_development_parser)
+    lock_m8_l2_development_parser.set_defaults(handler=_cmd_lock_m8_l2_development)
+
+    verify_m8_l2_development_parser = subparsers.add_parser(
+        "verify-m8-l2-development-lock",
+        help="verify the frozen L2 development lock and its explicit session authorities",
+    )
+    _add_m8_l2_development_authority_args(verify_m8_l2_development_parser)
+    verify_m8_l2_development_parser.add_argument(
+        "--development-lock-sha256",
+        required=True,
+        type=_lowercase_sha256,
+    )
+    verify_m8_l2_development_parser.set_defaults(handler=_cmd_verify_m8_l2_development_lock)
+
+    reproduce_m8_l2_parser = subparsers.add_parser(
+        "reproduce-m8-l2",
+        help="produce the frozen four-session prospective live-L2 study",
+    )
+    _add_m8_l2_study_authority_args(
+        reproduce_m8_l2_parser,
+        require_run_authority=False,
+    )
+    reproduce_m8_l2_parser.set_defaults(handler=_cmd_reproduce_m8_l2)
+
+    verify_m8_l2_run_parser = subparsers.add_parser(
+        "verify-m8-l2-run",
+        help="verify a terminal live-L2 study and all external authorities",
+    )
+    _add_m8_l2_study_authority_args(
+        verify_m8_l2_run_parser,
+        require_run_authority=True,
+    )
+    verify_m8_l2_run_parser.set_defaults(handler=_cmd_verify_m8_l2_run)
+
+    report_m8_l2_parser = subparsers.add_parser(
+        "report-m8-l2",
+        help="render verified live-L2 report inputs outside the immutable run bundle",
+    )
+    _add_m8_l2_study_authority_args(
+        report_m8_l2_parser,
+        require_run_authority=True,
+    )
+    report_m8_l2_parser.add_argument("--output-dir", required=True, type=Path)
+    report_m8_l2_parser.set_defaults(handler=_cmd_report_m8_l2)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if getattr(args, "max_messages", 1) < 1:
+        parser.error("--max-messages must be positive")
+    duration_seconds = getattr(args, "duration_seconds", None)
+    if duration_seconds is not None and duration_seconds <= 0:
+        parser.error("--duration-seconds must be positive")
+    handler = args.handler
+    try:
+        return int(handler(args))
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        print("operation canceled", file=sys.stderr)
+        return 130
+    except Exception as error:
+        print(f"error: {error}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

Microstructure/src/microstructure/config.py

@@ -0,0 +1,341 @@
+"""Typed project configuration with deterministic hashing."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import re
+import tomllib
+from collections.abc import Mapping
+from dataclasses import asdict, dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, Literal, cast
+
+from microstructure.data.schemas import SCHEMA_VERSION
+
+
+class ConfigError(ValueError):
+    """Raised when a project configuration is internally inconsistent."""
+
+
+EvidenceTier = Literal["SYNTHETIC_SMOKE", "PUBLIC_SAMPLE_PARTIAL", "FULL_DATA"]
+# Adapter modes are intentionally open-ended: ingestion owns the fail-closed
+# registry, while configuration validates a stable identifier that third-party
+# adapters can use.  Built-in modes retain their source-specific checks below.
+DataMode = str
+_DATA_MODE_PATTERN = re.compile(r"[a-z][a-z0-9_.-]{0,63}")
+
+
+def _utc_datetime(value: str) -> datetime:
+    parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    if parsed.tzinfo is None:
+        raise ConfigError(f"timestamp must include a UTC offset: {value!r}")
+    return parsed.astimezone(UTC)
+
+
+@dataclass(frozen=True, slots=True)
+class RunConfig:
+    name: str
+    evidence_tier: EvidenceTier
+    seed: int
+
+
+@dataclass(frozen=True, slots=True)
+class DataConfig:
+    mode: DataMode
+    source: str
+    symbols: tuple[str, ...]
+    start: datetime
+    end: datetime | None
+    events_per_symbol: int | None
+    max_events_per_symbol: int | None
+    raw_root: Path
+    partition_root: Path
+    schema_version: str
+    base_url: str
+    request_limit: int
+    timeout_seconds: float
+    max_retries: int
+
+
+@dataclass(frozen=True, slots=True)
+class QualityConfig:
+    max_spread_bps: float
+    max_silence_ms: int
+    fail_on_error: bool
+
+
+@dataclass(frozen=True, slots=True)
+class FeatureConfig:
+    trade_windows: tuple[int, ...]
+    volatility_window: int
+    intensity_window: int
+    label_horizon_events: int
+    large_trade_quantile: float
+
+
+@dataclass(frozen=True, slots=True)
+class EvaluationConfig:
+    min_train_events: int
+    validation_events: int
+    test_events: int
+    step_events: int
+    embargo_events: int
+    bootstrap_samples: int
+    calibration_bins: int
+
+
+@dataclass(frozen=True, slots=True)
+class ModelConfig:
+    selection_metric: str
+    logistic_c_values: tuple[float, ...]
+    tree_max_depth_values: tuple[int, ...]
+    tree_min_samples_leaf: int
+
+
+@dataclass(frozen=True, slots=True)
+class ExecutionConfig:
+    decision_latency_events: int
+    order_latency_events: int
+    maker_fee_bps: float
+    taker_fee_bps: float
+    half_spread_bps: float
+    slippage_bps_per_unit: float
+    signal_threshold: float
+    max_position_units: float
+    order_size_units: float
+    limit_fill_base_probability: float
+    queue_ahead_units: float
+    limit_max_age_events: int
+    cancel_latency_events: int
+    liquidate_at_end: bool
+    capacity_multipliers: tuple[float, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class ProjectConfig:
+    path: Path
+    project_root: Path
+    run: RunConfig
+    data: DataConfig
+    quality: QualityConfig
+    features: FeatureConfig
+    evaluation: EvaluationConfig
+    models: ModelConfig
+    execution: ExecutionConfig
+    canonical: Mapping[str, Any]
+
+    @property
+    def hash(self) -> str:
+        """Return a stable SHA-256 hash of the source configuration."""
+        payload = json.dumps(self.canonical, sort_keys=True, separators=(",", ":"))
+        return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+    def public_dict(self) -> dict[str, Any]:
+        """Return a JSON-safe representation with resolved paths and timestamps."""
+        result = asdict(self)
+        result.pop("canonical")
+        result["path"] = str(self.path)
+        result["project_root"] = str(self.project_root)
+        data = cast(dict[str, Any], result["data"])
+        data["start"] = self.data.start.isoformat().replace("+00:00", "Z")
+        data["end"] = self.data.end.isoformat().replace("+00:00", "Z") if self.data.end else None
+        data["raw_root"] = str(self.data.raw_root)
+        data["partition_root"] = str(self.data.partition_root)
+        return result
+
+
+def _section(raw: Mapping[str, Any], name: str) -> Mapping[str, Any]:
+    value = raw.get(name)
+    if not isinstance(value, Mapping):
+        raise ConfigError(f"missing TOML section [{name}]")
+    return cast(Mapping[str, Any], value)
+
+
+def _resolve(project_root: Path, value: str) -> Path:
+    candidate = Path(value)
+    return candidate if candidate.is_absolute() else (project_root / candidate).resolve()
+
+
+def load_config(path: str | Path) -> ProjectConfig:
+    """Load and validate a project TOML configuration."""
+    config_path = Path(path).resolve()
+    with config_path.open("rb") as handle:
+        raw: dict[str, Any] = tomllib.load(handle)
+
+    project_root = config_path.parent.parent.resolve()
+    run_raw = _section(raw, "run")
+    data_raw = _section(raw, "data")
+    quality_raw = _section(raw, "quality")
+    feature_raw = _section(raw, "features")
+    evaluation_raw = _section(raw, "evaluation")
+    model_raw = _section(raw, "models")
+    execution_raw = _section(raw, "execution")
+
+    evidence_tier = str(run_raw["evidence_tier"])
+    if evidence_tier not in {"SYNTHETIC_SMOKE", "PUBLIC_SAMPLE_PARTIAL", "FULL_DATA"}:
+        raise ConfigError(f"unsupported evidence tier: {evidence_tier}")
+    mode = str(data_raw["mode"])
+    if _DATA_MODE_PATTERN.fullmatch(mode) is None:
+        raise ConfigError(
+            "data.mode must be a lowercase adapter identifier containing only "
+            "letters, digits, underscores, dots, or hyphens"
+        )
+
+    start = _utc_datetime(str(data_raw["start"]))
+    end_value = data_raw.get("end")
+    end = _utc_datetime(str(end_value)) if end_value is not None else None
+    if end is not None and end <= start:
+        raise ConfigError("data.end must be after data.start")
+
+    run = RunConfig(
+        name=str(run_raw["name"]),
+        evidence_tier=cast(EvidenceTier, evidence_tier),
+        seed=int(run_raw["seed"]),
+    )
+    data = DataConfig(
+        mode=mode,
+        source=str(data_raw["source"]),
+        symbols=tuple(str(symbol).upper() for symbol in data_raw["symbols"]),
+        start=start,
+        end=end,
+        events_per_symbol=(
+            int(data_raw["events_per_symbol"])
+            if data_raw.get("events_per_symbol") is not None
+            else None
+        ),
+        max_events_per_symbol=(
+            int(data_raw["max_events_per_symbol"])
+            if data_raw.get("max_events_per_symbol") is not None
+            else None
+        ),
+        raw_root=_resolve(project_root, str(data_raw.get("raw_root", "data/raw"))),
+        partition_root=_resolve(project_root, str(data_raw["partition_root"])),
+        schema_version=str(data_raw["schema_version"]),
+        base_url=str(data_raw.get("base_url", "https://data-api.binance.vision")).rstrip("/"),
+        request_limit=int(data_raw.get("request_limit", 1000)),
+        timeout_seconds=float(data_raw.get("timeout_seconds", 30.0)),
+        max_retries=int(data_raw.get("max_retries", 5)),
+    )
+    quality = QualityConfig(
+        max_spread_bps=float(quality_raw["max_spread_bps"]),
+        max_silence_ms=int(quality_raw["max_silence_ms"]),
+        fail_on_error=bool(quality_raw["fail_on_error"]),
+    )
+    features = FeatureConfig(
+        trade_windows=tuple(int(window) for window in feature_raw["trade_windows"]),
+        volatility_window=int(feature_raw["volatility_window"]),
+        intensity_window=int(feature_raw["intensity_window"]),
+        label_horizon_events=int(feature_raw["label_horizon_events"]),
+        large_trade_quantile=float(feature_raw["large_trade_quantile"]),
+    )
+    evaluation = EvaluationConfig(
+        min_train_events=int(evaluation_raw["min_train_events"]),
+        validation_events=int(evaluation_raw["validation_events"]),
+        test_events=int(evaluation_raw["test_events"]),
+        step_events=int(evaluation_raw["step_events"]),
+        embargo_events=int(evaluation_raw["embargo_events"]),
+        bootstrap_samples=int(evaluation_raw["bootstrap_samples"]),
+        calibration_bins=int(evaluation_raw["calibration_bins"]),
+    )
+    models = ModelConfig(
+        selection_metric=str(model_raw["selection_metric"]),
+        logistic_c_values=tuple(float(value) for value in model_raw["logistic_c_values"]),
+        tree_max_depth_values=tuple(int(value) for value in model_raw["tree_max_depth_values"]),
+        tree_min_samples_leaf=int(model_raw["tree_min_samples_leaf"]),
+    )
+    execution = ExecutionConfig(
+        decision_latency_events=int(execution_raw["decision_latency_events"]),
+        order_latency_events=int(execution_raw["order_latency_events"]),
+        maker_fee_bps=float(execution_raw["maker_fee_bps"]),
+        taker_fee_bps=float(execution_raw["taker_fee_bps"]),
+        half_spread_bps=float(execution_raw["half_spread_bps"]),
+        slippage_bps_per_unit=float(execution_raw["slippage_bps_per_unit"]),
+        signal_threshold=float(execution_raw["signal_threshold"]),
+        max_position_units=float(execution_raw["max_position_units"]),
+        order_size_units=float(execution_raw["order_size_units"]),
+        limit_fill_base_probability=float(execution_raw["limit_fill_base_probability"]),
+        queue_ahead_units=float(execution_raw["queue_ahead_units"]),
+        limit_max_age_events=int(execution_raw["limit_max_age_events"]),
+        cancel_latency_events=int(execution_raw["cancel_latency_events"]),
+        liquidate_at_end=bool(execution_raw["liquidate_at_end"]),
+        capacity_multipliers=tuple(float(value) for value in execution_raw["capacity_multipliers"]),
+    )
+
+    if not data.symbols:
+        raise ConfigError("data.symbols must not be empty")
+    if data.mode == "synthetic" and (data.events_per_symbol is None or data.events_per_symbol < 1):
+        raise ConfigError("synthetic mode requires positive data.events_per_symbol")
+    if data.mode == "synthetic" and run.evidence_tier != "SYNTHETIC_SMOKE":
+        raise ConfigError("synthetic inputs must use the SYNTHETIC_SMOKE evidence tier")
+    if data.mode == "binance_rest" and run.evidence_tier == "SYNTHETIC_SMOKE":
+        raise ConfigError("public inputs cannot use the SYNTHETIC_SMOKE evidence tier")
+    if data.mode == "binance_rest" and data.end is None:
+        raise ConfigError("binance_rest mode requires a bounded data.end")
+    if data.mode == "binance_rest" and (
+        data.max_events_per_symbol is None or data.max_events_per_symbol < 1
+    ):
+        raise ConfigError("binance_rest mode requires positive data.max_events_per_symbol")
+    if data.schema_version != SCHEMA_VERSION:
+        raise ConfigError(
+            f"unsupported data.schema_version {data.schema_version!r}; expected {SCHEMA_VERSION!r}"
+        )
+    if not all(window > 1 for window in features.trade_windows):
+        raise ConfigError("all feature trade windows must exceed one event")
+    if features.label_horizon_events < 1:
+        raise ConfigError("label_horizon_events must be positive")
+    if evaluation.embargo_events < features.label_horizon_events:
+        raise ConfigError("embargo_events must cover label_horizon_events")
+    if not 0.5 < execution.signal_threshold < 1.0:
+        raise ConfigError("signal_threshold must be between 0.5 and 1.0")
+    if not 0.0 <= execution.limit_fill_base_probability <= 1.0:
+        raise ConfigError("limit_fill_base_probability must be in [0, 1]")
+    if execution.limit_max_age_events < 1 or execution.cancel_latency_events < 0:
+        raise ConfigError("limit order age must be positive and cancel latency nonnegative")
+    if execution.decision_latency_events < 0 or execution.order_latency_events < 0:
+        raise ConfigError("decision and order latency must be nonnegative")
+    if execution.max_position_units <= 0 or execution.order_size_units <= 0:
+        raise ConfigError("execution position and order sizes must be positive")
+    execution_floats = (
+        execution.maker_fee_bps,
+        execution.taker_fee_bps,
+        execution.half_spread_bps,
+        execution.slippage_bps_per_unit,
+        execution.max_position_units,
+        execution.order_size_units,
+        execution.queue_ahead_units,
+    )
+    if not all(math.isfinite(value) for value in execution_floats):
+        raise ConfigError("execution numeric assumptions must be finite")
+    if execution.queue_ahead_units < 0:
+        raise ConfigError("execution queue_ahead_units must be nonnegative")
+    if execution.half_spread_bps < 0 or execution.slippage_bps_per_unit < 0:
+        raise ConfigError("execution spread and slippage assumptions must be nonnegative")
+    if not execution.capacity_multipliers or not all(
+        math.isfinite(value) and value > 0 for value in execution.capacity_multipliers
+    ):
+        raise ConfigError("execution capacity_multipliers must be finite and positive")
+    if not 0.0 < features.large_trade_quantile < 1.0:
+        raise ConfigError("large_trade_quantile must lie strictly between zero and one")
+
+    return ProjectConfig(
+        path=config_path,
+        project_root=project_root,
+        run=run,
+        data=data,
+        quality=quality,
+        features=features,
+        evaluation=evaluation,
+        models=models,
+        execution=execution,
+        canonical=raw,
+    )
+
+
+def datetime_to_ns(value: datetime) -> int:
+    """Convert an aware UTC datetime to integer epoch nanoseconds."""
+    if value.tzinfo is None:
+        raise ConfigError("datetime must be timezone aware")
+    return int(value.timestamp() * 1_000_000_000)

Microstructure/src/microstructure/data/__init__.py

@@ -0,0 +1,33 @@
+"""Market-data ingestion, normalization, storage, and validation primitives.
+
+The package deliberately contains no authenticated or order-entry API.  Binance
+support is restricted to public market-data endpoints.
+"""
+
+from microstructure.data.book import (
+    BookSnapshot,
+    DepthDelta,
+    ReconstructionResult,
+    reconstruct_snapshot_and_deltas,
+)
+from microstructure.data.quality import QualityFinding, ValidationReport, validate_table
+from microstructure.data.schemas import SCHEMA_VERSION, get_schema, table_from_records
+from microstructure.data.storage import DatasetWriteResult, write_partitioned_parquet
+from microstructure.data.synthetic import SyntheticMarketData, generate_synthetic_market
+
+__all__ = [
+    "SCHEMA_VERSION",
+    "BookSnapshot",
+    "DatasetWriteResult",
+    "DepthDelta",
+    "QualityFinding",
+    "ReconstructionResult",
+    "SyntheticMarketData",
+    "ValidationReport",
+    "generate_synthetic_market",
+    "get_schema",
+    "reconstruct_snapshot_and_deltas",
+    "table_from_records",
+    "validate_table",
+    "write_partitioned_parquet",
+]

Microstructure/src/microstructure/data/binance.py

@@ -0,0 +1,1330 @@
+"""Public Binance Spot market-data adapters; no authenticated/trading endpoints."""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+import os
+import random
+import tempfile
+import time
+from collections.abc import AsyncIterator, Callable, Iterator, Mapping
+from contextlib import nullcontext
+from dataclasses import dataclass
+from decimal import Decimal, InvalidOperation
+from enum import StrEnum
+from pathlib import Path
+from typing import Any, Literal, Protocol, cast
+
+import pyarrow as pa  # type: ignore[import-untyped]
+import requests
+import websockets
+from websockets.exceptions import WebSocketException
+
+from microstructure.data.book import BookSnapshot, DepthDelta
+from microstructure.data.evidence_budget import RetainedEvidenceBudget
+from microstructure.data.schemas import SCHEMA_VERSION, get_schema, table_from_records
+from microstructure.data.storage import write_source_manifest
+from microstructure.provenance import sha256_file
+
+_NS_PER_MILLISECOND = 1_000_000
+_NS_PER_MICROSECOND = 1_000
+
+
+class BinanceError(RuntimeError):
+    """Base error for public Binance market-data collection."""
+
+
+class BinanceHTTPError(BinanceError):
+    """Raised when a public market-data GET cannot be completed safely."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int | None = None,
+        retry_exhausted: bool = False,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.retry_exhausted = retry_exhausted
+
+
+class BinancePayloadError(BinanceError):
+    """Raised when Binance returns malformed or scale-incompatible data."""
+
+    def __init__(self, message: str, *, transient: bool = False) -> None:
+        super().__init__(message)
+        self.transient = transient
+
+
+class BinanceMetadataContractError(BinancePayloadError):
+    """A bounded exchangeInfo response violates the declared metadata contract."""
+
+
+class BinanceResponseSizeLimitError(BinancePayloadError):
+    """A public response violates its frozen body-size contract."""
+
+
+@dataclass(frozen=True, slots=True)
+class RetryPolicy:
+    max_retries: int = 5
+    base_delay_seconds: float = 0.5
+    max_delay_seconds: float = 30.0
+
+    def __post_init__(self) -> None:
+        if self.max_retries < 0:
+            raise ValueError("max_retries must not be negative")
+        if self.base_delay_seconds < 0.0 or self.max_delay_seconds < 0.0:
+            raise ValueError("retry delays must not be negative")
+
+
+@dataclass(frozen=True, slots=True)
+class RawPage:
+    path: Path
+    manifest_path: Path
+    sha256: str
+    request_uri: str
+    row_count: int
+
+
+@dataclass(frozen=True, slots=True)
+class BinanceDownloadResult:
+    trades: pa.Table
+    raw_pages: tuple[RawPage, ...]
+    requested_start_ns: int
+    requested_end_ns: int
+    complete_range: bool
+
+
+class BinanceTradeStreamStopReason(StrEnum):
+    """Why a normally exhausted historical-trade stream stopped."""
+
+    EMPTY_PAGE = "empty_page"
+    SHORT_PAGE = "short_page"
+    RANGE_END = "range_end"
+    EVENT_CAP = "event_cap"
+
+
+@dataclass(frozen=True, slots=True)
+class BinanceTradeStreamSummary:
+    """Constant-size terminal metadata for a historical-trade stream."""
+
+    requested_start_ns: int
+    requested_end_ns: int
+    rows_yielded: int
+    raw_page_count: int
+    stop_reason: BinanceTradeStreamStopReason
+    complete_range: bool
+    last_raw_page: RawPage | None
+
+
+@dataclass(frozen=True, slots=True)
+class CapturedDepth:
+    raw_payload: str
+    delta: DepthDelta
+
+
+@dataclass(frozen=True, slots=True)
+class RawDepthFrame:
+    """One exact websocket frame timestamped before UTF-8/JSON normalization."""
+
+    payload: bytes
+    was_text: bool
+    received_ts_ns: int
+    capture_seq: int
+    continuity_id: str
+
+
+@dataclass(frozen=True, slots=True)
+class SymbolMetadata:
+    """Public symbol filters captured before tick/lot normalization."""
+
+    venue: str
+    symbol: str
+    status: str
+    base_asset: str
+    quote_asset: str
+    tick_size: Decimal
+    lot_size: Decimal
+    min_price: Decimal
+    max_price: Decimal
+    min_quantity: Decimal
+    max_quantity: Decimal
+    observed_ts_ns: int
+    source_artifact_id: str
+    source_path: Path
+    source_manifest_path: Path
+
+
+class _WebSocketConnection(Protocol):
+    def __aiter__(self) -> AsyncIterator[str | bytes]: ...
+
+
+class _WebSocketContext(Protocol):
+    async def __aenter__(self) -> _WebSocketConnection: ...
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: object | None,
+    ) -> bool | None: ...
+
+
+ConnectFactory = Callable[[str], _WebSocketContext]
+RawDepthFrameCallback = Callable[[RawDepthFrame], None]
+
+
+def _scaled_integer(value: str | Decimal, quantum: Decimal, label: str) -> int:
+    try:
+        decimal_value = value if isinstance(value, Decimal) else Decimal(value)
+        scaled = decimal_value / quantum
+    except (InvalidOperation, ZeroDivisionError) as exc:
+        raise BinancePayloadError(f"invalid {label}: {value!r}") from exc
+    integral = scaled.to_integral_value()
+    if scaled != integral:
+        raise BinancePayloadError(
+            f"{label} {decimal_value} is not aligned to configured scale {quantum}"
+        )
+    return int(integral)
+
+
+def _event_timestamp_ns(value: int, unit: Literal["ms", "us"]) -> int:
+    if value < 0:
+        raise BinancePayloadError("event timestamp must not be negative")
+    return value * (_NS_PER_MILLISECOND if unit == "ms" else _NS_PER_MICROSECOND)
+
+
+def _safe_response_headers(headers: Mapping[str, str]) -> dict[str, str]:
+    allowed = {"content-length", "content-type", "etag", "last-modified", "retry-after"}
+    return {
+        str(key): str(value)
+        for key, value in headers.items()
+        if key.lower() in allowed or key.lower().startswith("x-mbx-used-weight")
+    }
+
+
+def _close_response(response: object) -> None:
+    close = getattr(response, "close", None)
+    if callable(close):
+        cast(Callable[[], object], close)()
+
+
+def _fsync_directory(path: Path) -> None:
+    descriptor = os.open(path, os.O_RDONLY)
+    try:
+        os.fsync(descriptor)
+    finally:
+        os.close(descriptor)
+
+
+class BinancePublicClient:
+    """Retrying client for market-data-only GET endpoints."""
+
+    def __init__(
+        self,
+        *,
+        base_url: str = "https://data-api.binance.vision",
+        timeout_seconds: float = 30.0,
+        retry_policy: RetryPolicy | None = None,
+        session: requests.Session | None = None,
+        sleep: Callable[[float], None] = time.sleep,
+        random_value: Callable[[], float] = random.random,
+        max_response_bytes: int = 8 * 1024 * 1024,
+        retained_evidence_budget: RetainedEvidenceBudget | None = None,
+    ) -> None:
+        if max_response_bytes < 1:
+            raise ValueError("max_response_bytes must be positive")
+        self.base_url = base_url.rstrip("/")
+        self.timeout_seconds = timeout_seconds
+        self.retry_policy = retry_policy or RetryPolicy()
+        self.session = session or requests.Session()
+        self._sleep = sleep
+        self._random_value = random_value
+        self.max_response_bytes = max_response_bytes
+        self.retained_evidence_budget = retained_evidence_budget
+
+    def _session_get(
+        self,
+        url: str,
+        params: Mapping[str, str | int],
+        *,
+        stream_response: bool,
+    ) -> requests.Response:
+        if not stream_response:
+            return self.session.get(url, params=params, timeout=self.timeout_seconds)
+        try:
+            return self.session.get(
+                url,
+                params=params,
+                timeout=self.timeout_seconds,
+                stream=True,
+            )
+        except TypeError as exc:
+            # Older injected test sessions may implement only the original
+            # three-argument boundary.  Production requests.Session accepts
+            # ``stream`` and therefore always takes the bounded transport path.
+            if "unexpected keyword argument 'stream'" not in str(exc):
+                raise
+            return self.session.get(url, params=params, timeout=self.timeout_seconds)
+
+    def _request(
+        self,
+        path: str,
+        params: Mapping[str, str | int],
+        *,
+        stream_response: bool = False,
+    ) -> requests.Response:
+        url = f"{self.base_url}{path}"
+        last_error: BaseException | None = None
+        for attempt in range(self.retry_policy.max_retries + 1):
+            response: requests.Response | None = None
+            try:
+                response = self._session_get(
+                    url,
+                    params,
+                    stream_response=stream_response,
+                )
+            except requests.RequestException as exc:
+                last_error = exc
+                retryable = True
+            else:
+                if response.status_code == 200:
+                    return response
+                retryable = response.status_code in {408, 418, 429} or response.status_code >= 500
+                response_detail = (
+                    "response body intentionally not materialized"
+                    if stream_response
+                    else response.text[:200]
+                )
+                last_error = BinanceHTTPError(
+                    f"GET {response.url} returned HTTP {response.status_code}: {response_detail}",
+                    status_code=response.status_code,
+                )
+                if not retryable:
+                    _close_response(response)
+                    raise last_error
+
+            if not retryable or attempt >= self.retry_policy.max_retries:
+                if response is not None:
+                    _close_response(response)
+                break
+            retry_after: float | None = None
+            if response is not None and response.status_code in {418, 429}:
+                raw_retry_after = response.headers.get("Retry-After")
+                if raw_retry_after is not None:
+                    try:
+                        retry_after = max(0.0, float(raw_retry_after))
+                    except ValueError:
+                        retry_after = None
+            exponential_cap = min(
+                self.retry_policy.max_delay_seconds,
+                self.retry_policy.base_delay_seconds * (2**attempt),
+            )
+            delay = (
+                retry_after if retry_after is not None else exponential_cap * self._random_value()
+            )
+            if response is not None:
+                _close_response(response)
+            self._sleep(delay)
+        status_code = last_error.status_code if isinstance(last_error, BinanceHTTPError) else None
+        raise BinanceHTTPError(
+            f"public Binance GET failed after {self.retry_policy.max_retries + 1} attempts",
+            status_code=status_code,
+            retry_exhausted=True,
+        ) from last_error
+
+    def _bounded_request_body(
+        self,
+        path: str,
+        params: Mapping[str, str | int],
+        *,
+        raw_root: Path,
+        rejected_dataset: str,
+        symbol: str,
+        requested_start_ns: int | None,
+        requested_end_ns: int | None,
+        max_response_bytes: int | None = None,
+    ) -> tuple[bytes, str, dict[str, str], int]:
+        """Read one bounded body, retrying recoverable transport interruptions.
+
+        Every interrupted attempt is persisted before retry.  Payload/size
+        violations remain non-retryable because another identical response is
+        not evidence of a transient network failure.
+        """
+        byte_ceiling = max_response_bytes or self.max_response_bytes
+        for attempt in range(self.retry_policy.max_retries + 1):
+            response = self._request(path, params, stream_response=True)
+            observed_ts_ns = time.time_ns()
+            request_uri = str(response.url)
+            response_headers = _safe_response_headers(response.headers)
+            bounded_body = _read_bounded_response_body(
+                response,
+                max_response_bytes=byte_ceiling,
+            )
+            if bounded_body.error_message is None:
+                return (
+                    bounded_body.content,
+                    request_uri,
+                    response_headers,
+                    observed_ts_ns,
+                )
+
+            rejected_headers = _rejected_response_headers(response_headers, bounded_body)
+            rejected_headers["x-local-body-attempt"] = str(attempt + 1)
+            _write_raw_response(
+                bounded_body.content,
+                raw_root=raw_root,
+                dataset=rejected_dataset,
+                symbol=symbol,
+                request_uri=request_uri,
+                downloaded_at_utc=_iso_from_ns(observed_ts_ns),
+                requested_start_ns=requested_start_ns,
+                requested_end_ns=requested_end_ns,
+                response_headers=rejected_headers,
+                retained_evidence_budget=self.retained_evidence_budget,
+            )
+            if not bounded_body.retryable or attempt >= self.retry_policy.max_retries:
+                if bounded_body.retryable:
+                    raise BinancePayloadError(bounded_body.error_message, transient=True)
+                raise BinanceResponseSizeLimitError(bounded_body.error_message)
+            exponential_cap = min(
+                self.retry_policy.max_delay_seconds,
+                self.retry_policy.base_delay_seconds * (2**attempt),
+            )
+            self._sleep(exponential_cap * self._random_value())
+        raise AssertionError("bounded response retry loop exhausted without a terminal result")
+
+    def fetch_exchange_info(self, *, symbol: str, raw_root: str | Path) -> SymbolMetadata:
+        """Fetch public symbol status and exact PRICE_FILTER/LOT_SIZE scales."""
+        symbol = symbol.upper()
+        content, request_uri, response_headers, observed_ts_ns = self._bounded_request_body(
+            "/api/v3/exchangeInfo",
+            {"symbol": symbol},
+            raw_root=Path(raw_root),
+            rejected_dataset="exchange_info_rejected",
+            symbol=symbol,
+            requested_start_ns=None,
+            requested_end_ns=None,
+        )
+        raw_page = _write_raw_response(
+            content,
+            raw_root=Path(raw_root),
+            dataset="exchange_info",
+            symbol=symbol,
+            request_uri=request_uri,
+            downloaded_at_utc=_iso_from_ns(observed_ts_ns),
+            requested_start_ns=None,
+            requested_end_ns=None,
+            response_headers=response_headers,
+            retained_evidence_budget=self.retained_evidence_budget,
+        )
+        try:
+            payload = cast(dict[str, Any], json.loads(content))
+            symbols = cast(list[dict[str, Any]], payload["symbols"])
+            if len(symbols) != 1 or str(symbols[0]["symbol"]).upper() != symbol:
+                raise BinanceMetadataContractError(
+                    "exchangeInfo did not return exactly the requested symbol"
+                )
+            item = symbols[0]
+            filters = {
+                str(value["filterType"]): value
+                for value in cast(list[dict[str, Any]], item["filters"])
+            }
+            price_filter = filters["PRICE_FILTER"]
+            lot_filter = filters["LOT_SIZE"]
+            tick_size = Decimal(str(price_filter["tickSize"]))
+            lot_size = Decimal(str(lot_filter["stepSize"]))
+            if tick_size <= 0 or lot_size <= 0:
+                raise BinanceMetadataContractError(
+                    "exchangeInfo returned a nonpositive tick or lot size"
+                )
+            return SymbolMetadata(
+                venue="binance_spot",
+                symbol=symbol,
+                status=str(item["status"]),
+                base_asset=str(item["baseAsset"]),
+                quote_asset=str(item["quoteAsset"]),
+                tick_size=tick_size,
+                lot_size=lot_size,
+                min_price=Decimal(str(price_filter["minPrice"])),
+                max_price=Decimal(str(price_filter["maxPrice"])),
+                min_quantity=Decimal(str(lot_filter["minQty"])),
+                max_quantity=Decimal(str(lot_filter["maxQty"])),
+                observed_ts_ns=observed_ts_ns,
+                source_artifact_id=raw_page.sha256,
+                source_path=raw_page.path,
+                source_manifest_path=raw_page.manifest_path,
+            )
+        except (BinanceMetadataContractError, BinanceResponseSizeLimitError):
+            raise
+        except BinancePayloadError as exc:
+            if exc.transient:
+                raise
+            raise BinanceMetadataContractError(str(exc)) from exc
+        except (InvalidOperation, KeyError, TypeError, ValueError) as exc:
+            raise BinanceMetadataContractError("malformed Binance exchangeInfo response") from exc
+
+    def fetch_depth_snapshot(
+        self,
+        *,
+        symbol: str,
+        raw_root: str | Path,
+        continuity_id: str,
+        tick_size: Decimal | None = None,
+        lot_size: Decimal | None = None,
+        limit: int = 5000,
+    ) -> BookSnapshot:
+        """Fetch a public REST anchor; it intentionally has no exchange event time."""
+        if limit not in {5, 10, 20, 50, 100, 500, 1000, 5000}:
+            raise ValueError("unsupported Binance depth snapshot limit")
+        symbol = symbol.upper()
+        if (tick_size is None) != (lot_size is None):
+            raise ValueError("tick_size and lot_size must be supplied together")
+        if tick_size is None or lot_size is None:
+            metadata = self.fetch_exchange_info(symbol=symbol, raw_root=raw_root)
+            tick_size = metadata.tick_size
+            lot_size = metadata.lot_size
+        request_ts_ns = time.time_ns()
+        content, request_uri, response_headers, received_ts_ns = self._bounded_request_body(
+            "/api/v3/depth",
+            {"symbol": symbol, "limit": limit},
+            raw_root=Path(raw_root),
+            rejected_dataset="depth_snapshots_rejected",
+            symbol=symbol,
+            requested_start_ns=None,
+            requested_end_ns=None,
+        )
+        raw_page = _write_raw_response(
+            content,
+            raw_root=Path(raw_root),
+            dataset="depth_snapshots",
+            symbol=symbol,
+            request_uri=request_uri,
+            downloaded_at_utc=_iso_from_ns(received_ts_ns),
+            requested_start_ns=None,
+            requested_end_ns=None,
+            response_headers=response_headers,
+            retained_evidence_budget=self.retained_evidence_budget,
+        )
+        try:
+            payload = cast(dict[str, Any], json.loads(content))
+            bids = tuple(
+                (
+                    _scaled_integer(str(item[0]), tick_size, "bid price"),
+                    _scaled_integer(str(item[1]), lot_size, "bid quantity"),
+                )
+                for item in payload["bids"]
+            )
+            asks = tuple(
+                (
+                    _scaled_integer(str(item[0]), tick_size, "ask price"),
+                    _scaled_integer(str(item[1]), lot_size, "ask quantity"),
+                )
+                for item in payload["asks"]
+            )
+            last_update_id = int(payload["lastUpdateId"])
+        except (KeyError, TypeError, ValueError) as exc:
+            raise BinancePayloadError("malformed Binance depth snapshot") from exc
+        return BookSnapshot(
+            venue="binance_spot",
+            symbol=symbol,
+            snapshot_id=raw_page.sha256,
+            request_ts_ns=request_ts_ns,
+            received_ts_ns=received_ts_ns,
+            available_ts_ns=received_ts_ns,
+            continuity_id=continuity_id,
+            last_update_id=last_update_id,
+            depth_limit=limit,
+            bids=bids,
+            asks=asks,
+            tick_size=float(tick_size),
+            lot_size=float(lot_size),
+            source_artifact_id=raw_page.sha256,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class _ParsedAggregateTrade:
+    aggregate_id: int
+    first_trade_id: int
+    last_trade_id: int
+    event_ts_ns: int
+    price: Decimal
+    quantity: Decimal
+    buyer_is_maker: bool
+
+
+def _response_header(headers: Mapping[str, str], name: str) -> str | None:
+    normalized_name = name.lower()
+    for key, value in headers.items():
+        if str(key).lower() == normalized_name:
+            return str(value)
+    return None
+
+
+@dataclass(frozen=True, slots=True)
+class _BoundedResponseBody:
+    content: bytes
+    error_message: str | None
+    observed_bytes_lower_bound: int
+    retryable: bool = False
+
+
+def _rejected_response_headers(
+    response_headers: Mapping[str, str],
+    body: _BoundedResponseBody,
+) -> dict[str, str]:
+    """Describe a bounded rejected response in its immutable raw sidecar."""
+    result = dict(response_headers)
+    result.update(
+        {
+            "x-local-capture-status": (
+                "rejected_partial_response" if body.content else "rejected_headers_only"
+            ),
+            "x-local-captured-bytes": str(len(body.content)),
+            "x-local-observed-bytes-lower-bound": str(body.observed_bytes_lower_bound),
+            "x-local-rejection-reason": body.error_message or "unknown",
+        }
+    )
+    return result
+
+
+def _read_bounded_response_body(
+    response: requests.Response,
+    *,
+    max_response_bytes: int,
+) -> _BoundedResponseBody:
+    """Read one response with a hard prefix bound on the production transport.
+
+    A real ``requests.Response`` exposes ``iter_content`` and is consumed a
+    chunk at a time.  Injected legacy test responses without that method fall
+    back to their already-materialized ``content`` attribute for compatibility.
+    """
+    headers = response.headers
+    declared = _response_header(headers, "content-length")
+    try:
+        if declared is not None:
+            try:
+                declared_size = int(declared)
+            except ValueError:
+                return _BoundedResponseBody(
+                    content=b"",
+                    error_message="aggregate-trade response has invalid Content-Length",
+                    observed_bytes_lower_bound=0,
+                )
+            if declared_size < 0:
+                return _BoundedResponseBody(
+                    content=b"",
+                    error_message="aggregate-trade response has invalid Content-Length",
+                    observed_bytes_lower_bound=0,
+                )
+            if declared_size > max_response_bytes:
+                return _BoundedResponseBody(
+                    content=b"",
+                    error_message=(
+                        "aggregate-trade response Content-Length exceeded the response-byte ceiling"
+                    ),
+                    observed_bytes_lower_bound=0,
+                )
+
+        iter_content = getattr(response, "iter_content", None)
+        if callable(iter_content):
+            chunks: list[bytes] = []
+            captured_bytes = 0
+            chunk_size = min(64 * 1024, max_response_bytes + 1)
+            iterator = cast(
+                Callable[..., Iterator[object]],
+                iter_content,
+            )
+            try:
+                for raw_chunk in iterator(chunk_size=chunk_size):
+                    if not raw_chunk:
+                        continue
+                    if not isinstance(raw_chunk, bytes):
+                        return _BoundedResponseBody(
+                            content=b"".join(chunks),
+                            error_message=(
+                                "aggregate-trade response yielded a non-bytes body chunk"
+                            ),
+                            observed_bytes_lower_bound=captured_bytes,
+                        )
+                    remaining = max_response_bytes - captured_bytes
+                    if len(raw_chunk) > remaining:
+                        if remaining:
+                            chunks.append(raw_chunk[:remaining])
+                        return _BoundedResponseBody(
+                            content=b"".join(chunks),
+                            error_message=(
+                                "aggregate-trade response body exceeded the response-byte ceiling"
+                            ),
+                            observed_bytes_lower_bound=captured_bytes + len(raw_chunk),
+                        )
+                    chunks.append(raw_chunk)
+                    captured_bytes += len(raw_chunk)
+            except requests.RequestException as exc:
+                return _BoundedResponseBody(
+                    content=b"".join(chunks),
+                    error_message=(
+                        "aggregate-trade response body was interrupted after "
+                        f"{captured_bytes} bytes: {type(exc).__name__}"
+                    ),
+                    observed_bytes_lower_bound=captured_bytes,
+                    retryable=True,
+                )
+            return _BoundedResponseBody(
+                content=b"".join(chunks),
+                error_message=None,
+                observed_bytes_lower_bound=captured_bytes,
+            )
+
+        # Compatibility path for minimal injected responses.  This is not used
+        # by requests.Response and therefore is not the production transport.
+        content = bytes(response.content)
+        if len(content) > max_response_bytes:
+            return _BoundedResponseBody(
+                content=content[:max_response_bytes],
+                error_message=("aggregate-trade response body exceeded the response-byte ceiling"),
+                observed_bytes_lower_bound=len(content),
+            )
+        return _BoundedResponseBody(
+            content=content,
+            error_message=None,
+            observed_bytes_lower_bound=len(content),
+        )
+    finally:
+        _close_response(response)
+
+
+def _parse_aggregate_trade_page(
+    content: bytes,
+    *,
+    request_limit: int,
+) -> list[_ParsedAggregateTrade]:
+    try:
+        decoded = json.loads(content)
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise BinancePayloadError("malformed Binance aggregate-trade page") from exc
+    if not isinstance(decoded, list):
+        raise BinancePayloadError("malformed Binance aggregate-trade page")
+    if len(decoded) > request_limit:
+        raise BinancePayloadError("aggregate-trade response exceeded the requested page-size bound")
+
+    parsed: list[_ParsedAggregateTrade] = []
+    previous_id: int | None = None
+    previous_ts_ns: int | None = None
+    for raw_item in decoded:
+        if not isinstance(raw_item, dict):
+            raise BinancePayloadError("malformed aggregate-trade record")
+        item = cast(dict[str, Any], raw_item)
+        try:
+            aggregate_id = int(item["a"])
+            first_trade_id = int(item.get("f", aggregate_id))
+            last_trade_id = int(item.get("l", aggregate_id))
+            event_ts_ns = _event_timestamp_ns(int(item["T"]), "ms")
+            price = Decimal(str(item["p"]))
+            quantity = Decimal(str(item["q"]))
+            buyer_is_maker = item["m"]
+        except (KeyError, InvalidOperation, TypeError, ValueError) as exc:
+            raise BinancePayloadError("malformed aggregate-trade record") from exc
+        if not isinstance(buyer_is_maker, bool):
+            raise BinancePayloadError("malformed aggregate-trade record")
+        if aggregate_id < 0 or first_trade_id < 0 or last_trade_id < first_trade_id:
+            raise BinancePayloadError("invalid aggregate-trade identifiers")
+        if previous_id is not None and aggregate_id <= previous_id:
+            raise BinancePayloadError("aggregate-trade page IDs are not strictly increasing")
+        if previous_ts_ns is not None and event_ts_ns < previous_ts_ns:
+            raise BinancePayloadError("aggregate-trade page event times are not ordered")
+        parsed.append(
+            _ParsedAggregateTrade(
+                aggregate_id=aggregate_id,
+                first_trade_id=first_trade_id,
+                last_trade_id=last_trade_id,
+                event_ts_ns=event_ts_ns,
+                price=price,
+                quantity=quantity,
+                buyer_is_maker=buyer_is_maker,
+            )
+        )
+        previous_id = aggregate_id
+        previous_ts_ns = event_ts_ns
+    return parsed
+
+
+class BinanceTradeBatchStream(Iterator[pa.RecordBatch]):
+    """Lazy, page-bounded iterator over normalized aggregate trades.
+
+    No HTTP request is made until the first call to :func:`next`.  Each
+    nonempty batch comes from one retained raw response and has no more rows
+    than the downloader's request limit.  The iterator retains only terminal
+    counters and the latest raw-page descriptor; callers that need every raw
+    descriptor can process them incrementally with ``on_raw_page``.  Production
+    HTTP responses are consumed incrementally and stop after the first chunk
+    crossing ``max_response_bytes``.  Minimal injected responses that do not
+    implement ``iter_content`` retain a compatibility-only ``content`` fallback.
+    """
+
+    def __init__(
+        self,
+        *,
+        client: BinancePublicClient,
+        raw_root: Path,
+        request_limit: int,
+        max_response_bytes: int,
+        tick_size: Decimal | None,
+        lot_size: Decimal | None,
+        symbol: str,
+        start_ts_ns: int,
+        end_ts_ns: int,
+        max_events: int,
+        on_raw_page: Callable[[RawPage], None] | None,
+    ) -> None:
+        if end_ts_ns <= start_ts_ns:
+            raise ValueError("end_ts_ns must be after start_ts_ns")
+        if max_events < 1:
+            raise ValueError("max_events must be positive")
+        self._client = client
+        self._raw_root = raw_root
+        self._request_limit = request_limit
+        self._max_response_bytes = max_response_bytes
+        self._tick_size = tick_size
+        self._lot_size = lot_size
+        self._symbol = symbol.upper()
+        self._start_ts_ns = start_ts_ns
+        self._end_ts_ns = end_ts_ns
+        self._max_events = max_events
+        self._on_raw_page = on_raw_page
+        self._params: dict[str, str | int] = {
+            "symbol": self._symbol,
+            "startTime": start_ts_ns // _NS_PER_MILLISECOND,
+            "endTime": (end_ts_ns - 1) // _NS_PER_MILLISECOND,
+            "limit": request_limit,
+        }
+        self._rows_yielded = 0
+        self._raw_page_count = 0
+        self._last_raw_page: RawPage | None = None
+        self._previous_last_id: int | None = None
+        self._previous_last_event_ts_ns: int | None = None
+        self._summary: BinanceTradeStreamSummary | None = None
+        self._failed = False
+
+    def __iter__(self) -> BinanceTradeBatchStream:
+        return self
+
+    @property
+    def rows_yielded(self) -> int:
+        return self._rows_yielded
+
+    @property
+    def raw_page_count(self) -> int:
+        return self._raw_page_count
+
+    @property
+    def last_raw_page(self) -> RawPage | None:
+        return self._last_raw_page
+
+    @property
+    def summary(self) -> BinanceTradeStreamSummary:
+        """Return terminal metadata, failing closed before normal exhaustion."""
+        if self._summary is None:
+            raise RuntimeError("trade stream summary is unavailable before normal exhaustion")
+        return self._summary
+
+    def __next__(self) -> pa.RecordBatch:
+        if self._summary is not None:
+            raise StopIteration
+        if self._failed:
+            raise RuntimeError("trade stream cannot resume after a previous failure")
+        try:
+            return self._next_batch()
+        except StopIteration:
+            raise
+        except Exception:
+            self._failed = True
+            raise
+
+    def _resolve_scales(self) -> tuple[Decimal, Decimal]:
+        if self._tick_size is None or self._lot_size is None:
+            metadata = self._client.fetch_exchange_info(
+                symbol=self._symbol,
+                raw_root=self._raw_root,
+            )
+            self._tick_size = metadata.tick_size
+            self._lot_size = metadata.lot_size
+        return self._tick_size, self._lot_size
+
+    def _record_page(self, raw_page: RawPage) -> None:
+        self._raw_page_count += 1
+        self._last_raw_page = raw_page
+        if self._on_raw_page is not None:
+            self._on_raw_page(raw_page)
+
+    def _finish(self, reason: BinanceTradeStreamStopReason) -> None:
+        self._summary = BinanceTradeStreamSummary(
+            requested_start_ns=self._start_ts_ns,
+            requested_end_ns=self._end_ts_ns,
+            rows_yielded=self._rows_yielded,
+            raw_page_count=self._raw_page_count,
+            stop_reason=reason,
+            complete_range=(
+                reason is not BinanceTradeStreamStopReason.EVENT_CAP and self._rows_yielded > 0
+            ),
+            last_raw_page=self._last_raw_page,
+        )
+
+    def _normalize_records(
+        self,
+        items: list[_ParsedAggregateTrade],
+        *,
+        source_artifact_id: str,
+        tick_size: Decimal,
+        lot_size: Decimal,
+    ) -> list[dict[str, object]]:
+        records: list[dict[str, object]] = []
+        for item in items:
+            price_ticks = _scaled_integer(item.price, tick_size, "trade price")
+            quantity_lots = _scaled_integer(item.quantity, lot_size, "trade quantity")
+            price = float(item.price)
+            quantity = float(item.quantity)
+            records.append(
+                {
+                    "schema_version": SCHEMA_VERSION,
+                    "venue": "binance_spot",
+                    "symbol": self._symbol,
+                    "event_ts_ns": item.event_ts_ns,
+                    "received_ts_ns": None,
+                    "available_ts_ns": item.event_ts_ns,
+                    "availability_basis": "exchange_event_time_proxy",
+                    "capture_seq": None,
+                    "continuity_id": None,
+                    "trade_id": item.aggregate_id,
+                    "first_trade_id": item.first_trade_id,
+                    "last_trade_id": item.last_trade_id,
+                    "price_ticks": price_ticks,
+                    "quantity_lots": quantity_lots,
+                    "tick_size": float(tick_size),
+                    "lot_size": float(lot_size),
+                    "price": price,
+                    "quantity": quantity,
+                    "quote_quantity": price * quantity,
+                    "aggressor_side": "sell" if item.buyer_is_maker else "buy",
+                    "buyer_is_maker": item.buyer_is_maker,
+                    "source_artifact_id": source_artifact_id,
+                }
+            )
+        return records
+
+    def _next_batch(self) -> pa.RecordBatch:
+        tick_size, lot_size = self._resolve_scales()
+        while True:
+            content, request_uri, response_headers, downloaded_ns = (
+                self._client._bounded_request_body(
+                    "/api/v3/aggTrades",
+                    self._params,
+                    raw_root=self._raw_root,
+                    rejected_dataset="agg_trades_rejected",
+                    symbol=self._symbol,
+                    requested_start_ns=self._start_ts_ns,
+                    requested_end_ns=self._end_ts_ns,
+                    max_response_bytes=self._max_response_bytes,
+                )
+            )
+            raw_page_base = _write_raw_response(
+                content,
+                raw_root=self._raw_root,
+                dataset="agg_trades",
+                symbol=self._symbol,
+                request_uri=request_uri,
+                downloaded_at_utc=_iso_from_ns(downloaded_ns),
+                requested_start_ns=self._start_ts_ns,
+                requested_end_ns=self._end_ts_ns,
+                response_headers=response_headers,
+                retained_evidence_budget=self._client.retained_evidence_budget,
+            )
+            parsed = _parse_aggregate_trade_page(content, request_limit=self._request_limit)
+            raw_page = RawPage(
+                path=raw_page_base.path,
+                manifest_path=raw_page_base.manifest_path,
+                sha256=raw_page_base.sha256,
+                request_uri=raw_page_base.request_uri,
+                row_count=len(parsed),
+            )
+            self._record_page(raw_page)
+            if not parsed:
+                self._finish(BinanceTradeStreamStopReason.EMPTY_PAGE)
+                raise StopIteration
+
+            first = parsed[0]
+            last = parsed[-1]
+            if self._previous_last_id is not None and first.aggregate_id <= self._previous_last_id:
+                raise BinancePayloadError("aggregate-trade pagination did not advance")
+            if (
+                self._previous_last_event_ts_ns is not None
+                and first.event_ts_ns < self._previous_last_event_ts_ns
+            ):
+                raise BinancePayloadError("aggregate-trade pages are not time ordered")
+            self._previous_last_id = last.aggregate_id
+            self._previous_last_event_ts_ns = last.event_ts_ns
+
+            in_range = [
+                item for item in parsed if self._start_ts_ns <= item.event_ts_ns < self._end_ts_ns
+            ]
+            remaining = self._max_events - self._rows_yielded
+            selected = in_range[:remaining]
+            records = self._normalize_records(
+                selected,
+                source_artifact_id=raw_page.sha256,
+                tick_size=tick_size,
+                lot_size=lot_size,
+            )
+            self._rows_yielded += len(records)
+
+            terminal_reason: BinanceTradeStreamStopReason | None = None
+            if len(in_range) >= remaining:
+                terminal_reason = BinanceTradeStreamStopReason.EVENT_CAP
+            elif last.event_ts_ns >= self._end_ts_ns:
+                terminal_reason = BinanceTradeStreamStopReason.RANGE_END
+            elif len(parsed) < self._request_limit:
+                terminal_reason = BinanceTradeStreamStopReason.SHORT_PAGE
+            else:
+                self._params = {
+                    "symbol": self._symbol,
+                    "fromId": last.aggregate_id + 1,
+                    "limit": self._request_limit,
+                }
+
+            if terminal_reason is not None:
+                self._finish(terminal_reason)
+            if records:
+                table = table_from_records("trades", records)
+                batches = table.to_batches(max_chunksize=self._request_limit)
+                if len(batches) != 1:
+                    raise BinancePayloadError("failed to construct one bounded trade batch")
+                return batches[0]
+            if terminal_reason is not None:
+                raise StopIteration
+
+
+class BinanceHistoricalTradeDownloader:
+    """Historical aggregate-trade downloader with lazy and guarded materialized APIs."""
+
+    def __init__(
+        self,
+        *,
+        client: BinancePublicClient,
+        raw_root: str | Path,
+        request_limit: int = 1000,
+        max_response_bytes: int = 8 * 1024 * 1024,
+        materialization_max_rows: int = 100_000,
+        tick_size: Decimal | None = None,
+        lot_size: Decimal | None = None,
+    ) -> None:
+        if not 1 <= request_limit <= 1000:
+            raise ValueError("request_limit must be in [1, 1000]")
+        if max_response_bytes < 1:
+            raise ValueError("max_response_bytes must be positive")
+        if materialization_max_rows < 1:
+            raise ValueError("materialization_max_rows must be positive")
+        self.client = client
+        self.raw_root = Path(raw_root)
+        self.request_limit = request_limit
+        self.max_response_bytes = max_response_bytes
+        self.materialization_max_rows = materialization_max_rows
+        if (tick_size is None) != (lot_size is None):
+            raise ValueError("tick_size and lot_size must be supplied together")
+        self.tick_size = tick_size
+        self.lot_size = lot_size
+
+    def stream(
+        self,
+        *,
+        symbol: str,
+        start_ts_ns: int,
+        end_ts_ns: int,
+        max_events: int,
+        on_raw_page: Callable[[RawPage], None] | None = None,
+    ) -> BinanceTradeBatchStream:
+        """Create a lazy ``[start, end)`` page stream without making an HTTP call."""
+        return BinanceTradeBatchStream(
+            client=self.client,
+            raw_root=self.raw_root,
+            request_limit=self.request_limit,
+            max_response_bytes=self.max_response_bytes,
+            tick_size=self.tick_size,
+            lot_size=self.lot_size,
+            symbol=symbol,
+            start_ts_ns=start_ts_ns,
+            end_ts_ns=end_ts_ns,
+            max_events=max_events,
+            on_raw_page=on_raw_page,
+        )
+
+    def download(
+        self,
+        *,
+        symbol: str,
+        start_ts_ns: int,
+        end_ts_ns: int,
+        max_events: int,
+    ) -> BinanceDownloadResult:
+        """Materialize the lazy stream for backwards-compatible small downloads."""
+        if max_events > self.materialization_max_rows:
+            raise ValueError(
+                "max_events exceeds the guarded download() materialization limit; "
+                "consume stream() incrementally for larger histories"
+            )
+        raw_pages: list[RawPage] = []
+        stream = self.stream(
+            symbol=symbol,
+            start_ts_ns=start_ts_ns,
+            end_ts_ns=end_ts_ns,
+            max_events=max_events,
+            on_raw_page=raw_pages.append,
+        )
+        batches = list(stream)
+        trades = (
+            pa.Table.from_batches(batches, schema=get_schema("trades"))
+            if batches
+            else table_from_records("trades", [])
+        )
+        return BinanceDownloadResult(
+            trades=trades,
+            raw_pages=tuple(raw_pages),
+            requested_start_ns=start_ts_ns,
+            requested_end_ns=end_ts_ns,
+            complete_range=stream.summary.complete_range,
+        )
+
+
+def _iso_from_ns(timestamp_ns: int) -> str:
+    seconds, nanoseconds = divmod(timestamp_ns, 1_000_000_000)
+    base = time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime(seconds))
+    return f"{base}.{nanoseconds:09d}Z"
+
+
+def _write_raw_response(
+    content: bytes,
+    *,
+    raw_root: Path,
+    dataset: str,
+    symbol: str,
+    request_uri: str,
+    downloaded_at_utc: str,
+    requested_start_ns: int | None,
+    requested_end_ns: int | None,
+    response_headers: Mapping[str, str],
+    retained_evidence_budget: RetainedEvidenceBudget | None = None,
+) -> RawPage:
+    checksum = hashlib.sha256(content).hexdigest()
+    directory = raw_root / "binance_spot" / dataset / symbol.upper()
+    destination = directory / f"{checksum}.json"
+    if retained_evidence_budget is not None:
+        retained_evidence_budget.assert_contains(destination)
+    transaction = (
+        retained_evidence_budget.write_transaction()
+        if retained_evidence_budget is not None
+        else nullcontext()
+    )
+    with transaction:
+        directory.mkdir(parents=True, exist_ok=True)
+        body_reservation = None
+        created_body = False
+        if destination.exists():
+            if sha256_file(destination) != checksum:
+                raise BinancePayloadError(f"raw content-address collision at {destination}")
+        else:
+            if retained_evidence_budget is not None:
+                body_reservation = retained_evidence_budget.reserve(
+                    len(content),
+                    label=f"raw Binance response {destination.name}",
+                )
+            try:
+                handle, temporary_name = tempfile.mkstemp(
+                    dir=directory,
+                    prefix=".raw-",
+                    suffix=".tmp",
+                )
+            except BaseException:
+                if body_reservation is not None and body_reservation.active:
+                    body_reservation.release()
+                raise
+            try:
+                with os.fdopen(handle, "wb") as stream:
+                    stream.write(content)
+                    stream.flush()
+                    os.fsync(stream.fileno())
+                os.replace(temporary_name, destination)
+                _fsync_directory(directory)
+                created_body = True
+            except BaseException:
+                Path(temporary_name).unlink(missing_ok=True)
+                if body_reservation is not None and body_reservation.active:
+                    body_reservation.release()
+                raise
+        try:
+            manifest_path, _ = write_source_manifest(
+                destination,
+                source="binance_spot_public_api",
+                source_uri=request_uri,
+                downloaded_at_utc=downloaded_at_utc,
+                requested_start_ns=requested_start_ns,
+                requested_end_ns=requested_end_ns,
+                response_headers=response_headers,
+                retained_evidence_budget=retained_evidence_budget,
+            )
+            if body_reservation is not None:
+                body_reservation.commit()
+        except BaseException:
+            if created_body:
+                destination.unlink(missing_ok=True)
+            if body_reservation is not None and body_reservation.active:
+                body_reservation.release()
+            raise
+        return RawPage(
+            path=destination,
+            manifest_path=manifest_path,
+            sha256=checksum,
+            request_uri=request_uri,
+            row_count=0,
+        )
+
+
+def parse_depth_message(
+    raw_message: str | bytes,
+    *,
+    received_ts_ns: int,
+    capture_seq: int,
+    continuity_id: str,
+    tick_size: Decimal = Decimal("0.00000001"),
+    lot_size: Decimal = Decimal("0.00000001"),
+    timestamp_unit: Literal["ms", "us"] = "us",
+) -> DepthDelta:
+    """Normalize raw or combined-stream Spot ``U/u`` depth payloads."""
+    raw_bytes = raw_message.encode() if isinstance(raw_message, str) else raw_message
+    try:
+        decoded = json.loads(raw_bytes)
+        payload = decoded.get("data", decoded)
+        if payload.get("e") != "depthUpdate":
+            raise BinancePayloadError(f"unexpected websocket event: {payload.get('e')!r}")
+        symbol = str(payload["s"]).upper()
+        bids = tuple(
+            (
+                _scaled_integer(str(item[0]), tick_size, "bid price"),
+                _scaled_integer(str(item[1]), lot_size, "bid quantity"),
+            )
+            for item in payload["b"]
+        )
+        asks = tuple(
+            (
+                _scaled_integer(str(item[0]), tick_size, "ask price"),
+                _scaled_integer(str(item[1]), lot_size, "ask quantity"),
+            )
+            for item in payload["a"]
+        )
+        event_ts_ns = _event_timestamp_ns(int(payload["E"]), timestamp_unit)
+        first_update_id = int(payload["U"])
+        last_update_id = int(payload["u"])
+        previous = payload.get("pu")
+    except BinancePayloadError:
+        raise
+    except (KeyError, TypeError, ValueError, json.JSONDecodeError) as exc:
+        raise BinancePayloadError("malformed Binance depth websocket message") from exc
+    return DepthDelta(
+        venue="binance_spot",
+        symbol=symbol,
+        event_ts_ns=event_ts_ns,
+        received_ts_ns=received_ts_ns,
+        available_ts_ns=received_ts_ns,
+        availability_basis="local_receive_time",
+        capture_seq=capture_seq,
+        continuity_id=continuity_id,
+        first_update_id=first_update_id,
+        last_update_id=last_update_id,
+        previous_update_id=int(previous) if previous is not None else None,
+        bids=bids,
+        asks=asks,
+        tick_size=float(tick_size),
+        lot_size=float(lot_size),
+        source_artifact_id=hashlib.sha256(raw_bytes).hexdigest(),
+    )
+
+
+class BinanceLiveDepthCollector:
+    """Optional reconnecting collector for public diff-depth streams."""
+
+    def __init__(
+        self,
+        *,
+        symbols: tuple[str, ...],
+        websocket_base_url: str = "wss://data-stream.binance.vision",
+        tick_size: Decimal = Decimal("0.00000001"),
+        lot_size: Decimal = Decimal("0.00000001"),
+        max_reconnects: int = 5,
+        connect_factory: ConnectFactory | None = None,
+        on_raw_frame: RawDepthFrameCallback | None = None,
+    ) -> None:
+        if not symbols:
+            raise ValueError("symbols must not be empty")
+        self.symbols = tuple(symbol.upper() for symbol in symbols)
+        streams = "/".join(f"{symbol.lower()}@depth@100ms" for symbol in self.symbols)
+        self.url = f"{websocket_base_url.rstrip('/')}/stream?streams={streams}&timeUnit=MICROSECOND"
+        self.tick_size = tick_size
+        self.lot_size = lot_size
+        self.max_reconnects = max_reconnects
+        self._connect_factory = connect_factory or cast(ConnectFactory, websockets.connect)
+        self._on_raw_frame = on_raw_frame
+
+    async def stream(self, *, max_messages: int | None = None) -> AsyncIterator[CapturedDepth]:
+        """Yield exact raw payloads plus normalized deltas across continuity epochs."""
+        capture_seq = 0
+        yielded = 0
+        reconnect = 0
+        while reconnect <= self.max_reconnects:
+            continuity_id = f"binance-live-{time.time_ns()}-{reconnect}"
+            try:
+                async with self._connect_factory(self.url) as connection:
+                    async for raw in connection:
+                        received_ts_ns = time.time_ns()
+                        if isinstance(raw, bytes):
+                            raw_bytes = raw
+                            was_text = False
+                        else:
+                            raw_bytes = raw.encode("utf-8")
+                            was_text = True
+                        if self._on_raw_frame is not None:
+                            self._on_raw_frame(
+                                RawDepthFrame(
+                                    payload=raw_bytes,
+                                    was_text=was_text,
+                                    received_ts_ns=received_ts_ns,
+                                    capture_seq=capture_seq,
+                                    continuity_id=continuity_id,
+                                )
+                            )
+                        raw_text = raw_bytes.decode("utf-8") if isinstance(raw, bytes) else raw
+                        delta = parse_depth_message(
+                            raw_text,
+                            received_ts_ns=received_ts_ns,
+                            capture_seq=capture_seq,
+                            continuity_id=continuity_id,
+                            tick_size=self.tick_size,
+                            lot_size=self.lot_size,
+                            timestamp_unit="us",
+                        )
+                        yield CapturedDepth(raw_payload=raw_text, delta=delta)
+                        capture_seq += 1
+                        yielded += 1
+                        if max_messages is not None and yielded >= max_messages:
+                            return
+                reconnect += 1
+            except (OSError, WebSocketException):
+                reconnect += 1
+                if reconnect > self.max_reconnects:
+                    raise
+                await asyncio.sleep(min(30.0, 0.5 * (2 ** (reconnect - 1))))
+
+
+def depth_deltas_table(captured: tuple[CapturedDepth, ...] | list[CapturedDepth]) -> pa.Table:
+    return table_from_records("depth_deltas", [item.delta.to_record() for item in captured])

Microstructure/src/microstructure/data/binance_archive.py

@@ -0,0 +1,1459 @@
+"""Bounded acquisition and one-shot normalization of Binance daily trade archives.
+
+The acquisition boundary deliberately stops after authenticating the exact ZIP
+bytes and inspecting bounded ZIP metadata.  CSV rows are not opened until a
+caller explicitly requests a normalized stream.  That separation lets a study
+write an analysis lock before either held-out archive is exposed to research
+code.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import math
+import os
+import random
+import re
+import stat
+import struct
+import tempfile
+import time
+import zipfile
+from collections.abc import Callable, Generator, Iterator, Mapping
+from contextlib import nullcontext
+from dataclasses import dataclass
+from datetime import UTC, date, datetime, timedelta
+from decimal import Decimal, InvalidOperation
+from pathlib import Path
+from typing import Any, BinaryIO, Literal, Protocol, cast
+from urllib.parse import urlsplit
+
+import pyarrow as pa  # type: ignore[import-untyped]
+import requests
+
+from microstructure.data.binance import RetryPolicy
+from microstructure.data.evidence_budget import (
+    EvidenceBudgetError,
+    EvidenceReservation,
+    RetainedEvidenceBudget,
+)
+from microstructure.data.schemas import SCHEMA_VERSION, table_from_records
+from microstructure.data.storage import write_source_manifest
+from microstructure.provenance import sha256_file, utc_now_iso
+
+_DEFAULT_BASE_URL = "https://data.binance.vision"
+_SAFE_SYMBOL = re.compile(r"^[A-Z0-9]{2,20}$")
+_SAFE_ARCHIVE_NAME = re.compile(r"^[A-Z0-9]{2,20}-aggTrades-\d{4}-\d{2}-\d{2}\.zip$")
+_CHECKSUM_LINE = re.compile(rb"([0-9a-f]{64})  ([A-Za-z0-9_.-]+)(?:\r\n|\n)?")
+_UNSIGNED_INTEGER = re.compile(rb"(?:0|[1-9][0-9]*)")
+_EOCD_SIGNATURE = b"PK\x05\x06"
+_EOCD_STRUCT = struct.Struct("<4s4H2LH")
+_LOCAL_FILE_SIGNATURE = b"PK\x03\x04"
+_LOCAL_FILE_STRUCT = struct.Struct("<4s5H3L2H")
+_MAX_EOCD_BYTES = 22 + 65_535
+_MAX_ZIP_ENTRY_METADATA_BYTES = 256 * 1_024
+_MAX_DECIMAL_FIELD_BYTES = 64
+_MAX_INT64 = (1 << 63) - 1
+_MICROSECOND_ARCHIVE_START = date(2025, 1, 1)
+
+
+class BinanceArchiveError(RuntimeError):
+    """Base failure for immutable Binance archive acquisition or parsing."""
+
+
+class BinanceArchiveHTTPError(BinanceArchiveError):
+    """Raised when a bounded public archive response cannot be acquired."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int | None = None,
+        retry_exhausted: bool = False,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.retry_exhausted = retry_exhausted
+
+
+class BinanceArchivePayloadError(BinanceArchiveError):
+    """Raised when archive bytes or CSV rows violate their frozen contract."""
+
+
+ArchiveAcquisitionReasonCode = Literal[
+    "CHECKSUM_CONTRACT",
+    "ZIP_CONTRACT",
+    "RESPONSE_SIZE_LIMIT",
+]
+
+
+class BinanceArchiveContractError(BinanceArchivePayloadError):
+    """A deterministic raw archive/checksum contract failure before CSV open."""
+
+    def __init__(self, message: str, *, reason_code: ArchiveAcquisitionReasonCode) -> None:
+        super().__init__(message)
+        self.reason_code = reason_code
+
+
+class _RetryableDownloadError(BinanceArchiveHTTPError):
+    """Internal marker for one recoverable, already-evidenced HTTP attempt."""
+
+    def __init__(self, message: str, *, retry_after_seconds: float | None = None) -> None:
+        super().__init__(message)
+        self.retry_after_seconds = retry_after_seconds
+
+
+class _StreamingResponse(Protocol):
+    status_code: int
+    headers: Mapping[str, str]
+    url: str
+
+    def iter_content(self, *, chunk_size: int) -> Iterator[bytes]: ...
+
+    def close(self) -> object: ...
+
+
+class _StreamingSession(Protocol):
+    def get(self, url: str, *, timeout: float, stream: bool) -> _StreamingResponse: ...
+
+
+@dataclass(frozen=True, slots=True)
+class DailyArchiveRequest:
+    """One exact official UTC-day archive plus normalization scales."""
+
+    symbol: str
+    date: date
+    tick_size: Decimal
+    lot_size: Decimal
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.symbol, str) or _SAFE_SYMBOL.fullmatch(self.symbol) is None:
+            raise ValueError("archive symbol must be uppercase ASCII letters/digits")
+        if type(self.date) is not date:
+            raise ValueError("archive date must be a datetime.date")
+        if not isinstance(self.tick_size, Decimal):
+            raise ValueError("tick_size must be a Decimal")
+        if (
+            not self.tick_size.is_finite()
+            or self.tick_size <= 0
+            or not math.isfinite(float(self.tick_size))
+            or float(self.tick_size) <= 0
+        ):
+            raise ValueError("tick_size must be a positive finite Decimal")
+        if not isinstance(self.lot_size, Decimal):
+            raise ValueError("lot_size must be a Decimal")
+        if (
+            not self.lot_size.is_finite()
+            or self.lot_size <= 0
+            or not math.isfinite(float(self.lot_size))
+            or float(self.lot_size) <= 0
+        ):
+            raise ValueError("lot_size must be a positive finite Decimal")
+
+    @property
+    def archive_name(self) -> str:
+        return f"{self.symbol}-aggTrades-{self.date.isoformat()}.zip"
+
+    @property
+    def member_name(self) -> str:
+        return self.archive_name.removesuffix(".zip") + ".csv"
+
+    @property
+    def continuity_id(self) -> str:
+        return f"binance_spot:{self.symbol}:{self.date.isoformat()}"
+
+
+@dataclass(frozen=True, slots=True)
+class ArchiveDownloadLimits:
+    """Hard transport, expansion, and record-boundary ceilings."""
+
+    max_compressed_bytes: int
+    max_uncompressed_bytes: int
+    max_checksum_bytes: int = 4_096
+    transfer_chunk_bytes: int = 64 * 1_024
+    max_csv_line_bytes: int = 16 * 1_024
+
+    def __post_init__(self) -> None:
+        values = (
+            self.max_compressed_bytes,
+            self.max_uncompressed_bytes,
+            self.max_checksum_bytes,
+            self.transfer_chunk_bytes,
+            self.max_csv_line_bytes,
+        )
+        if any(
+            isinstance(value, bool) or not isinstance(value, int) or value < 1 for value in values
+        ):
+            raise ValueError("all archive byte limits must be positive integers")
+
+
+@dataclass(frozen=True, slots=True)
+class RawArchiveArtifact:
+    """Immutable descriptor for an exact public response body."""
+
+    kind: Literal["archive_zip", "archive_checksum", "rejected_prefix"]
+    path: Path
+    manifest_path: Path
+    sha256: str
+    manifest_sha256: str
+    bytes: int
+    source_uri: str
+
+
+@dataclass(frozen=True, slots=True)
+class DailyArchiveSummary:
+    """Non-economic coverage facts available only after full stream exhaustion."""
+
+    symbol: str
+    date: str
+    rows: int
+    first_trade_id: int
+    last_trade_id: int
+    first_event_ts_ns: int
+    last_event_ts_ns: int
+    compressed_bytes: int
+    expanded_bytes: int
+    source_archive_sha256: str
+    member_name: str
+    continuity_id: str
+
+
+@dataclass(frozen=True, slots=True)
+class _ZipDescriptor:
+    member_name: str
+    declared_uncompressed_bytes: int
+
+
+@dataclass(frozen=True, slots=True)
+class _ZipDirectoryBounds:
+    offset: int
+    bytes: int
+
+
+@dataclass(frozen=True, slots=True)
+class _DownloadedBody:
+    temporary_path: Path
+    sha256: str
+    bytes: int
+    response_headers: Mapping[str, str]
+    downloaded_at_utc: str
+    evidence_reservations: tuple[EvidenceReservation, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class AcquiredDailyArchive:
+    """Checksum-authenticated raw bytes whose CSV has not yet been opened."""
+
+    request: DailyArchiveRequest
+    archive_artifact: RawArchiveArtifact
+    checksum_artifact: RawArchiveArtifact
+    upstream_sha256: str
+    declared_uncompressed_bytes: int
+    limits: ArchiveDownloadLimits
+    requires_member_open_guard: bool = False
+
+    def iter_normalized_batches(
+        self,
+        *,
+        batch_rows: int = 65_536,
+        before_member_open: Callable[[], None] | None = None,
+    ) -> DailyArchiveTradeStream:
+        """Create a fresh one-shot normalized stream over the authenticated ZIP.
+
+        ``before_member_open`` is a fail-closed held-out-data guard.  It runs
+        after bounded ZIP-directory validation and immediately before the CSV
+        member is opened.  A raised exception therefore exposes zero member
+        bytes.  Acquisition callers normally leave it unset; prospective
+        research pipelines use it to revalidate their durable analysis lock
+        at the actual economic-data boundary.
+
+        Handles reconstructed for a frozen held-out role set
+        ``requires_member_open_guard``.  Such a stream refuses to advance at
+        all unless this callback is supplied; the generic archive adapter and
+        development-date handles retain their backward-compatible default.
+        """
+        if isinstance(batch_rows, bool) or not isinstance(batch_rows, int) or batch_rows < 1:
+            raise ValueError("batch_rows must be a positive integer")
+        return DailyArchiveTradeStream(
+            _stream_normalized_batches(
+                self,
+                batch_rows=batch_rows,
+                before_member_open=before_member_open,
+            )
+        )
+
+
+class DailyArchiveTradeStream(Iterator[pa.RecordBatch]):
+    """One-shot RecordBatch iterator with a terminal-only coverage summary."""
+
+    def __init__(
+        self,
+        generator: Generator[pa.RecordBatch, None, DailyArchiveSummary],
+    ) -> None:
+        self._generator = generator
+        self._summary: DailyArchiveSummary | None = None
+        self._closed = False
+
+    def __iter__(self) -> DailyArchiveTradeStream:
+        return self
+
+    def __next__(self) -> pa.RecordBatch:
+        if self._closed:
+            raise StopIteration
+        try:
+            return next(self._generator)
+        except StopIteration as stop:
+            self._closed = True
+            self._summary = cast(DailyArchiveSummary, stop.value)
+            raise
+        except BaseException:
+            self._closed = True
+            raise
+
+    @property
+    def summary(self) -> DailyArchiveSummary:
+        if self._summary is None:
+            raise RuntimeError("archive summary is unavailable before full stream exhaustion")
+        return self._summary
+
+    def close(self) -> None:
+        if not self._closed:
+            self._generator.close()
+            self._closed = True
+
+
+def _day_bounds_ns(value: date) -> tuple[int, int]:
+    start = datetime(value.year, value.month, value.day, tzinfo=UTC)
+    end = start + timedelta(days=1)
+    return int(start.timestamp()) * 1_000_000_000, int(end.timestamp()) * 1_000_000_000
+
+
+def _safe_headers(headers: Mapping[str, str]) -> dict[str, str]:
+    allowed = {
+        "content-length",
+        "content-type",
+        "etag",
+        "last-modified",
+        "retry-after",
+    }
+    return {str(key): str(value) for key, value in headers.items() if str(key).lower() in allowed}
+
+
+def _header(headers: Mapping[str, str], name: str) -> str | None:
+    lowered = name.lower()
+    for key, value in headers.items():
+        if str(key).lower() == lowered:
+            return str(value)
+    return None
+
+
+def _content_length(headers: Mapping[str, str]) -> int | None:
+    raw = _header(headers, "content-length")
+    if raw is None:
+        return None
+    if not raw.isascii() or not raw.isdecimal():
+        raise BinanceArchivePayloadError("response Content-Length must be an unsigned integer")
+    return int(raw)
+
+
+def _retry_after_seconds(headers: Mapping[str, str]) -> float | None:
+    raw = _header(headers, "retry-after")
+    if raw is None:
+        return None
+    try:
+        value = float(raw)
+    except ValueError:
+        return None
+    if not math.isfinite(value) or value < 0:
+        return None
+    return value
+
+
+def _validate_base_url(value: str) -> str:
+    normalized = value.rstrip("/")
+    parsed = urlsplit(normalized)
+    if parsed.scheme != "https" or not parsed.netloc or parsed.path not in {"", "/"}:
+        raise ValueError("archive base_url must be an HTTPS origin without path/query")
+    if parsed.query or parsed.fragment or parsed.username or parsed.password:
+        raise ValueError("archive base_url must not contain credentials, query, or fragment")
+    return normalized
+
+
+def _archive_urls(base_url: str, request: DailyArchiveRequest) -> tuple[str, str]:
+    archive = f"{base_url}/data/spot/daily/aggTrades/{request.symbol}/{request.archive_name}"
+    return archive, f"{archive}.CHECKSUM"
+
+
+def _release_evidence_reservations(
+    reservations: tuple[EvidenceReservation, ...] | list[EvidenceReservation],
+) -> None:
+    for reservation in reservations:
+        if reservation.active:
+            reservation.release()
+
+
+def _commit_evidence_reservations(
+    reservations: tuple[EvidenceReservation, ...] | list[EvidenceReservation],
+) -> None:
+    for reservation in reservations:
+        reservation.commit()
+
+
+def _discard_download(body: _DownloadedBody) -> None:
+    body.temporary_path.unlink(missing_ok=True)
+    _release_evidence_reservations(body.evidence_reservations)
+
+
+def _fsync_directory(path: Path) -> None:
+    descriptor = os.open(path, os.O_RDONLY)
+    try:
+        os.fsync(descriptor)
+    finally:
+        os.close(descriptor)
+
+
+def _publish_temp(
+    temporary: Path,
+    *,
+    destination_directory: Path,
+    suffix: str,
+    destination_name: str | None = None,
+    kind: Literal["archive_zip", "archive_checksum", "rejected_prefix"],
+    source: str,
+    source_uri: str,
+    downloaded_at_utc: str,
+    request: DailyArchiveRequest,
+    sha256: str,
+    response_headers: Mapping[str, str],
+    upstream_checksum_sha256: str | None,
+    retained_evidence_budget: RetainedEvidenceBudget | None = None,
+    evidence_reservations: tuple[EvidenceReservation, ...] = (),
+) -> RawArchiveArtifact:
+    destination = destination_directory / (destination_name or f"{sha256}{suffix}")
+    if retained_evidence_budget is None and evidence_reservations:
+        raise BinanceArchiveError("download reservations require a retained-evidence budget")
+    if retained_evidence_budget is not None:
+        retained_evidence_budget.assert_contains(temporary)
+        retained_evidence_budget.assert_contains(destination)
+    transaction = (
+        retained_evidence_budget.write_transaction()
+        if retained_evidence_budget is not None
+        else nullcontext()
+    )
+    created_destination = False
+    try:
+        with transaction:
+            destination_directory.mkdir(parents=True, exist_ok=True)
+            if destination.exists():
+                if sha256_file(destination) != sha256:
+                    raise BinanceArchivePayloadError(f"content-address collision at {destination}")
+                temporary.unlink(missing_ok=True)
+                _release_evidence_reservations(evidence_reservations)
+            else:
+                os.replace(temporary, destination)
+                _fsync_directory(destination_directory)
+                created_destination = True
+            start_ns, end_ns = _day_bounds_ns(request.date)
+            manifest_path, manifest_sha = write_source_manifest(
+                destination,
+                source=source,
+                source_uri=source_uri,
+                downloaded_at_utc=downloaded_at_utc,
+                requested_start_ns=start_ns,
+                requested_end_ns=end_ns,
+                upstream_checksum_sha256=upstream_checksum_sha256,
+                response_headers=response_headers,
+                retained_evidence_budget=retained_evidence_budget,
+            )
+            if created_destination:
+                _commit_evidence_reservations(evidence_reservations)
+            return RawArchiveArtifact(
+                kind=kind,
+                path=destination,
+                manifest_path=manifest_path,
+                sha256=sha256,
+                manifest_sha256=manifest_sha,
+                bytes=destination.stat().st_size,
+                source_uri=source_uri,
+            )
+    except BaseException:
+        temporary.unlink(missing_ok=True)
+        if created_destination:
+            destination.unlink(missing_ok=True)
+        _release_evidence_reservations(evidence_reservations)
+        raise
+
+
+def _publish_rejected(
+    temporary: Path,
+    *,
+    raw_root: Path,
+    request: DailyArchiveRequest,
+    source_uri: str,
+    downloaded_at_utc: str,
+    response_headers: Mapping[str, str],
+    reason: str,
+    suffix: str,
+    attempt_number: int | None = None,
+    retained_evidence_budget: RetainedEvidenceBudget | None = None,
+    evidence_reservations: tuple[EvidenceReservation, ...] = (),
+) -> RawArchiveArtifact:
+    digest = sha256_file(temporary)
+    headers = dict(response_headers)
+    headers.update(
+        {
+            "x-local-capture-status": "rejected_bounded_prefix",
+            "x-local-rejection-reason": reason,
+            "x-local-captured-bytes": str(temporary.stat().st_size),
+        }
+    )
+    if attempt_number is not None:
+        headers["x-local-download-attempt"] = str(attempt_number)
+    return _publish_temp(
+        temporary,
+        destination_directory=(
+            raw_root
+            / "binance_spot"
+            / "daily_agg_trades_archive_rejected"
+            / request.symbol
+            / request.date.isoformat()
+        ),
+        suffix=suffix,
+        kind="rejected_prefix",
+        source="binance_spot_daily_aggtrades_archive_rejected",
+        source_uri=source_uri,
+        downloaded_at_utc=downloaded_at_utc,
+        request=request,
+        sha256=digest,
+        response_headers=headers,
+        upstream_checksum_sha256=None,
+        retained_evidence_budget=retained_evidence_budget,
+        evidence_reservations=evidence_reservations,
+    )
+
+
+def _bounded_download_once(
+    session: _StreamingSession,
+    *,
+    url: str,
+    raw_root: Path,
+    request: DailyArchiveRequest,
+    byte_limit: int,
+    chunk_bytes: int,
+    timeout_seconds: float,
+    rejected_suffix: str,
+    attempt_number: int,
+    retained_evidence_budget: RetainedEvidenceBudget | None,
+) -> _DownloadedBody:
+    work = raw_root / "binance_spot" / ".archive_downloads"
+    if retained_evidence_budget is not None:
+        retained_evidence_budget.assert_contains(work)
+    work.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary_name = tempfile.mkstemp(dir=work, prefix=".download-", suffix=".tmp")
+    temporary = Path(temporary_name)
+    response: _StreamingResponse | None = None
+    downloaded_at = utc_now_iso()
+    safe_headers: dict[str, str] = {}
+    digest = hashlib.sha256()
+    captured = 0
+    error: BaseException | None = None
+    evidence_reservations: list[EvidenceReservation] = []
+
+    def write_chunk(sink: Any, chunk: bytes) -> None:
+        reservation = (
+            retained_evidence_budget.reserve(
+                len(chunk),
+                label=f"raw Binance archive response from {url}",
+            )
+            if retained_evidence_budget is not None
+            else None
+        )
+        if reservation is not None:
+            evidence_reservations.append(reservation)
+        try:
+            sink.write(chunk)
+        except BaseException:
+            if reservation is not None:
+                evidence_reservations.pop()
+                reservation.release()
+            raise
+
+    try:
+        with os.fdopen(descriptor, "wb") as sink:
+            descriptor = -1
+            try:
+                response = session.get(url, timeout=timeout_seconds, stream=True)
+            except requests.RequestException as exc:
+                raise _RetryableDownloadError(f"GET {url} failed before a response") from exc
+            safe_headers = _safe_headers(response.headers)
+            if str(response.url) != url:
+                raise BinanceArchiveHTTPError("archive response redirected away from exact URL")
+            if response.status_code != 200:
+                status_code = response.status_code
+                message = f"GET {url} returned HTTP {status_code}"
+                if status_code in {408, 418, 429} or 500 <= status_code <= 599:
+                    retry_after = (
+                        _retry_after_seconds(response.headers)
+                        if status_code in {418, 429}
+                        else None
+                    )
+                    raise _RetryableDownloadError(
+                        message,
+                        retry_after_seconds=retry_after,
+                    )
+                raise BinanceArchiveHTTPError(message, status_code=status_code)
+            declared = _content_length(response.headers)
+            if declared is not None and declared > byte_limit:
+                raise BinanceArchivePayloadError(
+                    f"response Content-Length {declared} exceeds byte ceiling {byte_limit}"
+                )
+            try:
+                chunks = response.iter_content(chunk_size=chunk_bytes)
+                for chunk in chunks:
+                    if not isinstance(chunk, bytes):
+                        raise BinanceArchivePayloadError("streaming response emitted non-bytes")
+                    if not chunk:
+                        continue
+                    remaining = byte_limit - captured
+                    if len(chunk) > remaining:
+                        prefix = chunk[:remaining]
+                        if prefix:
+                            write_chunk(sink, prefix)
+                            digest.update(prefix)
+                            captured += len(prefix)
+                        raise BinanceArchivePayloadError(
+                            f"response body exceeds byte ceiling {byte_limit}"
+                        )
+                    write_chunk(sink, chunk)
+                    digest.update(chunk)
+                    captured += len(chunk)
+            except requests.RequestException as exc:
+                raise _RetryableDownloadError(
+                    f"GET {url} body interrupted after {captured} bytes"
+                ) from exc
+            if declared is not None and captured < declared:
+                raise _RetryableDownloadError(
+                    f"GET {url} body truncated at {captured} of {declared} Content-Length bytes"
+                )
+            if declared is not None and captured > declared:
+                raise BinanceArchivePayloadError(
+                    f"GET {url} body length {captured} exceeds Content-Length {declared}"
+                )
+            sink.flush()
+            os.fsync(sink.fileno())
+    except BaseException as exc:
+        error = exc
+    finally:
+        if descriptor >= 0:
+            os.close(descriptor)
+        if response is not None:
+            try:
+                response.close()
+            except BaseException as exc:
+                if error is None:
+                    error = BinanceArchiveHTTPError(f"GET {url} response could not be closed")
+                    error.__cause__ = exc
+
+    if error is not None:
+        try:
+            _publish_rejected(
+                temporary,
+                raw_root=raw_root,
+                request=request,
+                source_uri=url,
+                downloaded_at_utc=downloaded_at,
+                response_headers=safe_headers,
+                reason=str(error),
+                suffix=rejected_suffix,
+                attempt_number=attempt_number,
+                retained_evidence_budget=retained_evidence_budget,
+                evidence_reservations=tuple(evidence_reservations),
+            )
+        except BaseException as evidence_error:
+            temporary.unlink(missing_ok=True)
+            _release_evidence_reservations(evidence_reservations)
+            if isinstance(evidence_error, EvidenceBudgetError):
+                raise
+            if not isinstance(evidence_error, Exception):
+                raise
+            raise BinanceArchiveError(
+                f"could not retain rejected download attempt {attempt_number}"
+            ) from evidence_error
+        raise error
+    return _DownloadedBody(
+        temporary_path=temporary,
+        sha256=digest.hexdigest(),
+        bytes=captured,
+        response_headers=safe_headers,
+        downloaded_at_utc=downloaded_at,
+        evidence_reservations=tuple(evidence_reservations),
+    )
+
+
+def _bounded_download(
+    session: _StreamingSession,
+    *,
+    url: str,
+    raw_root: Path,
+    request: DailyArchiveRequest,
+    byte_limit: int,
+    chunk_bytes: int,
+    timeout_seconds: float,
+    rejected_suffix: str,
+    retry_policy: RetryPolicy,
+    sleep: Callable[[float], None],
+    random_value: Callable[[], float],
+    retained_evidence_budget: RetainedEvidenceBudget | None,
+) -> _DownloadedBody:
+    attempts = retry_policy.max_retries + 1
+    for attempt_index in range(attempts):
+        try:
+            return _bounded_download_once(
+                session,
+                url=url,
+                raw_root=raw_root,
+                request=request,
+                byte_limit=byte_limit,
+                chunk_bytes=chunk_bytes,
+                timeout_seconds=timeout_seconds,
+                rejected_suffix=rejected_suffix,
+                attempt_number=attempt_index + 1,
+                retained_evidence_budget=retained_evidence_budget,
+            )
+        except _RetryableDownloadError as error:
+            if attempt_index >= retry_policy.max_retries:
+                error.add_note(f"exhausted {attempts} bounded download attempts")
+                error.retry_exhausted = True
+                raise
+            if error.retry_after_seconds is not None:
+                delay = error.retry_after_seconds
+            else:
+                exponential_cap = min(
+                    retry_policy.max_delay_seconds,
+                    retry_policy.base_delay_seconds * (2**attempt_index),
+                )
+                jitter = random_value()
+                if (
+                    isinstance(jitter, bool)
+                    or not isinstance(jitter, (int, float))
+                    or not math.isfinite(jitter)
+                    or not 0 <= jitter <= 1
+                ):
+                    raise ValueError("random_value must return a finite number in [0, 1]") from None
+                delay = exponential_cap * jitter
+            sleep(delay)
+    raise AssertionError("archive retry loop exhausted without a terminal result")
+
+
+def _read_bounded_file(path: Path, *, byte_limit: int) -> bytes:
+    with path.open("rb") as source:
+        content = source.read(byte_limit + 1)
+    if len(content) > byte_limit:
+        raise BinanceArchivePayloadError(f"artifact exceeds read ceiling {byte_limit}")
+    return content
+
+
+def _parse_checksum(content: bytes, *, archive_name: str) -> str:
+    match = _CHECKSUM_LINE.fullmatch(content)
+    if match is None:
+        raise BinanceArchivePayloadError(
+            "archive CHECKSUM must be one lowercase SHA-256 and exact basename"
+        )
+    digest = match.group(1).decode("ascii")
+    filename = match.group(2).decode("ascii")
+    if filename != archive_name or _SAFE_ARCHIVE_NAME.fullmatch(filename) is None:
+        raise BinanceArchivePayloadError("archive CHECKSUM names an unexpected file")
+    return digest
+
+
+def _preflight_eocd_handle(source: BinaryIO, size: int) -> _ZipDirectoryBounds:
+    if size < _EOCD_STRUCT.size:
+        raise BinanceArchivePayloadError("archive is too small to contain a ZIP directory")
+    tail_size = min(size, _MAX_EOCD_BYTES)
+    source.seek(size - tail_size)
+    tail = source.read(tail_size)
+    offset = tail.rfind(_EOCD_SIGNATURE)
+    if offset < 0 or len(tail) - offset < _EOCD_STRUCT.size:
+        raise BinanceArchivePayloadError("archive ZIP end-of-directory record is missing")
+    values = _EOCD_STRUCT.unpack_from(tail, offset)
+    _, disk, central_disk, entries_disk, entries_total, central_bytes, central_offset, comment = (
+        values
+    )
+    absolute_offset = size - tail_size + offset
+    if absolute_offset + _EOCD_STRUCT.size + comment != size:
+        raise BinanceArchivePayloadError("archive ZIP has trailing or malformed directory bytes")
+    if disk != 0 or central_disk != 0 or entries_disk != 1 or entries_total != 1:
+        raise BinanceArchivePayloadError("archive ZIP must contain exactly one single-disk member")
+    if central_bytes == 0 or central_bytes > _MAX_ZIP_ENTRY_METADATA_BYTES:
+        raise BinanceArchivePayloadError(
+            "archive ZIP central directory exceeds its metadata byte ceiling"
+        )
+    if central_offset + central_bytes != absolute_offset:
+        raise BinanceArchivePayloadError("archive ZIP central-directory bounds are invalid")
+    return _ZipDirectoryBounds(offset=central_offset, bytes=central_bytes)
+
+
+def _validate_local_file_header_handle(
+    source: BinaryIO,
+    *,
+    info: zipfile.ZipInfo,
+    expected_member: str,
+    central_offset: int,
+) -> None:
+    header_offset = int(info.header_offset)
+    if header_offset < 0 or header_offset + _LOCAL_FILE_STRUCT.size > central_offset:
+        raise BinanceArchivePayloadError("archive ZIP local-header bounds are invalid")
+    source.seek(header_offset)
+    header = source.read(_LOCAL_FILE_STRUCT.size)
+    if len(header) != _LOCAL_FILE_STRUCT.size:
+        raise BinanceArchivePayloadError("archive ZIP local header is truncated")
+    (
+        signature,
+        _version,
+        flags,
+        compression,
+        _modified_time,
+        _modified_date,
+        _crc32,
+        _compressed_bytes,
+        _uncompressed_bytes,
+        filename_bytes,
+        extra_bytes,
+    ) = _LOCAL_FILE_STRUCT.unpack(header)
+    if signature != _LOCAL_FILE_SIGNATURE:
+        raise BinanceArchivePayloadError("archive ZIP local-header signature is invalid")
+    metadata_bytes = filename_bytes + extra_bytes
+    if metadata_bytes > _MAX_ZIP_ENTRY_METADATA_BYTES:
+        raise BinanceArchivePayloadError(
+            "archive ZIP local header exceeds its metadata byte ceiling"
+        )
+    if header_offset + _LOCAL_FILE_STRUCT.size + metadata_bytes > central_offset:
+        raise BinanceArchivePayloadError("archive ZIP local-header bounds are invalid")
+    local_name = source.read(filename_bytes)
+    if local_name != expected_member.encode("ascii"):
+        raise BinanceArchivePayloadError("archive ZIP local member path/name is invalid")
+    if flags != info.flag_bits or compression != info.compress_type:
+        raise BinanceArchivePayloadError("archive ZIP local and central metadata disagree")
+
+
+def _validate_zip_structure_handle(
+    source: BinaryIO,
+    size: int,
+    *,
+    expected_member: str,
+    max_uncompressed_bytes: int,
+) -> _ZipDescriptor:
+    try:
+        directory = _preflight_eocd_handle(source, size)
+        source.seek(0)
+        with zipfile.ZipFile(source) as archive:
+            infos = archive.infolist()
+            if len(infos) != 1:
+                raise BinanceArchivePayloadError("archive ZIP must contain exactly one member")
+            info = infos[0]
+            mode = info.external_attr >> 16
+            if (
+                info.filename != expected_member
+                or Path(info.filename).name != info.filename
+                or "\\" in info.filename
+                or info.is_dir()
+            ):
+                raise BinanceArchivePayloadError("archive ZIP member path/name is invalid")
+            if stat.S_ISLNK(mode) or info.flag_bits & 0x1:
+                raise BinanceArchivePayloadError(
+                    "archive ZIP member must be regular and unencrypted"
+                )
+            if info.compress_type not in {zipfile.ZIP_STORED, zipfile.ZIP_DEFLATED}:
+                raise BinanceArchivePayloadError("archive ZIP uses an unsupported compression type")
+            if info.file_size < 1 or info.file_size > max_uncompressed_bytes:
+                raise BinanceArchiveContractError(
+                    "archive member declared uncompressed bytes outside configured ceiling",
+                    reason_code="RESPONSE_SIZE_LIMIT",
+                )
+            _validate_local_file_header_handle(
+                source,
+                info=info,
+                expected_member=expected_member,
+                central_offset=directory.offset,
+            )
+            return _ZipDescriptor(
+                member_name=info.filename,
+                declared_uncompressed_bytes=int(info.file_size),
+            )
+    except BinanceArchivePayloadError:
+        raise
+    except (OSError, RuntimeError, zipfile.BadZipFile) as exc:
+        raise BinanceArchivePayloadError("cannot inspect archive ZIP structure") from exc
+
+
+def _validate_zip_structure(
+    path: Path,
+    *,
+    expected_member: str,
+    max_uncompressed_bytes: int,
+) -> _ZipDescriptor:
+    with path.open("rb") as source:
+        return _validate_zip_structure_handle(
+            source,
+            os.fstat(source.fileno()).st_size,
+            expected_member=expected_member,
+            max_uncompressed_bytes=max_uncompressed_bytes,
+        )
+
+
+class BinanceArchiveClient:
+    """HTTP boundary for official checksum-authenticated daily Spot archives."""
+
+    def __init__(
+        self,
+        *,
+        session: _StreamingSession | None = None,
+        base_url: str = _DEFAULT_BASE_URL,
+        timeout_seconds: float = 30.0,
+        retry_policy: RetryPolicy | None = None,
+        sleep: Callable[[float], None] = time.sleep,
+        random_value: Callable[[], float] = random.random,
+        retained_evidence_budget: RetainedEvidenceBudget | None = None,
+    ) -> None:
+        if (
+            isinstance(timeout_seconds, bool)
+            or not isinstance(timeout_seconds, (int, float))
+            or not math.isfinite(timeout_seconds)
+            or timeout_seconds <= 0
+        ):
+            raise ValueError("timeout_seconds must be positive")
+        self.session = (
+            session
+            if session is not None
+            else cast(_StreamingSession, cast(object, requests.Session()))
+        )
+        self.base_url = _validate_base_url(base_url)
+        self.timeout_seconds = timeout_seconds
+        self.retry_policy = retry_policy or RetryPolicy()
+        self._sleep = sleep
+        self._random_value = random_value
+        self.retained_evidence_budget = retained_evidence_budget
+
+    def acquire(
+        self,
+        request: DailyArchiveRequest,
+        *,
+        raw_root: str | Path,
+        limits: ArchiveDownloadLimits,
+    ) -> AcquiredDailyArchive:
+        """Acquire exact raw bytes without opening the archive CSV member."""
+        destination_root = Path(raw_root).resolve()
+        archive_url, checksum_url = _archive_urls(self.base_url, request)
+        try:
+            checksum_body = _bounded_download(
+                self.session,
+                url=checksum_url,
+                raw_root=destination_root,
+                request=request,
+                byte_limit=limits.max_checksum_bytes,
+                chunk_bytes=min(limits.transfer_chunk_bytes, limits.max_checksum_bytes),
+                timeout_seconds=self.timeout_seconds,
+                rejected_suffix=".CHECKSUM.rejected",
+                retry_policy=self.retry_policy,
+                sleep=self._sleep,
+                random_value=self._random_value,
+                retained_evidence_budget=self.retained_evidence_budget,
+            )
+        except BinanceArchiveContractError:
+            raise
+        except BinanceArchivePayloadError as exc:
+            raise BinanceArchiveContractError(
+                str(exc),
+                reason_code="RESPONSE_SIZE_LIMIT",
+            ) from exc
+        try:
+            checksum_directory = (
+                destination_root
+                / "binance_spot"
+                / "daily_agg_trades_archive_checksums"
+                / request.symbol
+                / request.date.isoformat()
+            )
+            checksum_destination = checksum_directory / f"{request.archive_name}.CHECKSUM"
+            if (
+                checksum_destination.exists()
+                and sha256_file(checksum_destination) != checksum_body.sha256
+            ):
+                _publish_rejected(
+                    checksum_body.temporary_path,
+                    raw_root=destination_root,
+                    request=request,
+                    source_uri=checksum_url,
+                    downloaded_at_utc=checksum_body.downloaded_at_utc,
+                    response_headers=checksum_body.response_headers,
+                    reason="official CHECKSUM basename already contains different immutable bytes",
+                    suffix=".CHECKSUM.rejected",
+                    retained_evidence_budget=self.retained_evidence_budget,
+                    evidence_reservations=checksum_body.evidence_reservations,
+                )
+                raise BinanceArchivePayloadError(
+                    "official CHECKSUM basename collides with different immutable bytes"
+                )
+            checksum_artifact = _publish_temp(
+                checksum_body.temporary_path,
+                destination_directory=checksum_directory,
+                suffix=".CHECKSUM",
+                destination_name=f"{request.archive_name}.CHECKSUM",
+                kind="archive_checksum",
+                source="binance_spot_daily_aggtrades_archive_checksum",
+                source_uri=checksum_url,
+                downloaded_at_utc=checksum_body.downloaded_at_utc,
+                request=request,
+                sha256=checksum_body.sha256,
+                response_headers=checksum_body.response_headers,
+                upstream_checksum_sha256=None,
+                retained_evidence_budget=self.retained_evidence_budget,
+                evidence_reservations=checksum_body.evidence_reservations,
+            )
+        except BaseException:
+            _discard_download(checksum_body)
+            raise
+        try:
+            upstream_sha = _parse_checksum(
+                _read_bounded_file(checksum_artifact.path, byte_limit=limits.max_checksum_bytes),
+                archive_name=request.archive_name,
+            )
+        except BinanceArchivePayloadError as exc:
+            raise BinanceArchiveContractError(
+                str(exc),
+                reason_code="CHECKSUM_CONTRACT",
+            ) from exc
+
+        try:
+            archive_body = _bounded_download(
+                self.session,
+                url=archive_url,
+                raw_root=destination_root,
+                request=request,
+                byte_limit=limits.max_compressed_bytes,
+                chunk_bytes=limits.transfer_chunk_bytes,
+                timeout_seconds=self.timeout_seconds,
+                rejected_suffix=".zip.rejected",
+                retry_policy=self.retry_policy,
+                sleep=self._sleep,
+                random_value=self._random_value,
+                retained_evidence_budget=self.retained_evidence_budget,
+            )
+        except BinanceArchivePayloadError as exc:
+            raise BinanceArchiveContractError(
+                str(exc),
+                reason_code="RESPONSE_SIZE_LIMIT",
+            ) from exc
+        try:
+            if archive_body.sha256 != upstream_sha:
+                _publish_rejected(
+                    archive_body.temporary_path,
+                    raw_root=destination_root,
+                    request=request,
+                    source_uri=archive_url,
+                    downloaded_at_utc=archive_body.downloaded_at_utc,
+                    response_headers=archive_body.response_headers,
+                    reason=(
+                        f"archive SHA-256 {archive_body.sha256} disagrees with official {upstream_sha}"
+                    ),
+                    suffix=".zip.rejected",
+                    retained_evidence_budget=self.retained_evidence_budget,
+                    evidence_reservations=archive_body.evidence_reservations,
+                )
+                raise BinanceArchiveContractError(
+                    "archive SHA-256 disagrees with official CHECKSUM",
+                    reason_code="CHECKSUM_CONTRACT",
+                )
+
+            archive_directory = (
+                destination_root
+                / "binance_spot"
+                / "daily_agg_trades_archive"
+                / request.symbol
+                / request.date.isoformat()
+            )
+            official_destination = archive_directory / request.archive_name
+            if (
+                official_destination.exists()
+                and sha256_file(official_destination) != archive_body.sha256
+            ):
+                _publish_rejected(
+                    archive_body.temporary_path,
+                    raw_root=destination_root,
+                    request=request,
+                    source_uri=archive_url,
+                    downloaded_at_utc=archive_body.downloaded_at_utc,
+                    response_headers=archive_body.response_headers,
+                    reason="official archive basename already contains different immutable bytes",
+                    suffix=".zip.rejected",
+                    retained_evidence_budget=self.retained_evidence_budget,
+                    evidence_reservations=archive_body.evidence_reservations,
+                )
+                raise BinanceArchivePayloadError(
+                    "official archive basename collides with different immutable bytes"
+                )
+            archive_artifact = _publish_temp(
+                archive_body.temporary_path,
+                destination_directory=archive_directory,
+                suffix=".zip",
+                destination_name=request.archive_name,
+                kind="archive_zip",
+                source="binance_spot_daily_aggtrades_archive",
+                source_uri=archive_url,
+                downloaded_at_utc=archive_body.downloaded_at_utc,
+                request=request,
+                sha256=archive_body.sha256,
+                response_headers=archive_body.response_headers,
+                upstream_checksum_sha256=upstream_sha,
+                retained_evidence_budget=self.retained_evidence_budget,
+                evidence_reservations=archive_body.evidence_reservations,
+            )
+        except BaseException:
+            _discard_download(archive_body)
+            raise
+        try:
+            zip_descriptor = _validate_zip_structure(
+                archive_artifact.path,
+                expected_member=request.member_name,
+                max_uncompressed_bytes=limits.max_uncompressed_bytes,
+            )
+        except BinanceArchiveContractError:
+            raise
+        except BinanceArchivePayloadError as exc:
+            if isinstance(exc.__cause__, OSError):
+                raise
+            raise BinanceArchiveContractError(
+                str(exc),
+                reason_code="ZIP_CONTRACT",
+            ) from exc
+        return AcquiredDailyArchive(
+            request=request,
+            archive_artifact=archive_artifact,
+            checksum_artifact=checksum_artifact,
+            upstream_sha256=upstream_sha,
+            declared_uncompressed_bytes=zip_descriptor.declared_uncompressed_bytes,
+            limits=limits,
+        )
+
+
+def _parse_unsigned(value: bytes, *, label: str) -> int:
+    if len(value) > 19:
+        raise BinanceArchivePayloadError(f"{label} exceeds signed int64")
+    if _UNSIGNED_INTEGER.fullmatch(value) is None:
+        raise BinanceArchivePayloadError(f"{label} must be a canonical unsigned integer")
+    parsed = int(value)
+    if parsed > _MAX_INT64:
+        raise BinanceArchivePayloadError(f"{label} exceeds signed int64")
+    return parsed
+
+
+def _parse_boolean(value: bytes, *, label: str) -> bool:
+    lowered = value.lower()
+    if lowered == b"true":
+        return True
+    if lowered == b"false":
+        return False
+    raise BinanceArchivePayloadError(f"{label} must be true or false")
+
+
+def _scaled_decimal(value: bytes, *, quantum: Decimal, label: str) -> tuple[Decimal, int]:
+    if len(value) > _MAX_DECIMAL_FIELD_BYTES:
+        raise BinanceArchivePayloadError(f"{label} exceeds its field byte ceiling")
+    try:
+        text = value.decode("ascii")
+        decimal = Decimal(text)
+        if not decimal.is_finite() or decimal <= 0:
+            raise BinanceArchivePayloadError(f"{label} must be positive and finite")
+        scaled = decimal / quantum
+        integral = scaled.to_integral_value()
+    except (UnicodeDecodeError, InvalidOperation, ZeroDivisionError) as exc:
+        raise BinanceArchivePayloadError(f"{label} is not a valid decimal") from exc
+    if scaled != integral:
+        raise BinanceArchivePayloadError(f"{label} is not aligned to declared scale")
+    integer = int(integral)
+    if integer < 1 or integer > _MAX_INT64:
+        raise BinanceArchivePayloadError(f"{label} scaled value is outside signed int64")
+    return decimal, integer
+
+
+def _line_chunks(
+    source: Any,
+    *,
+    max_uncompressed_bytes: int,
+    chunk_bytes: int,
+    max_line_bytes: int,
+) -> Generator[bytes, None, int]:
+    pending = b""
+    expanded = 0
+    while True:
+        chunk = source.read(chunk_bytes)
+        if not isinstance(chunk, bytes):
+            raise BinanceArchivePayloadError("archive member emitted non-bytes")
+        if not chunk:
+            break
+        expanded += len(chunk)
+        if expanded > max_uncompressed_bytes:
+            raise BinanceArchivePayloadError("archive expansion exceeds configured byte ceiling")
+        combined = pending + chunk
+        pieces = combined.split(b"\n")
+        pending = pieces.pop()
+        if len(pending) > max_line_bytes:
+            raise BinanceArchivePayloadError("archive CSV line exceeds configured byte ceiling")
+        for line in pieces:
+            if line.endswith(b"\r"):
+                line = line[:-1]
+            if len(line) > max_line_bytes:
+                raise BinanceArchivePayloadError("archive CSV line exceeds configured byte ceiling")
+            yield line
+    if pending:
+        if pending.endswith(b"\r"):
+            pending = pending[:-1]
+        if len(pending) > max_line_bytes:
+            raise BinanceArchivePayloadError("archive CSV line exceeds configured byte ceiling")
+        yield pending
+    return expanded
+
+
+def _record_from_line(
+    line: bytes,
+    *,
+    row_number: int,
+    acquired: AcquiredDailyArchive,
+    previous_trade_id: int | None,
+    previous_event_ts_ns: int | None,
+    start_ns: int,
+    end_ns: int,
+) -> tuple[dict[str, object], int, int]:
+    fields = line.split(b",")
+    if len(fields) != 8:
+        raise BinanceArchivePayloadError(
+            f"archive CSV row {row_number} must contain exactly 8 fields"
+        )
+    aggregate_id = _parse_unsigned(fields[0], label=f"row {row_number} aggregate trade ID")
+    first_trade_id = _parse_unsigned(fields[3], label=f"row {row_number} first trade ID")
+    last_trade_id = _parse_unsigned(fields[4], label=f"row {row_number} last trade ID")
+    if first_trade_id > last_trade_id:
+        raise BinanceArchivePayloadError(
+            f"archive CSV row {row_number} first trade ID exceeds last trade ID"
+        )
+    if previous_trade_id is not None and aggregate_id != previous_trade_id + 1:
+        raise BinanceArchivePayloadError(
+            f"archive aggregate trade IDs are noncontiguous at row {row_number}"
+        )
+    raw_timestamp = _parse_unsigned(fields[5], label=f"row {row_number} timestamp")
+    multiplier = 1_000 if acquired.request.date >= _MICROSECOND_ARCHIVE_START else 1_000_000
+    if raw_timestamp > _MAX_INT64 // multiplier:
+        raise BinanceArchivePayloadError(f"archive CSV row {row_number} timestamp overflows ns")
+    event_ts_ns = raw_timestamp * multiplier
+    if not start_ns <= event_ts_ns < end_ns:
+        raise BinanceArchivePayloadError(
+            f"archive CSV row {row_number} timestamp is outside declared UTC date"
+        )
+    if previous_event_ts_ns is not None and event_ts_ns < previous_event_ts_ns:
+        raise BinanceArchivePayloadError(f"archive event time reverses at row {row_number}")
+    price, price_ticks = _scaled_decimal(
+        fields[1], quantum=acquired.request.tick_size, label=f"row {row_number} price"
+    )
+    quantity, quantity_lots = _scaled_decimal(
+        fields[2], quantum=acquired.request.lot_size, label=f"row {row_number} quantity"
+    )
+    buyer_is_maker = _parse_boolean(fields[6], label=f"row {row_number} buyer-maker flag")
+    _parse_boolean(fields[7], label=f"row {row_number} best-match flag")
+    record: dict[str, object] = {
+        "schema_version": SCHEMA_VERSION,
+        "venue": "binance_spot",
+        "symbol": acquired.request.symbol,
+        "event_ts_ns": event_ts_ns,
+        "received_ts_ns": None,
+        "available_ts_ns": event_ts_ns,
+        "availability_basis": "exchange_event_time_proxy",
+        "capture_seq": None,
+        "continuity_id": acquired.request.continuity_id,
+        "trade_id": aggregate_id,
+        "first_trade_id": first_trade_id,
+        "last_trade_id": last_trade_id,
+        "price_ticks": price_ticks,
+        "quantity_lots": quantity_lots,
+        "tick_size": float(acquired.request.tick_size),
+        "lot_size": float(acquired.request.lot_size),
+        "price": float(price),
+        "quantity": float(quantity),
+        "quote_quantity": float(price * quantity),
+        "aggressor_side": "sell" if buyer_is_maker else "buy",
+        "buyer_is_maker": buyer_is_maker,
+        "source_artifact_id": acquired.archive_artifact.sha256,
+    }
+    return record, aggregate_id, event_ts_ns
+
+
+def _sha256_open_file(source: BinaryIO) -> str:
+    digest = hashlib.sha256()
+    source.seek(0)
+    while chunk := source.read(1024 * 1024):
+        digest.update(chunk)
+    source.seek(0)
+    return digest.hexdigest()
+
+
+def _stream_normalized_batches(
+    acquired: AcquiredDailyArchive,
+    *,
+    batch_rows: int,
+    before_member_open: Callable[[], None] | None,
+) -> Generator[pa.RecordBatch, None, DailyArchiveSummary]:
+    if acquired.requires_member_open_guard and before_member_open is None:
+        raise BinanceArchivePayloadError("held-out archive requires a member-open authority guard")
+    archive_path = acquired.archive_artifact.path
+    nofollow = getattr(os, "O_NOFOLLOW", 0)
+    try:
+        raw_descriptor = os.open(archive_path, os.O_RDONLY | nofollow)
+    except OSError as exc:
+        raise BinanceArchivePayloadError("archive bytes are unavailable after acquisition") from exc
+    try:
+        archive_source = os.fdopen(raw_descriptor, "rb")
+    except BaseException:
+        os.close(raw_descriptor)
+        raise
+
+    start_ns, end_ns = _day_bounds_ns(acquired.request.date)
+    rows = 0
+    first_trade_id: int | None = None
+    last_trade_id: int | None = None
+    first_event_ts_ns: int | None = None
+    last_event_ts_ns: int | None = None
+    records: list[dict[str, object]] = []
+    expanded_bytes = 0
+    with archive_source:
+        try:
+            observed = os.fstat(archive_source.fileno())
+            if not stat.S_ISREG(observed.st_mode):
+                raise BinanceArchivePayloadError("archive bytes are not a regular file")
+            if observed.st_size != acquired.archive_artifact.bytes:
+                raise BinanceArchivePayloadError("archive bytes changed after acquisition")
+            if _sha256_open_file(archive_source) != acquired.archive_artifact.sha256:
+                raise BinanceArchivePayloadError("archive checksum changed after acquisition")
+            descriptor = _validate_zip_structure_handle(
+                archive_source,
+                observed.st_size,
+                expected_member=acquired.request.member_name,
+                max_uncompressed_bytes=acquired.limits.max_uncompressed_bytes,
+            )
+            if descriptor.declared_uncompressed_bytes != acquired.declared_uncompressed_bytes:
+                raise BinanceArchivePayloadError(
+                    "archive uncompressed-size claim changed after acquisition"
+                )
+            archive_source.seek(0)
+            archive_context = zipfile.ZipFile(archive_source)
+        except BinanceArchivePayloadError:
+            raise
+        except (OSError, RuntimeError, ValueError, zipfile.BadZipFile) as exc:
+            raise BinanceArchivePayloadError("cannot stream archive CSV safely") from exc
+        with archive_context as archive:
+            # The same already-hashed file descriptor backs both ZipFile and
+            # member decompression.  The path may change, but the guarded bytes
+            # cannot switch inode between authority verification and open.
+            if before_member_open is not None:
+                before_member_open()
+            try:
+                with archive.open(descriptor.member_name, "r") as member:
+                    lines = _line_chunks(
+                        member,
+                        max_uncompressed_bytes=acquired.limits.max_uncompressed_bytes,
+                        chunk_bytes=acquired.limits.transfer_chunk_bytes,
+                        max_line_bytes=acquired.limits.max_csv_line_bytes,
+                    )
+                    while True:
+                        try:
+                            line = next(lines)
+                        except StopIteration as stop:
+                            expanded_bytes = int(stop.value)
+                            break
+                        row_number = rows + 1
+                        record, trade_id, event_ts_ns = _record_from_line(
+                            line,
+                            row_number=row_number,
+                            acquired=acquired,
+                            previous_trade_id=last_trade_id,
+                            previous_event_ts_ns=last_event_ts_ns,
+                            start_ns=start_ns,
+                            end_ns=end_ns,
+                        )
+                        if first_trade_id is None:
+                            first_trade_id = trade_id
+                            first_event_ts_ns = event_ts_ns
+                        last_trade_id = trade_id
+                        last_event_ts_ns = event_ts_ns
+                        records.append(record)
+                        rows += 1
+                        if len(records) == batch_rows:
+                            table = table_from_records("trades", records)
+                            batches = table.to_batches(max_chunksize=batch_rows)
+                            if len(batches) != 1 or batches[0].num_rows > batch_rows:
+                                raise BinanceArchivePayloadError(
+                                    "archive normalizer violated its RecordBatch bound"
+                                )
+                            yield batches[0]
+                            records = []
+                    if records:
+                        table = table_from_records("trades", records)
+                        batches = table.to_batches(max_chunksize=batch_rows)
+                        if len(batches) != 1 or batches[0].num_rows > batch_rows:
+                            raise BinanceArchivePayloadError(
+                                "archive normalizer violated its RecordBatch bound"
+                            )
+                        yield batches[0]
+            except BinanceArchivePayloadError:
+                raise
+            except (
+                OSError,
+                RuntimeError,
+                UnicodeError,
+                ValueError,
+                OverflowError,
+                zipfile.BadZipFile,
+            ) as exc:
+                raise BinanceArchivePayloadError("cannot stream archive CSV safely") from exc
+
+    if (
+        rows < 1
+        or first_trade_id is None
+        or last_trade_id is None
+        or first_event_ts_ns is None
+        or last_event_ts_ns is None
+    ):
+        raise BinanceArchivePayloadError("archive CSV contains no trade rows")
+    if expanded_bytes != acquired.declared_uncompressed_bytes:
+        raise BinanceArchivePayloadError(
+            "streamed archive bytes disagree with ZIP uncompressed-size claim"
+        )
+    return DailyArchiveSummary(
+        symbol=acquired.request.symbol,
+        date=acquired.request.date.isoformat(),
+        rows=rows,
+        first_trade_id=first_trade_id,
+        last_trade_id=last_trade_id,
+        first_event_ts_ns=first_event_ts_ns,
+        last_event_ts_ns=last_event_ts_ns,
+        compressed_bytes=acquired.archive_artifact.bytes,
+        expanded_bytes=expanded_bytes,
+        source_archive_sha256=acquired.archive_artifact.sha256,
+        member_name=descriptor.member_name,
+        continuity_id=acquired.request.continuity_id,
+    )
+
+
+__all__ = [
+    "AcquiredDailyArchive",
+    "ArchiveAcquisitionReasonCode",
+    "ArchiveDownloadLimits",
+    "BinanceArchiveClient",
+    "BinanceArchiveContractError",
+    "BinanceArchiveError",
+    "BinanceArchiveHTTPError",
+    "BinanceArchivePayloadError",
+    "DailyArchiveRequest",
+    "DailyArchiveSummary",
+    "DailyArchiveTradeStream",
+    "RawArchiveArtifact",
+    "RetryPolicy",
+]

Microstructure/src/microstructure/data/book.py

@@ -0,0 +1,483 @@
+"""Pure snapshot-plus-delta order-book reconstruction.
+
+Sequence order is authoritative.  Exchange timestamps are never used to sort
+updates, so a timestamp reversal is reportable without concealing or inventing
+book continuity.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Literal
+
+import pyarrow as pa  # type: ignore[import-untyped]
+
+from microstructure.data.schemas import SCHEMA_VERSION, table_from_records
+
+BookLevel = tuple[int, int]
+_MAX_BOOK_LEVELS_PER_SIDE = 10_000
+
+
+class BookInvariantError(ValueError):
+    """Raised when a snapshot or delta contains an impossible book level."""
+
+
+class _BookCapacityError(BookInvariantError):
+    """Raised before retained book state can exceed its hard memory bound."""
+
+
+@dataclass(frozen=True, slots=True)
+class BookSnapshot:
+    venue: str
+    symbol: str
+    snapshot_id: str
+    request_ts_ns: int
+    received_ts_ns: int
+    available_ts_ns: int
+    continuity_id: str
+    last_update_id: int
+    depth_limit: int
+    bids: tuple[BookLevel, ...]
+    asks: tuple[BookLevel, ...]
+    tick_size: float
+    lot_size: float
+    source_artifact_id: str
+
+    def to_record(self) -> dict[str, object]:
+        return {
+            "schema_version": SCHEMA_VERSION,
+            "venue": self.venue,
+            "symbol": self.symbol,
+            "snapshot_id": self.snapshot_id,
+            "request_ts_ns": self.request_ts_ns,
+            "received_ts_ns": self.received_ts_ns,
+            "available_ts_ns": self.available_ts_ns,
+            "continuity_id": self.continuity_id,
+            "last_update_id": self.last_update_id,
+            "depth_limit": self.depth_limit,
+            "bids": [
+                {"price_ticks": price, "quantity_lots": quantity} for price, quantity in self.bids
+            ],
+            "asks": [
+                {"price_ticks": price, "quantity_lots": quantity} for price, quantity in self.asks
+            ],
+            "tick_size": self.tick_size,
+            "lot_size": self.lot_size,
+            "source_artifact_id": self.source_artifact_id,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class DepthDelta:
+    venue: str
+    symbol: str
+    event_ts_ns: int
+    received_ts_ns: int | None
+    available_ts_ns: int
+    availability_basis: str
+    capture_seq: int | None
+    continuity_id: str
+    first_update_id: int
+    last_update_id: int
+    previous_update_id: int | None
+    bids: tuple[BookLevel, ...]
+    asks: tuple[BookLevel, ...]
+    tick_size: float
+    lot_size: float
+    source_artifact_id: str
+
+    def to_record(self) -> dict[str, object]:
+        return {
+            "schema_version": SCHEMA_VERSION,
+            "venue": self.venue,
+            "symbol": self.symbol,
+            "event_ts_ns": self.event_ts_ns,
+            "received_ts_ns": self.received_ts_ns,
+            "available_ts_ns": self.available_ts_ns,
+            "availability_basis": self.availability_basis,
+            "capture_seq": self.capture_seq,
+            "continuity_id": self.continuity_id,
+            "first_update_id": self.first_update_id,
+            "last_update_id": self.last_update_id,
+            "previous_update_id": self.previous_update_id,
+            "bids": [
+                {"price_ticks": price, "quantity_lots": quantity} for price, quantity in self.bids
+            ],
+            "asks": [
+                {"price_ticks": price, "quantity_lots": quantity} for price, quantity in self.asks
+            ],
+            "tick_size": self.tick_size,
+            "lot_size": self.lot_size,
+            "source_artifact_id": self.source_artifact_id,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class SequenceGap:
+    venue: str
+    symbol: str
+    continuity_id: str
+    expected_sequence: int
+    observed_sequence_start: int
+    observed_sequence_end: int
+    missing_start: int
+    missing_end: int
+    detected_ts_ns: int
+    reason: str
+    source_artifact_id: str
+
+    def to_record(self) -> dict[str, object]:
+        return {
+            "schema_version": SCHEMA_VERSION,
+            "venue": self.venue,
+            "symbol": self.symbol,
+            "continuity_id": self.continuity_id,
+            "expected_sequence": self.expected_sequence,
+            "observed_sequence_start": self.observed_sequence_start,
+            "observed_sequence_end": self.observed_sequence_end,
+            "missing_start": self.missing_start,
+            "missing_end": self.missing_end,
+            "detected_ts_ns": self.detected_ts_ns,
+            "reason": self.reason,
+            "source_artifact_id": self.source_artifact_id,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class ReconstructionResult:
+    status: Literal["LIVE", "GAPPED", "INVALID"]
+    observations: pa.Table
+    gaps: pa.Table
+    stale_events: int
+    final_update_id: int
+
+
+ReconstructionOutcome = Literal[
+    "OBSERVED",
+    "STALE",
+    "GAP",
+    "INVALID",
+    "EXCLUDED_AFTER_TERMINAL",
+]
+
+
+@dataclass(frozen=True, slots=True)
+class ReconstructionStep:
+    """Bounded result of applying one delta to one continuity epoch."""
+
+    outcome: ReconstructionOutcome
+    observation: Mapping[str, object] | None
+    gap: SequenceGap | None
+
+
+def _levels_to_book(levels: tuple[BookLevel, ...], side: str) -> dict[int, int]:
+    if len(levels) > _MAX_BOOK_LEVELS_PER_SIDE:
+        raise _BookCapacityError(
+            f"{side} snapshot exceeds {_MAX_BOOK_LEVELS_PER_SIDE} retained levels"
+        )
+    result: dict[int, int] = {}
+    for price, quantity in levels:
+        if price <= 0:
+            raise BookInvariantError(f"{side} snapshot price must be positive: {price}")
+        if quantity <= 0:
+            raise BookInvariantError(f"{side} snapshot quantity must be positive: {quantity}")
+        if price in result:
+            raise BookInvariantError(f"duplicate {side} snapshot price: {price}")
+        result[price] = quantity
+    if not result:
+        raise BookInvariantError(f"{side} snapshot must not be empty")
+    return result
+
+
+def _apply_side(book: dict[int, int], changes: tuple[BookLevel, ...], side: str) -> None:
+    for price, quantity in changes:
+        if price <= 0:
+            raise BookInvariantError(f"{side} delta price must be positive: {price}")
+        if quantity < 0:
+            raise BookInvariantError(f"{side} delta quantity must not be negative: {quantity}")
+        if quantity == 0:
+            book.pop(price, None)
+        else:
+            book[price] = quantity
+    if len(book) > _MAX_BOOK_LEVELS_PER_SIDE:
+        raise _BookCapacityError(f"{side} book exceeds {_MAX_BOOK_LEVELS_PER_SIDE} retained levels")
+
+
+def _depth(book: dict[int, int], *, bids: bool, levels: int, lot_size: float) -> float:
+    ordered = sorted(book, reverse=bids)[:levels]
+    return sum(book[price] for price in ordered) * lot_size
+
+
+def _queue_imbalance(bid_depth: float, ask_depth: float) -> float:
+    total = bid_depth + ask_depth
+    return (bid_depth - ask_depth) / total if total > 0.0 else 0.0
+
+
+def _observation(
+    *,
+    snapshot: BookSnapshot,
+    delta: DepthDelta,
+    bids: dict[int, int],
+    asks: dict[int, int],
+    valid: bool,
+) -> dict[str, object]:
+    if not bids or not asks:
+        raise BookInvariantError("delta removed every price level from one side of the book")
+    best_bid_ticks = max(bids)
+    best_ask_ticks = min(asks)
+    bid_quantity_lots = bids[best_bid_ticks]
+    ask_quantity_lots = asks[best_ask_ticks]
+    best_bid = best_bid_ticks * snapshot.tick_size
+    best_ask = best_ask_ticks * snapshot.tick_size
+    bid_quantity = bid_quantity_lots * snapshot.lot_size
+    ask_quantity = ask_quantity_lots * snapshot.lot_size
+    mid_price = (best_bid + best_ask) / 2.0
+    microprice = (best_ask * bid_quantity + best_bid * ask_quantity) / (bid_quantity + ask_quantity)
+    depth_bid_1 = _depth(bids, bids=True, levels=1, lot_size=snapshot.lot_size)
+    depth_ask_1 = _depth(asks, bids=False, levels=1, lot_size=snapshot.lot_size)
+    depth_bid_5 = _depth(bids, bids=True, levels=5, lot_size=snapshot.lot_size)
+    depth_ask_5 = _depth(asks, bids=False, levels=5, lot_size=snapshot.lot_size)
+    depth_bid_10 = _depth(bids, bids=True, levels=10, lot_size=snapshot.lot_size)
+    depth_ask_10 = _depth(asks, bids=False, levels=10, lot_size=snapshot.lot_size)
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "venue": snapshot.venue,
+        "symbol": snapshot.symbol,
+        "event_ts_ns": delta.event_ts_ns,
+        "received_ts_ns": delta.received_ts_ns,
+        "available_ts_ns": max(snapshot.available_ts_ns, delta.available_ts_ns),
+        "availability_basis": delta.availability_basis,
+        "capture_seq": delta.capture_seq,
+        "continuity_id": snapshot.continuity_id,
+        "sequence_start": delta.first_update_id,
+        "sequence_end": delta.last_update_id,
+        "is_valid": valid,
+        "best_bid_ticks": best_bid_ticks,
+        "best_ask_ticks": best_ask_ticks,
+        "bid_quantity_lots": bid_quantity_lots,
+        "ask_quantity_lots": ask_quantity_lots,
+        "tick_size": snapshot.tick_size,
+        "lot_size": snapshot.lot_size,
+        "best_bid": best_bid,
+        "best_ask": best_ask,
+        "bid_quantity": bid_quantity,
+        "ask_quantity": ask_quantity,
+        "spread": best_ask - best_bid,
+        "mid_price": mid_price,
+        "microprice": microprice,
+        "depth_bid_1": depth_bid_1,
+        "depth_ask_1": depth_ask_1,
+        "depth_bid_5": depth_bid_5,
+        "depth_ask_5": depth_ask_5,
+        "depth_bid_10": depth_bid_10,
+        "depth_ask_10": depth_ask_10,
+        "queue_imbalance_1": _queue_imbalance(depth_bid_1, depth_ask_1),
+        "queue_imbalance_5": _queue_imbalance(depth_bid_5, depth_ask_5),
+        "queue_imbalance_10": _queue_imbalance(depth_bid_10, depth_ask_10),
+        "source_artifact_id": delta.source_artifact_id,
+    }
+
+
+def _gap(snapshot: BookSnapshot, delta: DepthDelta, expected: int, reason: str) -> SequenceGap:
+    missing_end = max(expected, delta.first_update_id - 1)
+    return SequenceGap(
+        venue=snapshot.venue,
+        symbol=snapshot.symbol,
+        continuity_id=snapshot.continuity_id,
+        expected_sequence=expected,
+        observed_sequence_start=delta.first_update_id,
+        observed_sequence_end=delta.last_update_id,
+        missing_start=expected,
+        missing_end=missing_end,
+        detected_ts_ns=delta.available_ts_ns,
+        reason=reason,
+        source_artifact_id=delta.source_artifact_id,
+    )
+
+
+class IncrementalBookReconstructor:
+    """Stateful O(book-depth) snapshot-plus-delta reconstruction.
+
+    The class retains only the current epoch's book.  Every input delta returns
+    an explicit outcome; after a gap or invalidation, later deltas receive an
+    ``EXCLUDED_AFTER_TERMINAL`` gap record rather than disappearing silently.
+    """
+
+    def __init__(self, snapshot: BookSnapshot) -> None:
+        if snapshot.available_ts_ns < snapshot.received_ts_ns:
+            raise BookInvariantError("snapshot cannot be available before it was received")
+        if (
+            not math.isfinite(snapshot.tick_size)
+            or not math.isfinite(snapshot.lot_size)
+            or snapshot.tick_size <= 0
+            or snapshot.lot_size <= 0
+        ):
+            raise BookInvariantError("snapshot tick and lot sizes must be finite and positive")
+        if snapshot.depth_limit < 1 or snapshot.depth_limit > _MAX_BOOK_LEVELS_PER_SIDE:
+            raise BookInvariantError(
+                f"snapshot depth_limit must be within 1..{_MAX_BOOK_LEVELS_PER_SIDE}"
+            )
+        bids = _levels_to_book(snapshot.bids, "bid")
+        asks = _levels_to_book(snapshot.asks, "ask")
+        if max(bids) >= min(asks):
+            raise BookInvariantError("snapshot is crossed or locked")
+        self.snapshot = snapshot
+        self._bids = bids
+        self._asks = asks
+        self._last_update_id = snapshot.last_update_id
+        self._stale_events = 0
+        self._status: Literal["LIVE", "GAPPED", "INVALID"] = "LIVE"
+
+    @property
+    def status(self) -> Literal["LIVE", "GAPPED", "INVALID"]:
+        return self._status
+
+    @property
+    def stale_events(self) -> int:
+        return self._stale_events
+
+    @property
+    def final_update_id(self) -> int:
+        return self._last_update_id
+
+    def _validate_identity(self, delta: DepthDelta) -> None:
+        if delta.venue != self.snapshot.venue or delta.symbol != self.snapshot.symbol:
+            raise BookInvariantError("delta venue/symbol does not match snapshot")
+        if delta.tick_size != self.snapshot.tick_size or delta.lot_size != self.snapshot.lot_size:
+            raise BookInvariantError("delta tick/lot scales do not match snapshot metadata")
+
+    def update(self, delta: DepthDelta) -> ReconstructionStep:
+        """Apply exactly one delta and return its explicit reconstruction disposition."""
+        self._validate_identity(delta)
+        expected = self._last_update_id + 1
+        if self._status != "LIVE":
+            return ReconstructionStep(
+                outcome="EXCLUDED_AFTER_TERMINAL",
+                observation=None,
+                gap=_gap(
+                    self.snapshot,
+                    delta,
+                    expected,
+                    f"epoch_already_{self._status.lower()}",
+                ),
+            )
+        if delta.continuity_id != self.snapshot.continuity_id:
+            self._status = "GAPPED"
+            return ReconstructionStep(
+                outcome="GAP",
+                observation=None,
+                gap=_gap(self.snapshot, delta, expected, "continuity_id_mismatch"),
+            )
+        if delta.last_update_id < delta.first_update_id:
+            self._status = "INVALID"
+            return ReconstructionStep(
+                outcome="INVALID",
+                observation=None,
+                gap=_gap(self.snapshot, delta, expected, "invalid_sequence_range"),
+            )
+        if delta.last_update_id <= self._last_update_id:
+            self._stale_events += 1
+            return ReconstructionStep(outcome="STALE", observation=None, gap=None)
+        if (
+            delta.previous_update_id is not None
+            and delta.previous_update_id != self._last_update_id
+        ):
+            self._status = "GAPPED"
+            return ReconstructionStep(
+                outcome="GAP",
+                observation=None,
+                gap=_gap(self.snapshot, delta, expected, "previous_update_id_mismatch"),
+            )
+        if delta.first_update_id > expected:
+            self._status = "GAPPED"
+            return ReconstructionStep(
+                outcome="GAP",
+                observation=None,
+                gap=_gap(self.snapshot, delta, expected, "forward_sequence_gap"),
+            )
+        if delta.last_update_id < expected:
+            self._stale_events += 1
+            return ReconstructionStep(outcome="STALE", observation=None, gap=None)
+
+        candidate_bids = self._bids.copy()
+        candidate_asks = self._asks.copy()
+        try:
+            _apply_side(candidate_bids, delta.bids, "bid")
+            _apply_side(candidate_asks, delta.asks, "ask")
+            if not candidate_bids or not candidate_asks:
+                raise BookInvariantError("delta emptied one side of the order book")
+            crossed = max(candidate_bids) >= min(candidate_asks)
+            observation = _observation(
+                snapshot=self.snapshot,
+                delta=delta,
+                bids=candidate_bids,
+                asks=candidate_asks,
+                valid=not crossed,
+            )
+        except _BookCapacityError:
+            self._status = "INVALID"
+            return ReconstructionStep(
+                outcome="INVALID",
+                observation=None,
+                gap=_gap(self.snapshot, delta, expected, "book_level_limit_exceeded"),
+            )
+        except BookInvariantError:
+            self._status = "INVALID"
+            return ReconstructionStep(
+                outcome="INVALID",
+                observation=None,
+                gap=_gap(self.snapshot, delta, expected, "invalid_book_level"),
+            )
+
+        self._bids = candidate_bids
+        self._asks = candidate_asks
+        self._last_update_id = delta.last_update_id
+        if crossed:
+            self._status = "INVALID"
+            return ReconstructionStep(
+                outcome="INVALID",
+                observation=observation,
+                gap=_gap(self.snapshot, delta, expected, "crossed_or_locked_book"),
+            )
+        return ReconstructionStep(outcome="OBSERVED", observation=observation, gap=None)
+
+
+def reconstruct_snapshot_and_deltas(
+    snapshot: BookSnapshot, deltas: tuple[DepthDelta, ...] | list[DepthDelta]
+) -> ReconstructionResult:
+    """Apply buffered/live deltas until an explicit gap or invariant failure.
+
+    Stale events (``u <= last_update_id``) are counted and ignored.  A usable
+    event must cover the next expected update ID, allowing safe overlap.  A
+    forward gap invalidates the continuity epoch; later events are not emitted.
+    """
+    reconstructor = IncrementalBookReconstructor(snapshot)
+    observation_records: list[dict[str, object]] = []
+    gaps: list[SequenceGap] = []
+
+    for delta in deltas:
+        step = reconstructor.update(delta)
+        if step.observation is not None:
+            observation_records.append(dict(step.observation))
+        if step.gap is not None:
+            gaps.append(step.gap)
+        if step.outcome in {"GAP", "INVALID"}:
+            break
+
+    return ReconstructionResult(
+        status=reconstructor.status,
+        observations=table_from_records("book_observations", observation_records),
+        gaps=table_from_records("sequence_gaps", [item.to_record() for item in gaps]),
+        stale_events=reconstructor.stale_events,
+        final_update_id=reconstructor.final_update_id,
+    )
+
+
+def snapshots_table(snapshots: list[BookSnapshot] | tuple[BookSnapshot, ...]) -> pa.Table:
+    return table_from_records("book_snapshots", [snapshot.to_record() for snapshot in snapshots])
+
+
+def deltas_table(deltas: list[DepthDelta] | tuple[DepthDelta, ...]) -> pa.Table:
+    return table_from_records("depth_deltas", [delta.to_record() for delta in deltas])

Microstructure/src/microstructure/data/evidence_budget.py

@@ -0,0 +1,208 @@
+"""Fail-closed accounting for retained raw-evidence bytes."""
+
+from __future__ import annotations
+
+import os
+import threading
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
+
+
+class EvidenceBudgetError(RuntimeError):
+    """Base error for retained-evidence budget failures."""
+
+
+class EvidenceBudgetExceeded(EvidenceBudgetError):
+    """Raised before a retained artifact would exceed its byte budget."""
+
+
+class EvidenceBudgetStateError(EvidenceBudgetError):
+    """Raised when a reservation is finalized more than once."""
+
+
+def _scan_regular_file_bytes(root: Path) -> int:
+    """Return logical bytes below *root* without following symbolic links."""
+    if root.is_symlink():
+        raise EvidenceBudgetError(f"evidence-budget root must not be a symlink: {root}")
+    if not root.exists():
+        return 0
+    if not root.is_dir():
+        raise EvidenceBudgetError(f"evidence-budget root is not a directory: {root}")
+
+    total = 0
+    pending = [root]
+    try:
+        while pending:
+            directory = pending.pop()
+            with os.scandir(directory) as entries:
+                for entry in entries:
+                    if entry.is_symlink():
+                        continue
+                    if entry.is_dir(follow_symlinks=False):
+                        pending.append(Path(entry.path))
+                    elif entry.is_file(follow_symlinks=False):
+                        total += entry.stat(follow_symlinks=False).st_size
+    except OSError as exc:
+        raise EvidenceBudgetError(f"cannot scan retained evidence below {root}") from exc
+    return total
+
+
+class EvidenceReservation:
+    """One exclusive byte reservation, committed only after durable retention."""
+
+    __slots__ = ("_budget", "_bytes_reserved", "_label", "_state")
+
+    def __init__(
+        self,
+        budget: RetainedEvidenceBudget,
+        bytes_reserved: int,
+        label: str,
+    ) -> None:
+        self._budget = budget
+        self._bytes_reserved = bytes_reserved
+        self._label = label
+        self._state = "active"
+
+    @property
+    def bytes_reserved(self) -> int:
+        return self._bytes_reserved
+
+    @property
+    def label(self) -> str:
+        return self._label
+
+    @property
+    def active(self) -> bool:
+        return self._state == "active"
+
+    def commit(self) -> None:
+        """Charge the reservation after its bytes have been retained."""
+        if self._state != "active":
+            raise EvidenceBudgetStateError(f"reservation is already {self._state}")
+        self._budget._commit(self._bytes_reserved)
+        self._state = "committed"
+
+    def release(self) -> None:
+        """Return an unused reservation to the available budget."""
+        if self._state != "active":
+            raise EvidenceBudgetStateError(f"reservation is already {self._state}")
+        self._budget._release(self._bytes_reserved)
+        self._state = "released"
+
+    def __enter__(self) -> EvidenceReservation:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: object | None,
+    ) -> None:
+        if self.active:
+            self.release()
+
+
+class RetainedEvidenceBudget:
+    """Thread-safe accounting for a bounded directory of immutable evidence.
+
+    Existing regular files are counted once at construction. Symbolic links
+    are neither counted nor traversed. Callers must share one instance across
+    writers targeting the same root so outstanding reservations cannot
+    oversubscribe the limit.
+    """
+
+    __slots__ = ("_limit_bytes", "_lock", "_reserved_bytes", "_root", "_used_bytes")
+
+    def __init__(self, root: str | Path, limit_bytes: int) -> None:
+        if isinstance(limit_bytes, bool) or limit_bytes < 0:
+            raise ValueError("limit_bytes must be a nonnegative integer")
+        self._root = Path(root).expanduser().absolute()
+        self._limit_bytes = limit_bytes
+        self._lock = threading.RLock()
+        self._reserved_bytes = 0
+        self._used_bytes = _scan_regular_file_bytes(self._root)
+        if self._used_bytes > self._limit_bytes:
+            raise EvidenceBudgetExceeded(
+                "preexisting retained evidence exceeds the configured byte budget: "
+                f"used={self._used_bytes}, limit={self._limit_bytes}, root={self._root}"
+            )
+
+    @property
+    def root(self) -> Path:
+        return self._root
+
+    @property
+    def limit_bytes(self) -> int:
+        return self._limit_bytes
+
+    @property
+    def used_bytes(self) -> int:
+        with self._lock:
+            return self._used_bytes
+
+    @property
+    def reserved_bytes(self) -> int:
+        with self._lock:
+            return self._reserved_bytes
+
+    @property
+    def remaining_bytes(self) -> int:
+        with self._lock:
+            return self._limit_bytes - self._used_bytes - self._reserved_bytes
+
+    def assert_contains(self, path: str | Path) -> None:
+        """Reject targets outside the budget root or below an in-root symlink."""
+        target = Path(os.path.abspath(Path(path).expanduser()))
+        if not target.is_relative_to(self._root):
+            raise EvidenceBudgetError(
+                f"retained-evidence target is outside budget root: target={target}, "
+                f"root={self._root}"
+            )
+        current = self._root
+        for component in target.relative_to(self._root).parts:
+            current /= component
+            if current.is_symlink():
+                raise EvidenceBudgetError(
+                    f"retained-evidence target traverses a symlink: {current}"
+                )
+
+    @contextmanager
+    def write_transaction(self) -> Iterator[None]:
+        """Serialize deduplication checks, reservations, and artifact commits."""
+        with self._lock:
+            yield
+
+    def reserve(
+        self,
+        bytes_to_add: int,
+        *,
+        label: str = "retained evidence",
+    ) -> EvidenceReservation:
+        """Atomically reserve bytes or fail before the caller writes them."""
+        if isinstance(bytes_to_add, bool) or bytes_to_add < 0:
+            raise ValueError("bytes_to_add must be a nonnegative integer")
+        with self._lock:
+            projected = self._used_bytes + self._reserved_bytes + bytes_to_add
+            if projected > self._limit_bytes:
+                raise EvidenceBudgetExceeded(
+                    f"{label} would exceed retained-evidence budget: "
+                    f"requested={bytes_to_add}, used={self._used_bytes}, "
+                    f"reserved={self._reserved_bytes}, limit={self._limit_bytes}, "
+                    f"root={self._root}"
+                )
+            self._reserved_bytes += bytes_to_add
+        return EvidenceReservation(self, bytes_to_add, label)
+
+    def _commit(self, bytes_reserved: int) -> None:
+        with self._lock:
+            if bytes_reserved > self._reserved_bytes:
+                raise EvidenceBudgetStateError("reservation accounting underflow on commit")
+            self._reserved_bytes -= bytes_reserved
+            self._used_bytes += bytes_reserved
+
+    def _release(self, bytes_reserved: int) -> None:
+        with self._lock:
+            if bytes_reserved > self._reserved_bytes:
+                raise EvidenceBudgetStateError("reservation accounting underflow on release")
+            self._reserved_bytes -= bytes_reserved

Microstructure/src/microstructure/data/quality.py

@@ -0,0 +1,1103 @@
+"""Non-mutating data-quality rules with explicit, machine-readable findings."""
+
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import tempfile
+from collections.abc import Iterable, Mapping
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Literal, Protocol, TextIO
+
+import pyarrow as pa  # type: ignore[import-untyped]
+
+from microstructure.data.schemas import ensure_schema, get_schema
+from microstructure.provenance import utc_now_iso, write_json
+
+Severity = Literal["ERROR", "WARNING"]
+
+
+@dataclass(frozen=True, slots=True)
+class QualityFinding:
+    rule_id: str
+    severity: Severity
+    dataset: str
+    row_index: int | None
+    symbol: str | None
+    event_ts_ns: int | None
+    message: str
+    details: Mapping[str, Any]
+
+
+@dataclass(frozen=True, slots=True)
+class ValidationReport:
+    dataset: str
+    rows_checked: int
+    findings: tuple[QualityFinding, ...]
+    total_errors: int | None = None
+    total_warnings: int | None = None
+    findings_jsonl_path: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.rows_checked < 0:
+            raise ValueError("rows_checked must be non-negative")
+        if (self.total_errors is None) != (self.total_warnings is None):
+            raise ValueError("total_errors and total_warnings must be supplied together")
+        retained_errors = sum(item.severity == "ERROR" for item in self.findings)
+        retained_warnings = sum(item.severity == "WARNING" for item in self.findings)
+        if self.total_errors is not None and self.total_errors < retained_errors:
+            raise ValueError("total_errors cannot be smaller than retained error findings")
+        if self.total_warnings is not None and self.total_warnings < retained_warnings:
+            raise ValueError("total_warnings cannot be smaller than retained warning findings")
+
+    @property
+    def has_errors(self) -> bool:
+        return self.error_count > 0
+
+    @property
+    def error_count(self) -> int:
+        if self.total_errors is not None:
+            return self.total_errors
+        return sum(item.severity == "ERROR" for item in self.findings)
+
+    @property
+    def warning_count(self) -> int:
+        if self.total_warnings is not None:
+            return self.total_warnings
+        return sum(item.severity == "WARNING" for item in self.findings)
+
+    @property
+    def findings_truncated(self) -> bool:
+        """Whether ``findings`` is only an in-memory preview of the full result."""
+        return len(self.findings) < self.error_count + self.warning_count
+
+    def to_dict(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "generated_at_utc": utc_now_iso(),
+            "dataset": self.dataset,
+            "rows_checked": self.rows_checked,
+            "summary": {"errors": self.error_count, "warnings": self.warning_count},
+            "findings": [asdict(item) for item in self.findings],
+            "mutation_policy": "observations were not changed or repaired",
+        }
+        if self.findings_truncated:
+            payload["findings_preview"] = {
+                "retained": len(self.findings),
+                "total": self.error_count + self.warning_count,
+                "truncated": True,
+            }
+        if self.findings_jsonl_path is not None:
+            payload["findings_jsonl_path"] = self.findings_jsonl_path
+        return payload
+
+    def write_json(self, path: str | Path) -> None:
+        write_json(path, self.to_dict())
+
+
+class _FindingTarget(Protocol):
+    def append(self, finding: QualityFinding) -> None: ...
+
+
+class _FindingAccumulator:
+    """Count every finding while retaining only a bounded in-memory preview."""
+
+    def __init__(
+        self,
+        *,
+        max_findings: int | None,
+        findings_jsonl_path: str | Path | None,
+    ) -> None:
+        if max_findings is not None and max_findings < 0:
+            raise ValueError("max_findings must be non-negative or None")
+        self._max_findings = max_findings
+        self._findings: list[QualityFinding] = []
+        self.error_count = 0
+        self.warning_count = 0
+        self.path = Path(findings_jsonl_path) if findings_jsonl_path is not None else None
+        self._temporary_path: Path | None = None
+        self._sink: TextIO | None = None
+        if self.path is not None:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            descriptor, temporary_name = tempfile.mkstemp(
+                dir=self.path.parent,
+                prefix=f".{self.path.name}.",
+                suffix=".tmp",
+                text=True,
+            )
+            self._temporary_path = Path(temporary_name)
+            self._sink = os.fdopen(descriptor, "w", encoding="utf-8")
+
+    @property
+    def findings(self) -> tuple[QualityFinding, ...]:
+        return tuple(self._findings)
+
+    def append(self, finding: QualityFinding) -> None:
+        if finding.severity == "ERROR":
+            self.error_count += 1
+        else:
+            self.warning_count += 1
+        if self._max_findings is None or len(self._findings) < self._max_findings:
+            self._findings.append(finding)
+        if self._sink is not None:
+            self._sink.write(
+                json.dumps(
+                    asdict(finding),
+                    ensure_ascii=False,
+                    separators=(",", ":"),
+                    sort_keys=True,
+                )
+            )
+            self._sink.write("\n")
+
+    def flush(self) -> None:
+        if self._sink is not None:
+            self._sink.flush()
+
+    def publish(self) -> None:
+        if self._sink is not None:
+            self._sink.flush()
+            os.fsync(self._sink.fileno())
+            self._sink.close()
+            self._sink = None
+        if self.path is not None and self._temporary_path is not None:
+            os.replace(self._temporary_path, self.path)
+            self._temporary_path = None
+
+    def close(self) -> None:
+        if self._sink is not None:
+            self._sink.close()
+            self._sink = None
+        if self._temporary_path is not None:
+            self._temporary_path.unlink(missing_ok=True)
+            self._temporary_path = None
+
+
+def _continuity_key(continuity_id: object) -> tuple[int, str]:
+    if continuity_id is None:
+        return (1, "")
+    return (0, str(continuity_id))
+
+
+class _SpillState:
+    """Disk-backed exact state whose RAM use does not grow with row history."""
+
+    def __init__(self) -> None:
+        # An empty SQLite filename creates a private temporary on-disk database
+        # which is deleted when the connection closes.
+        self._connection = sqlite3.connect("")
+        self._connection.execute("PRAGMA cache_size = -2048")
+        self._connection.execute("PRAGMA temp_store = FILE")
+        self._connection.execute("PRAGMA journal_mode = OFF")
+        self._connection.execute("PRAGMA synchronous = OFF")
+        self._connection.executescript(
+            """
+            CREATE TABLE event_state (
+                venue TEXT NOT NULL,
+                symbol TEXT NOT NULL,
+                continuity_is_null INTEGER NOT NULL,
+                continuity_id TEXT NOT NULL,
+                event_ts_ns INTEGER NOT NULL,
+                received_ts_ns INTEGER,
+                row_index INTEGER NOT NULL,
+                PRIMARY KEY (venue, symbol, continuity_is_null, continuity_id)
+            ) WITHOUT ROWID;
+            CREATE TABLE sequence_state (
+                sequence_kind TEXT NOT NULL,
+                venue TEXT NOT NULL,
+                symbol TEXT NOT NULL,
+                continuity_is_null INTEGER NOT NULL,
+                continuity_id TEXT NOT NULL,
+                sequence_end INTEGER NOT NULL,
+                PRIMARY KEY (
+                    sequence_kind,
+                    venue,
+                    symbol,
+                    continuity_is_null,
+                    continuity_id
+                )
+            ) WITHOUT ROWID;
+            CREATE TABLE trade_identity (
+                venue TEXT NOT NULL,
+                symbol TEXT NOT NULL,
+                trade_id INTEGER NOT NULL,
+                first_row INTEGER NOT NULL,
+                PRIMARY KEY (venue, symbol, trade_id)
+            ) WITHOUT ROWID;
+            """
+        )
+
+    def get_event(self, key: tuple[str, str, str | None]) -> tuple[int, int | None, int] | None:
+        continuity_is_null, continuity_id = _continuity_key(key[2])
+        result = self._connection.execute(
+            """
+            SELECT event_ts_ns, received_ts_ns, row_index
+            FROM event_state
+            WHERE venue = ? AND symbol = ?
+              AND continuity_is_null = ? AND continuity_id = ?
+            """,
+            (key[0], key[1], continuity_is_null, continuity_id),
+        ).fetchone()
+        if result is None:
+            return None
+        event_ts_ns, received_ts_ns, row_index = result
+        return (
+            int(event_ts_ns),
+            int(received_ts_ns) if received_ts_ns is not None else None,
+            int(row_index),
+        )
+
+    def set_event(
+        self,
+        key: tuple[str, str, str | None],
+        value: tuple[int, int | None, int],
+    ) -> None:
+        continuity_is_null, continuity_id = _continuity_key(key[2])
+        self._connection.execute(
+            """
+            INSERT INTO event_state (
+                venue, symbol, continuity_is_null, continuity_id,
+                event_ts_ns, received_ts_ns, row_index
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT (venue, symbol, continuity_is_null, continuity_id)
+            DO UPDATE SET
+                event_ts_ns = excluded.event_ts_ns,
+                received_ts_ns = excluded.received_ts_ns,
+                row_index = excluded.row_index
+            """,
+            (*key[:2], continuity_is_null, continuity_id, *value),
+        )
+
+    def get_sequence(self, kind: str, key: tuple[str, str, str | None]) -> int | None:
+        continuity_is_null, continuity_id = _continuity_key(key[2])
+        result = self._connection.execute(
+            """
+            SELECT sequence_end
+            FROM sequence_state
+            WHERE sequence_kind = ? AND venue = ? AND symbol = ?
+              AND continuity_is_null = ? AND continuity_id = ?
+            """,
+            (kind, key[0], key[1], continuity_is_null, continuity_id),
+        ).fetchone()
+        return int(result[0]) if result is not None else None
+
+    def set_sequence(
+        self,
+        kind: str,
+        key: tuple[str, str, str | None],
+        sequence_end: int,
+    ) -> None:
+        continuity_is_null, continuity_id = _continuity_key(key[2])
+        self._connection.execute(
+            """
+            INSERT INTO sequence_state (
+                sequence_kind, venue, symbol, continuity_is_null,
+                continuity_id, sequence_end
+            ) VALUES (?, ?, ?, ?, ?, ?)
+            ON CONFLICT (
+                sequence_kind, venue, symbol, continuity_is_null, continuity_id
+            ) DO UPDATE SET sequence_end = excluded.sequence_end
+            """,
+            (kind, key[0], key[1], continuity_is_null, continuity_id, sequence_end),
+        )
+
+    def first_trade_row_or_insert(
+        self, identity: tuple[str, str, int], row_index: int
+    ) -> int | None:
+        try:
+            self._connection.execute(
+                """
+                INSERT INTO trade_identity (venue, symbol, trade_id, first_row)
+                VALUES (?, ?, ?, ?)
+                """,
+                (*identity, row_index),
+            )
+        except sqlite3.IntegrityError:
+            result = self._connection.execute(
+                """
+                SELECT first_row FROM trade_identity
+                WHERE venue = ? AND symbol = ? AND trade_id = ?
+                """,
+                identity,
+            ).fetchone()
+            if result is None:  # pragma: no cover - guarded by the primary key
+                raise RuntimeError("duplicate identity disappeared from quality state") from None
+            return int(result[0])
+        return None
+
+    def commit(self) -> None:
+        self._connection.commit()
+
+    def close(self) -> None:
+        self._connection.close()
+
+
+class _ValidationState(Protocol):
+    def get_event(self, key: tuple[str, str, str | None]) -> tuple[int, int | None, int] | None: ...
+
+    def set_event(
+        self,
+        key: tuple[str, str, str | None],
+        value: tuple[int, int | None, int],
+    ) -> None: ...
+
+    def get_sequence(self, kind: str, key: tuple[str, str, str | None]) -> int | None: ...
+
+    def set_sequence(
+        self,
+        kind: str,
+        key: tuple[str, str, str | None],
+        sequence_end: int,
+    ) -> None: ...
+
+    def first_trade_row_or_insert(
+        self, identity: tuple[str, str, int], row_index: int
+    ) -> int | None: ...
+
+
+class _MemoryState:
+    def __init__(self) -> None:
+        self._events: dict[tuple[str, str, str | None], tuple[int, int | None, int]] = {}
+        self._sequences: dict[tuple[str, str, str, str | None], int] = {}
+        self._trade_identities: dict[tuple[str, str, int], int] = {}
+
+    def get_event(self, key: tuple[str, str, str | None]) -> tuple[int, int | None, int] | None:
+        return self._events.get(key)
+
+    def set_event(
+        self,
+        key: tuple[str, str, str | None],
+        value: tuple[int, int | None, int],
+    ) -> None:
+        self._events[key] = value
+
+    def get_sequence(self, kind: str, key: tuple[str, str, str | None]) -> int | None:
+        return self._sequences.get((kind, *key))
+
+    def set_sequence(
+        self,
+        kind: str,
+        key: tuple[str, str, str | None],
+        sequence_end: int,
+    ) -> None:
+        self._sequences[(kind, *key)] = sequence_end
+
+    def first_trade_row_or_insert(
+        self, identity: tuple[str, str, int], row_index: int
+    ) -> int | None:
+        first_row = self._trade_identities.get(identity)
+        if first_row is None:
+            self._trade_identities[identity] = row_index
+        return first_row
+
+
+def _finding(
+    findings: _FindingTarget,
+    *,
+    rule_id: str,
+    severity: Severity,
+    dataset: str,
+    row_index: int | None,
+    row: Mapping[str, Any] | None,
+    message: str,
+    details: Mapping[str, Any] | None = None,
+) -> None:
+    findings.append(
+        QualityFinding(
+            rule_id=rule_id,
+            severity=severity,
+            dataset=dataset,
+            row_index=row_index,
+            symbol=str(row["symbol"]) if row is not None and row.get("symbol") else None,
+            event_ts_ns=(
+                int(row["event_ts_ns"])
+                if row is not None and row.get("event_ts_ns") is not None
+                else None
+            ),
+            message=message,
+            details=details or {},
+        )
+    )
+
+
+def _validate_event_clocks(
+    rows: list[dict[str, Any]],
+    *,
+    dataset: str,
+    findings: _FindingTarget,
+    max_silence_ns: int,
+    row_offset: int = 0,
+    state: _ValidationState | None = None,
+) -> None:
+    validation_state = state if state is not None else _MemoryState()
+    for local_index, row in enumerate(rows):
+        index = row_offset + local_index
+        event_ts = int(row["event_ts_ns"])
+        available_ts = int(row["available_ts_ns"])
+        received = row.get("received_ts_ns")
+        received_ts = int(received) if received is not None else None
+        if available_ts < event_ts:
+            _finding(
+                findings,
+                rule_id="temporal.available_before_event",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="observation is marked available before its exchange event time",
+                details={"event_ts_ns": event_ts, "available_ts_ns": available_ts},
+            )
+        if received_ts is not None and available_ts < received_ts:
+            _finding(
+                findings,
+                rule_id="temporal.available_before_receipt",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="live observation is marked available before local receipt",
+                details={"received_ts_ns": received_ts, "available_ts_ns": available_ts},
+            )
+
+        key = (str(row["venue"]), str(row["symbol"]), row.get("continuity_id"))
+        prior = validation_state.get_event(key)
+        if prior is not None:
+            previous_event, previous_received, previous_index = prior
+            if event_ts < previous_event:
+                _finding(
+                    findings,
+                    rule_id="temporal.out_of_order_event_time",
+                    severity="WARNING",
+                    dataset=dataset,
+                    row_index=index,
+                    row=row,
+                    message="exchange timestamps reversed in source/capture order",
+                    details={
+                        "previous_row": previous_index,
+                        "previous_event_ts_ns": previous_event,
+                    },
+                )
+            if event_ts - previous_event > max_silence_ns:
+                _finding(
+                    findings,
+                    rule_id="temporal.long_silence",
+                    severity="WARNING",
+                    dataset=dataset,
+                    row_index=index,
+                    row=row,
+                    message="time between events exceeded configured silence threshold",
+                    details={"silence_ns": event_ts - previous_event},
+                )
+            if (
+                received_ts is not None
+                and previous_received is not None
+                and received_ts < previous_received
+            ):
+                _finding(
+                    findings,
+                    rule_id="temporal.receive_clock_reversal",
+                    severity="WARNING",
+                    dataset=dataset,
+                    row_index=index,
+                    row=row,
+                    message="wall-clock receipt timestamp moved backwards",
+                    details={
+                        "previous_row": previous_index,
+                        "previous_received_ts_ns": previous_received,
+                    },
+                )
+        validation_state.set_event(key, (event_ts, received_ts, index))
+
+
+def _validate_trades(
+    rows: list[dict[str, Any]],
+    dataset: str,
+    findings: _FindingTarget,
+    *,
+    row_offset: int = 0,
+    state: _ValidationState | None = None,
+) -> None:
+    validation_state = state if state is not None else _MemoryState()
+    for local_index, row in enumerate(rows):
+        index = row_offset + local_index
+        identity = (str(row["venue"]), str(row["symbol"]), int(row["trade_id"]))
+        first_row = validation_state.first_trade_row_or_insert(identity, index)
+        if first_row is not None:
+            _finding(
+                findings,
+                rule_id="trade.duplicate",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="duplicate trade identity was preserved",
+                details={"first_row": first_row, "trade_id": identity[2]},
+            )
+        if int(row["price_ticks"]) <= 0 or float(row["price"]) <= 0.0:
+            _finding(
+                findings,
+                rule_id="trade.nonpositive_price",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="trade price is zero or negative",
+            )
+        if int(row["quantity_lots"]) <= 0 or float(row["quantity"]) <= 0.0:
+            _finding(
+                findings,
+                rule_id="trade.nonpositive_quantity",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="trade quantity is zero or negative",
+            )
+        expected_price = int(row["price_ticks"]) * float(row["tick_size"])
+        expected_quantity = int(row["quantity_lots"]) * float(row["lot_size"])
+        if abs(expected_price - float(row["price"])) > max(1e-12, abs(expected_price) * 1e-12):
+            _finding(
+                findings,
+                rule_id="trade.price_scale_mismatch",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="floating price does not match exact ticks and tick size",
+            )
+        if abs(expected_quantity - float(row["quantity"])) > max(
+            1e-12, abs(expected_quantity) * 1e-12
+        ):
+            _finding(
+                findings,
+                rule_id="trade.quantity_scale_mismatch",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="floating quantity does not match exact lots and lot size",
+            )
+        if row["aggressor_side"] not in {"buy", "sell"}:
+            _finding(
+                findings,
+                rule_id="trade.invalid_aggressor_side",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="aggressor side is outside the normalized enum",
+            )
+
+
+def _validate_book_sequences(
+    rows: list[dict[str, Any]],
+    dataset: str,
+    findings: _FindingTarget,
+    *,
+    row_offset: int = 0,
+    state: _ValidationState | None = None,
+) -> None:
+    validation_state = state if state is not None else _MemoryState()
+    for local_index, row in enumerate(rows):
+        index = row_offset + local_index
+        start = int(row["sequence_start"])
+        end = int(row["sequence_end"])
+        if end < start:
+            _finding(
+                findings,
+                rule_id="sequence.invalid_range",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="sequence range ends before it starts",
+            )
+            continue
+        key = (str(row["venue"]), str(row["symbol"]), row.get("continuity_id"))
+        prior = validation_state.get_sequence("book_observations", key)
+        if prior is not None:
+            expected = prior + 1
+            if start > expected:
+                _finding(
+                    findings,
+                    rule_id="sequence.missing_range",
+                    severity="ERROR",
+                    dataset=dataset,
+                    row_index=index,
+                    row=row,
+                    message="book sequence has a forward gap",
+                    details={
+                        "expected_sequence": expected,
+                        "observed_start": start,
+                        "missing_start": expected,
+                        "missing_end": start - 1,
+                    },
+                )
+            elif end <= prior:
+                _finding(
+                    findings,
+                    rule_id="sequence.stale_or_duplicate",
+                    severity="WARNING",
+                    dataset=dataset,
+                    row_index=index,
+                    row=row,
+                    message="sequence event is fully stale or duplicated",
+                    details={"previous_end": prior},
+                )
+        validation_state.set_sequence(
+            "book_observations",
+            key,
+            max(prior if prior is not None else end, end),
+        )
+
+
+def _validate_books(
+    rows: list[dict[str, Any]],
+    dataset: str,
+    findings: _FindingTarget,
+    max_spread_bps: float,
+    *,
+    row_offset: int = 0,
+    state: _ValidationState | None = None,
+) -> None:
+    _validate_book_sequences(
+        rows,
+        dataset,
+        findings,
+        row_offset=row_offset,
+        state=state,
+    )
+    for local_index, row in enumerate(rows):
+        index = row_offset + local_index
+        bid = float(row["best_bid"])
+        ask = float(row["best_ask"])
+        bid_quantity = float(row["bid_quantity"])
+        ask_quantity = float(row["ask_quantity"])
+        mid = float(row["mid_price"])
+        tick_size = float(row["tick_size"])
+        lot_size = float(row["lot_size"])
+        expected_bid = int(row["best_bid_ticks"]) * tick_size
+        expected_ask = int(row["best_ask_ticks"]) * tick_size
+        expected_bid_quantity = int(row["bid_quantity_lots"]) * lot_size
+        expected_ask_quantity = int(row["ask_quantity_lots"]) * lot_size
+        if abs(expected_bid - bid) > max(1e-12, abs(expected_bid) * 1e-12) or abs(
+            expected_ask - ask
+        ) > max(1e-12, abs(expected_ask) * 1e-12):
+            _finding(
+                findings,
+                rule_id="book.price_scale_mismatch",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="floating best prices do not match exact ticks and tick size",
+            )
+        if abs(expected_bid_quantity - bid_quantity) > max(
+            1e-12, abs(expected_bid_quantity) * 1e-12
+        ) or abs(expected_ask_quantity - ask_quantity) > max(
+            1e-12, abs(expected_ask_quantity) * 1e-12
+        ):
+            _finding(
+                findings,
+                rule_id="book.quantity_scale_mismatch",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="floating best quantities do not match exact lots and lot size",
+            )
+        if bid <= 0.0 or ask <= 0.0:
+            _finding(
+                findings,
+                rule_id="book.nonpositive_price",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="best price is zero or negative",
+            )
+        if bid_quantity <= 0.0 or ask_quantity <= 0.0:
+            _finding(
+                findings,
+                rule_id="book.nonpositive_quantity",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="best-level quantity is zero or negative",
+            )
+        if bid >= ask:
+            _finding(
+                findings,
+                rule_id="book.crossed_or_locked",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="best bid is greater than or equal to best ask",
+                details={"best_bid": bid, "best_ask": ask},
+            )
+        if mid > 0.0:
+            relative_spread_bps = (ask - bid) / mid * 10_000.0
+            if relative_spread_bps > max_spread_bps:
+                _finding(
+                    findings,
+                    rule_id="book.abnormal_spread",
+                    severity="WARNING",
+                    dataset=dataset,
+                    row_index=index,
+                    row=row,
+                    message="relative spread exceeded configured threshold",
+                    details={
+                        "spread_bps": relative_spread_bps,
+                        "threshold_bps": max_spread_bps,
+                    },
+                )
+        microprice = float(row["microprice"])
+        if not bid <= microprice <= ask:
+            _finding(
+                findings,
+                rule_id="book.microprice_outside_quotes",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="microprice is outside the contemporaneous quotes",
+            )
+        for side in ("bid", "ask"):
+            depth_1 = float(row[f"depth_{side}_1"])
+            depth_5 = float(row[f"depth_{side}_5"])
+            depth_10 = float(row[f"depth_{side}_10"])
+            if not 0.0 < depth_1 <= depth_5 <= depth_10:
+                _finding(
+                    findings,
+                    rule_id="book.nonmonotone_depth",
+                    severity="ERROR",
+                    dataset=dataset,
+                    row_index=index,
+                    row=row,
+                    message=f"cumulative {side} depth is not positive and monotone",
+                )
+        if not bool(row["is_valid"]):
+            _finding(
+                findings,
+                rule_id="book.invalid_state",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="reconstructor marked this state invalid",
+            )
+
+
+def _validate_depth_deltas(
+    rows: list[dict[str, Any]],
+    dataset: str,
+    findings: _FindingTarget,
+    *,
+    row_offset: int = 0,
+    state: _ValidationState | None = None,
+) -> None:
+    validation_state = state if state is not None else _MemoryState()
+    for local_index, row in enumerate(rows):
+        index = row_offset + local_index
+        start = int(row["first_update_id"])
+        end = int(row["last_update_id"])
+        if end < start:
+            _finding(
+                findings,
+                rule_id="sequence.invalid_range",
+                severity="ERROR",
+                dataset=dataset,
+                row_index=index,
+                row=row,
+                message="delta sequence range ends before it starts",
+            )
+        else:
+            key = (str(row["venue"]), str(row["symbol"]), row.get("continuity_id"))
+            prior = validation_state.get_sequence("depth_deltas", key)
+            if prior is not None:
+                expected = prior + 1
+                previous_hint = row.get("previous_update_id")
+                if previous_hint is not None and int(previous_hint) != prior:
+                    _finding(
+                        findings,
+                        rule_id="sequence.previous_id_mismatch",
+                        severity="ERROR",
+                        dataset=dataset,
+                        row_index=index,
+                        row=row,
+                        message="delta previous-update hint does not match the prior event",
+                        details={"expected_previous": prior, "observed_previous": previous_hint},
+                    )
+                if start > expected:
+                    _finding(
+                        findings,
+                        rule_id="sequence.missing_range",
+                        severity="ERROR",
+                        dataset=dataset,
+                        row_index=index,
+                        row=row,
+                        message="depth delta sequence has a forward gap",
+                        details={
+                            "expected_sequence": expected,
+                            "observed_start": start,
+                            "missing_start": expected,
+                            "missing_end": start - 1,
+                        },
+                    )
+                elif end <= prior:
+                    _finding(
+                        findings,
+                        rule_id="sequence.stale_or_duplicate",
+                        severity="WARNING",
+                        dataset=dataset,
+                        row_index=index,
+                        row=row,
+                        message="depth delta is fully stale or duplicated",
+                        details={"previous_end": prior},
+                    )
+            validation_state.set_sequence(
+                "depth_deltas",
+                key,
+                max(prior if prior is not None else end, end),
+            )
+        for side in ("bids", "asks"):
+            seen_prices: set[int] = set()
+            for level in row[side]:
+                price_ticks = int(level["price_ticks"])
+                quantity_lots = int(level["quantity_lots"])
+                if price_ticks <= 0:
+                    _finding(
+                        findings,
+                        rule_id="depth.nonpositive_price",
+                        severity="ERROR",
+                        dataset=dataset,
+                        row_index=index,
+                        row=row,
+                        message="depth change contains a zero or negative price",
+                    )
+                # Zero is a documented delete instruction, not bad quantity.
+                if quantity_lots < 0:
+                    _finding(
+                        findings,
+                        rule_id="depth.negative_quantity",
+                        severity="ERROR",
+                        dataset=dataset,
+                        row_index=index,
+                        row=row,
+                        message="depth change contains a negative quantity",
+                    )
+                if price_ticks in seen_prices:
+                    _finding(
+                        findings,
+                        rule_id="depth.duplicate_price_in_event",
+                        severity="WARNING",
+                        dataset=dataset,
+                        row_index=index,
+                        row=row,
+                        message="one delta updates the same side/price more than once",
+                        details={"side": side, "price_ticks": price_ticks},
+                    )
+                seen_prices.add(price_ticks)
+
+
+class IncrementalQualityValidator:
+    """Validate normalized Arrow batches without retaining the row history.
+
+    Clock, sequence, and exact trade-identity state spill to a private temporary
+    SQLite database. ``findings`` in the final report is a bounded preview, while
+    total severity counts remain exact. Supplying ``findings_jsonl_path`` streams
+    every finding to JSONL in detection order.
+    """
+
+    def __init__(
+        self,
+        schema_name: str,
+        *,
+        max_spread_bps: float = 100.0,
+        max_silence_ns: int = 5_000_000_000,
+        max_findings: int | None = 1_000,
+        findings_jsonl_path: str | Path | None = None,
+        row_chunk_size: int = 16_384,
+    ) -> None:
+        get_schema(schema_name)
+        if row_chunk_size <= 0:
+            raise ValueError("row_chunk_size must be positive")
+        self.schema_name = schema_name
+        self.max_spread_bps = max_spread_bps
+        self.max_silence_ns = max_silence_ns
+        self.row_chunk_size = row_chunk_size
+        self._state = _SpillState()
+        try:
+            self._findings = _FindingAccumulator(
+                max_findings=max_findings,
+                findings_jsonl_path=findings_jsonl_path,
+            )
+        except BaseException:
+            self._state.close()
+            raise
+        self._rows_checked = 0
+        self._closed = False
+        self._report: ValidationReport | None = None
+
+    def __enter__(self) -> IncrementalQualityValidator:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: object,
+    ) -> None:
+        self.close()
+
+    @property
+    def rows_checked(self) -> int:
+        return self._rows_checked
+
+    def _require_open(self) -> None:
+        if self._closed:
+            raise RuntimeError("incremental quality validator is already closed")
+
+    def _validate_rows(self, rows: list[dict[str, Any]]) -> None:
+        row_offset = self._rows_checked
+        if self.schema_name in {"trades", "book_observations", "depth_deltas"}:
+            _validate_event_clocks(
+                rows,
+                dataset=self.schema_name,
+                findings=self._findings,
+                max_silence_ns=self.max_silence_ns,
+                row_offset=row_offset,
+                state=self._state,
+            )
+        if self.schema_name == "trades":
+            _validate_trades(
+                rows,
+                self.schema_name,
+                self._findings,
+                row_offset=row_offset,
+                state=self._state,
+            )
+        elif self.schema_name == "book_observations":
+            _validate_books(
+                rows,
+                self.schema_name,
+                self._findings,
+                self.max_spread_bps,
+                row_offset=row_offset,
+                state=self._state,
+            )
+        elif self.schema_name == "depth_deltas":
+            _validate_depth_deltas(
+                rows,
+                self.schema_name,
+                self._findings,
+                row_offset=row_offset,
+                state=self._state,
+            )
+        self._rows_checked += len(rows)
+
+    def update(self, batch: pa.Table | pa.RecordBatch) -> None:
+        """Consume one table or record batch without changing its observations."""
+        self._require_open()
+        if not isinstance(batch, (pa.Table, pa.RecordBatch)):
+            raise TypeError("batch must be a pyarrow Table or RecordBatch")
+        if batch.num_rows == 0:
+            ensure_schema(batch, self.schema_name)
+            return
+        for start in range(0, batch.num_rows, self.row_chunk_size):
+            chunk = batch.slice(start, self.row_chunk_size)
+            ensure_schema(chunk, self.schema_name)
+            self._validate_rows(chunk.to_pylist())
+            self._state.commit()
+            self._findings.flush()
+
+    def finish(self) -> ValidationReport:
+        """Close spill resources and return the exact-count validation report."""
+        if self._report is not None:
+            return self._report
+        self._require_open()
+        self._state.commit()
+        self._findings.flush()
+        self._findings.publish()
+        self._state.close()
+        self._closed = True
+        jsonl_path = self._findings.path
+        self._report = ValidationReport(
+            dataset=self.schema_name,
+            rows_checked=self._rows_checked,
+            findings=self._findings.findings,
+            total_errors=self._findings.error_count,
+            total_warnings=self._findings.warning_count,
+            findings_jsonl_path=str(jsonl_path.resolve()) if jsonl_path is not None else None,
+        )
+        return self._report
+
+    def close(self) -> None:
+        """Release resources without fabricating a report for unfinished input."""
+        if self._closed:
+            return
+        self._findings.close()
+        self._state.close()
+        self._closed = True
+
+
+def validate_batches(
+    batches: Iterable[pa.Table | pa.RecordBatch],
+    schema_name: str,
+    *,
+    max_spread_bps: float = 100.0,
+    max_silence_ns: int = 5_000_000_000,
+    max_findings: int | None = 1_000,
+    findings_jsonl_path: str | Path | None = None,
+    row_chunk_size: int = 16_384,
+) -> ValidationReport:
+    """Consume an iterable once and validate it with bounded retained state."""
+    validator = IncrementalQualityValidator(
+        schema_name,
+        max_spread_bps=max_spread_bps,
+        max_silence_ns=max_silence_ns,
+        max_findings=max_findings,
+        findings_jsonl_path=findings_jsonl_path,
+        row_chunk_size=row_chunk_size,
+    )
+    try:
+        for batch in batches:
+            validator.update(batch)
+        return validator.finish()
+    except BaseException:
+        validator.close()
+        raise
+
+
+def validate_table(
+    table: pa.Table,
+    schema_name: str,
+    *,
+    max_spread_bps: float = 100.0,
+    max_silence_ns: int = 5_000_000_000,
+) -> ValidationReport:
+    """Validate without sorting, de-duplicating, clipping, or changing rows."""
+    ensure_schema(table, schema_name)
+    rows = table.to_pylist()
+    findings: list[QualityFinding] = []
+    if schema_name in {"trades", "book_observations", "depth_deltas"}:
+        _validate_event_clocks(
+            rows,
+            dataset=schema_name,
+            findings=findings,
+            max_silence_ns=max_silence_ns,
+        )
+    if schema_name == "trades":
+        _validate_trades(rows, schema_name, findings)
+    elif schema_name == "book_observations":
+        _validate_books(rows, schema_name, findings, max_spread_bps)
+    elif schema_name == "depth_deltas":
+        _validate_depth_deltas(rows, schema_name, findings)
+    return ValidationReport(
+        dataset=schema_name,
+        rows_checked=table.num_rows,
+        findings=tuple(findings),
+    )

Microstructure/src/microstructure/data/schemas.py

@@ -0,0 +1,223 @@
+"""Versioned normalized Arrow schemas and their temporal contract.
+
+All timestamps are signed UTC epoch nanoseconds.  ``available_ts_ns`` is the
+earliest time at which a row may enter a research information set.  Archive
+rows explicitly identify exchange event time as a proxy; live rows use local
+receipt time.  Prices and quantities retain exact integer tick/lot columns and
+also expose documented floating convenience columns for research consumers.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from typing import Any
+
+import pyarrow as pa  # type: ignore[import-untyped]
+
+SCHEMA_VERSION = "1.0.0"
+
+
+class SchemaError(ValueError):
+    """Raised when a normalized table violates its declared schema."""
+
+
+def _metadata(name: str) -> dict[bytes, bytes]:
+    return {
+        b"schema_name": name.encode(),
+        b"schema_version": SCHEMA_VERSION.encode(),
+        b"timestamp_unit": b"UTC epoch nanoseconds",
+        b"temporal_contract": (
+            b"available_ts_ns is the information-set clock; event_ts_ns alone is not receipt proof"
+        ),
+        b"numeric_contract": (
+            b"price_ticks and quantity_lots are exact; float columns are convenience units"
+        ),
+    }
+
+
+_COMMON_EVENT_FIELDS = [
+    pa.field("schema_version", pa.string(), nullable=False),
+    pa.field("venue", pa.string(), nullable=False),
+    pa.field("symbol", pa.string(), nullable=False),
+    pa.field("event_ts_ns", pa.int64(), nullable=False),
+    pa.field("received_ts_ns", pa.int64()),
+    pa.field("available_ts_ns", pa.int64(), nullable=False),
+    pa.field("availability_basis", pa.string(), nullable=False),
+    pa.field("capture_seq", pa.int64()),
+    pa.field("continuity_id", pa.string()),
+]
+
+
+TRADE_SCHEMA = pa.schema(
+    [
+        *_COMMON_EVENT_FIELDS,
+        pa.field("trade_id", pa.int64(), nullable=False),
+        pa.field("first_trade_id", pa.int64()),
+        pa.field("last_trade_id", pa.int64()),
+        pa.field("price_ticks", pa.int64(), nullable=False),
+        pa.field("quantity_lots", pa.int64(), nullable=False),
+        pa.field("tick_size", pa.float64(), nullable=False),
+        pa.field("lot_size", pa.float64(), nullable=False),
+        pa.field("price", pa.float64(), nullable=False),
+        pa.field("quantity", pa.float64(), nullable=False),
+        pa.field("quote_quantity", pa.float64(), nullable=False),
+        pa.field("aggressor_side", pa.string(), nullable=False),
+        pa.field("buyer_is_maker", pa.bool_(), nullable=False),
+        pa.field("source_artifact_id", pa.string(), nullable=False),
+    ],
+    metadata=_metadata("trades"),
+)
+
+
+BOOK_OBSERVATION_SCHEMA = pa.schema(
+    [
+        *_COMMON_EVENT_FIELDS,
+        pa.field("sequence_start", pa.int64(), nullable=False),
+        pa.field("sequence_end", pa.int64(), nullable=False),
+        pa.field("is_valid", pa.bool_(), nullable=False),
+        pa.field("best_bid_ticks", pa.int64(), nullable=False),
+        pa.field("best_ask_ticks", pa.int64(), nullable=False),
+        pa.field("bid_quantity_lots", pa.int64(), nullable=False),
+        pa.field("ask_quantity_lots", pa.int64(), nullable=False),
+        pa.field("tick_size", pa.float64(), nullable=False),
+        pa.field("lot_size", pa.float64(), nullable=False),
+        pa.field("best_bid", pa.float64(), nullable=False),
+        pa.field("best_ask", pa.float64(), nullable=False),
+        pa.field("bid_quantity", pa.float64(), nullable=False),
+        pa.field("ask_quantity", pa.float64(), nullable=False),
+        pa.field("spread", pa.float64(), nullable=False),
+        pa.field("mid_price", pa.float64(), nullable=False),
+        pa.field("microprice", pa.float64(), nullable=False),
+        pa.field("depth_bid_1", pa.float64(), nullable=False),
+        pa.field("depth_ask_1", pa.float64(), nullable=False),
+        pa.field("depth_bid_5", pa.float64(), nullable=False),
+        pa.field("depth_ask_5", pa.float64(), nullable=False),
+        pa.field("depth_bid_10", pa.float64(), nullable=False),
+        pa.field("depth_ask_10", pa.float64(), nullable=False),
+        pa.field("queue_imbalance_1", pa.float64(), nullable=False),
+        pa.field("queue_imbalance_5", pa.float64(), nullable=False),
+        pa.field("queue_imbalance_10", pa.float64(), nullable=False),
+        pa.field("source_artifact_id", pa.string(), nullable=False),
+    ],
+    metadata=_metadata("book_observations"),
+)
+
+
+LEVEL_TYPE = pa.struct(
+    [
+        pa.field("price_ticks", pa.int64(), nullable=False),
+        pa.field("quantity_lots", pa.int64(), nullable=False),
+    ]
+)
+
+
+DEPTH_DELTA_SCHEMA = pa.schema(
+    [
+        *_COMMON_EVENT_FIELDS,
+        pa.field("first_update_id", pa.int64(), nullable=False),
+        pa.field("last_update_id", pa.int64(), nullable=False),
+        pa.field("previous_update_id", pa.int64()),
+        pa.field("bids", pa.list_(LEVEL_TYPE), nullable=False),
+        pa.field("asks", pa.list_(LEVEL_TYPE), nullable=False),
+        pa.field("tick_size", pa.float64(), nullable=False),
+        pa.field("lot_size", pa.float64(), nullable=False),
+        pa.field("source_artifact_id", pa.string(), nullable=False),
+    ],
+    metadata=_metadata("depth_deltas"),
+)
+
+
+BOOK_SNAPSHOT_SCHEMA = pa.schema(
+    [
+        pa.field("schema_version", pa.string(), nullable=False),
+        pa.field("venue", pa.string(), nullable=False),
+        pa.field("symbol", pa.string(), nullable=False),
+        pa.field("snapshot_id", pa.string(), nullable=False),
+        pa.field("request_ts_ns", pa.int64(), nullable=False),
+        pa.field("received_ts_ns", pa.int64(), nullable=False),
+        pa.field("available_ts_ns", pa.int64(), nullable=False),
+        pa.field("continuity_id", pa.string(), nullable=False),
+        pa.field("last_update_id", pa.int64(), nullable=False),
+        pa.field("depth_limit", pa.int32(), nullable=False),
+        pa.field("bids", pa.list_(LEVEL_TYPE), nullable=False),
+        pa.field("asks", pa.list_(LEVEL_TYPE), nullable=False),
+        pa.field("tick_size", pa.float64(), nullable=False),
+        pa.field("lot_size", pa.float64(), nullable=False),
+        pa.field("source_artifact_id", pa.string(), nullable=False),
+    ],
+    metadata=_metadata("book_snapshots"),
+)
+
+
+SEQUENCE_GAP_SCHEMA = pa.schema(
+    [
+        pa.field("schema_version", pa.string(), nullable=False),
+        pa.field("venue", pa.string(), nullable=False),
+        pa.field("symbol", pa.string(), nullable=False),
+        pa.field("continuity_id", pa.string(), nullable=False),
+        pa.field("expected_sequence", pa.int64(), nullable=False),
+        pa.field("observed_sequence_start", pa.int64(), nullable=False),
+        pa.field("observed_sequence_end", pa.int64(), nullable=False),
+        pa.field("missing_start", pa.int64(), nullable=False),
+        pa.field("missing_end", pa.int64(), nullable=False),
+        pa.field("detected_ts_ns", pa.int64(), nullable=False),
+        pa.field("reason", pa.string(), nullable=False),
+        pa.field("source_artifact_id", pa.string(), nullable=False),
+    ],
+    metadata=_metadata("sequence_gaps"),
+)
+
+
+SCHEMAS: Mapping[str, pa.Schema] = {
+    "trades": TRADE_SCHEMA,
+    "book_observations": BOOK_OBSERVATION_SCHEMA,
+    "depth_deltas": DEPTH_DELTA_SCHEMA,
+    "book_snapshots": BOOK_SNAPSHOT_SCHEMA,
+    "sequence_gaps": SEQUENCE_GAP_SCHEMA,
+}
+
+
+def get_schema(name: str, version: str = SCHEMA_VERSION) -> pa.Schema:
+    """Return a schema by stable name and fail closed on unknown versions."""
+    if version != SCHEMA_VERSION:
+        raise SchemaError(f"unsupported schema version {version!r}; expected {SCHEMA_VERSION!r}")
+    try:
+        return SCHEMAS[name]
+    except KeyError as exc:
+        raise SchemaError(f"unknown normalized schema: {name!r}") from exc
+
+
+def table_from_records(name: str, records: Iterable[Mapping[str, Any]]) -> pa.Table:
+    """Construct a table using the registry rather than inferred Arrow types."""
+    schema = get_schema(name)
+    try:
+        return pa.Table.from_pylist(list(records), schema=schema)
+    except (pa.ArrowException, TypeError, ValueError) as exc:
+        raise SchemaError(f"records do not conform to {name} {SCHEMA_VERSION}: {exc}") from exc
+
+
+def ensure_schema(table: pa.Table | pa.RecordBatch, name: str) -> None:
+    """Require exact field order/types/nullability; metadata may be absent on batches."""
+    expected = get_schema(name)
+    actual = table.schema
+    if not actual.equals(expected, check_metadata=False):
+        raise SchemaError(f"schema mismatch for {name}: expected {expected}, got {actual}")
+    metadata = actual.metadata or {}
+    declared_name = metadata.get(b"schema_name")
+    declared_version = metadata.get(b"schema_version")
+    if declared_name is not None and declared_name != name.encode():
+        raise SchemaError(
+            f"schema metadata name mismatch: expected {name!r}, got {declared_name.decode()}"
+        )
+    if declared_version is not None and declared_version != SCHEMA_VERSION.encode():
+        raise SchemaError(
+            "schema metadata version mismatch: "
+            f"expected {SCHEMA_VERSION!r}, got {declared_version.decode()}"
+        )
+    version_column = table.column(actual.get_field_index("schema_version"))
+    observed_versions = set(version_column.to_pylist())
+    if observed_versions.difference({SCHEMA_VERSION}):
+        raise SchemaError(
+            f"row schema_version mismatch: expected only {SCHEMA_VERSION!r}, "
+            f"got {sorted(observed_versions)!r}"
+        )

Microstructure/src/microstructure/data/storage.py

@@ -0,0 +1,605 @@
+"""Streaming, content-addressed Parquet storage and immutable data manifests."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import tempfile
+from collections import defaultdict
+from collections.abc import Iterable, Mapping, Sequence
+from contextlib import nullcontext, suppress
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import pyarrow as pa  # type: ignore[import-untyped]
+import pyarrow.compute as pc  # type: ignore[import-untyped]
+import pyarrow.parquet as pq  # type: ignore[import-untyped]
+
+from microstructure.data.evidence_budget import RetainedEvidenceBudget
+from microstructure.data.schemas import SCHEMA_VERSION, ensure_schema, get_schema
+from microstructure.provenance import read_json, sha256_file, utc_now_iso, write_json
+
+MANIFEST_VERSION = "1.0.0"
+_SAFE_COMPONENT = re.compile(r"^[A-Za-z0-9_.-]+$")
+_NS_PER_SECOND = 1_000_000_000
+
+
+class StorageError(RuntimeError):
+    """Raised for an unsafe path or inconsistent immutable artifact."""
+
+
+@dataclass(frozen=True, slots=True)
+class PartitionArtifact:
+    dataset: str
+    venue: str
+    symbol: str
+    partition_date: str
+    rows: int
+    write_ordinal: int
+    observed_start_ns: int
+    observed_end_inclusive_ns: int
+    data_path: Path
+    manifest_path: Path
+    data_sha256: str
+    manifest_sha256: str
+
+
+@dataclass(frozen=True, slots=True)
+class DatasetWriteResult:
+    dataset: str
+    schema_version: str
+    rows: int
+    artifacts: tuple[PartitionArtifact, ...]
+    manifest_path: Path
+    manifest_sha256: str
+
+
+@dataclass(frozen=True, slots=True)
+class CaptureDatasetWriteResult:
+    """Constant-descriptor result for one bounded-memory live capture."""
+
+    dataset: str
+    schema_version: str
+    rows: int
+    data_path: Path | None
+    data_sha256: str | None
+    manifest_path: Path
+    manifest_sha256: str
+
+
+def _safe(value: str, label: str) -> str:
+    if not value or _SAFE_COMPONENT.fullmatch(value) is None:
+        raise StorageError(f"unsafe {label} path component: {value!r}")
+    return value
+
+
+def _stable_sha(payload: Mapping[str, Any]) -> str:
+    encoded = json.dumps(payload, sort_keys=True, separators=(",", ":"), allow_nan=False)
+    return hashlib.sha256(encoded.encode()).hexdigest()
+
+
+def _partition_date(timestamp_ns: int) -> str:
+    seconds = timestamp_ns // _NS_PER_SECOND
+    return datetime.fromtimestamp(seconds, tz=UTC).date().isoformat()
+
+
+def _immutable_json(
+    directory: Path,
+    stem: str,
+    payload: Mapping[str, Any],
+    *,
+    retained_evidence_budget: RetainedEvidenceBudget | None = None,
+) -> tuple[Path, str]:
+    identity = _stable_sha(payload)
+    destination = directory / f"{stem}-{identity[:20]}.json"
+    if retained_evidence_budget is not None:
+        retained_evidence_budget.assert_contains(destination)
+    transaction = (
+        retained_evidence_budget.write_transaction()
+        if retained_evidence_budget is not None
+        else nullcontext()
+    )
+    with transaction:
+        if destination.exists():
+            existing = read_json(destination)
+            if existing != dict(payload):
+                raise StorageError(f"immutable manifest collision at {destination}")
+        else:
+            encoded = (
+                json.dumps(payload, indent=2, sort_keys=True, allow_nan=False) + "\n"
+            ).encode()
+            reservation = (
+                retained_evidence_budget.reserve(
+                    len(encoded),
+                    label=f"raw source manifest {destination.name}",
+                )
+                if retained_evidence_budget is not None
+                else None
+            )
+            try:
+                write_json(destination, payload)
+                if destination.stat().st_size != len(encoded):
+                    raise StorageError(
+                        f"source manifest byte count changed while writing {destination}"
+                    )
+                if reservation is not None:
+                    reservation.commit()
+            except BaseException:
+                destination.unlink(missing_ok=True)
+                if reservation is not None and reservation.active:
+                    reservation.release()
+                raise
+        return destination, sha256_file(destination)
+
+
+def write_source_manifest(
+    raw_path: str | Path,
+    *,
+    source: str,
+    source_uri: str,
+    downloaded_at_utc: str,
+    requested_start_ns: int | None,
+    requested_end_ns: int | None,
+    upstream_checksum_sha256: str | None = None,
+    response_headers: Mapping[str, str] | None = None,
+    retained_evidence_budget: RetainedEvidenceBudget | None = None,
+) -> tuple[Path, str]:
+    """Write an immutable sidecar for an untouched raw response or archive."""
+    path = Path(raw_path)
+    if not path.is_file():
+        raise StorageError(f"raw artifact does not exist: {path}")
+    checksum = sha256_file(path)
+    payload: dict[str, Any] = {
+        "manifest_version": MANIFEST_VERSION,
+        "artifact_kind": "raw_source",
+        "source": source,
+        "source_uri": source_uri,
+        "downloaded_at_utc": downloaded_at_utc,
+        "requested_range_ns": {"start": requested_start_ns, "end_exclusive": requested_end_ns},
+        "checksum": {"algorithm": "sha256", "value": checksum},
+        "upstream_checksum_sha256": upstream_checksum_sha256,
+        "bytes": path.stat().st_size,
+        "path": path.name,
+        "response_headers": dict(sorted((response_headers or {}).items())),
+    }
+    manifest_path, manifest_sha = _immutable_json(
+        path.parent,
+        f"{path.name}.manifest",
+        payload,
+        retained_evidence_budget=retained_evidence_budget,
+    )
+    return manifest_path, manifest_sha
+
+
+def _write_parquet_part(
+    *,
+    table: pa.Table,
+    root: Path,
+    dataset: str,
+    schema_name: str,
+    venue: str,
+    symbol: str,
+    date: str,
+    source: str,
+    source_uri: str,
+    downloaded_at_utc: str,
+    source_checksum_sha256: str | None,
+    requested_start_ns: int | None,
+    requested_end_ns: int | None,
+    time_column: str,
+    compression: str,
+    write_ordinal: int,
+) -> PartitionArtifact:
+    partition = (
+        root
+        / _safe(dataset, "dataset")
+        / f"schema-{_safe(SCHEMA_VERSION, 'schema version')}"
+        / f"venue-{_safe(venue, 'venue')}"
+        / f"symbol-{_safe(symbol, 'symbol')}"
+        / f"date-{_safe(date, 'date')}"
+    )
+    partition.mkdir(parents=True, exist_ok=True)
+    handle, temporary_name = tempfile.mkstemp(dir=partition, prefix=".part-", suffix=".parquet.tmp")
+    os.close(handle)
+    temporary = Path(temporary_name)
+    try:
+        table = table.replace_schema_metadata(get_schema(schema_name).metadata)
+        pq.write_table(
+            table,
+            temporary,
+            compression=compression,
+            use_dictionary=True,
+            write_statistics=True,
+        )
+        checksum = sha256_file(temporary)
+        destination = partition / f"part-{checksum[:20]}.parquet"
+        if destination.exists():
+            if sha256_file(destination) != checksum:
+                raise StorageError(f"content-address collision at {destination}")
+            temporary.unlink()
+        else:
+            os.replace(temporary, destination)
+    except BaseException:
+        temporary.unlink(missing_ok=True)
+        raise
+
+    time_bounds = pc.min_max(table.column(time_column)).as_py()
+    if time_bounds is None or time_bounds["min"] is None or time_bounds["max"] is None:
+        raise StorageError("cannot manifest a Parquet part without a timestamp range")
+    manifest_payload: dict[str, Any] = {
+        "manifest_version": MANIFEST_VERSION,
+        "artifact_kind": "normalized_parquet",
+        "dataset": dataset,
+        "schema_name": schema_name,
+        "schema_version": SCHEMA_VERSION,
+        "venue": venue,
+        "symbol": symbol,
+        "partition_date": date,
+        "write_ordinal": write_ordinal,
+        "source": source,
+        "source_uri": source_uri,
+        "downloaded_at_utc": downloaded_at_utc,
+        "requested_range_ns": {"start": requested_start_ns, "end_exclusive": requested_end_ns},
+        "observed_range_ns": {
+            "start": int(time_bounds["min"]),
+            "end_inclusive": int(time_bounds["max"]),
+        },
+        "source_checksum_sha256": source_checksum_sha256,
+        "checksum": {"algorithm": "sha256", "value": checksum},
+        "rows": table.num_rows,
+        "bytes": destination.stat().st_size,
+        "path": str(destination.relative_to(root)),
+        "transformations": [
+            "normalized field names and types",
+            "UTC epoch-nanosecond timestamp conversion",
+            "exact integer tick/lot conversion where scale supplied",
+        ],
+    }
+    manifest_path, manifest_sha = _immutable_json(
+        partition, f"part-{checksum[:20]}.manifest", manifest_payload
+    )
+    return PartitionArtifact(
+        dataset=dataset,
+        venue=venue,
+        symbol=symbol,
+        partition_date=date,
+        rows=table.num_rows,
+        write_ordinal=write_ordinal,
+        observed_start_ns=int(time_bounds["min"]),
+        observed_end_inclusive_ns=int(time_bounds["max"]),
+        data_path=destination,
+        manifest_path=manifest_path,
+        data_sha256=checksum,
+        manifest_sha256=manifest_sha,
+    )
+
+
+def _as_table(batch: pa.RecordBatch | pa.Table) -> pa.Table:
+    return batch if isinstance(batch, pa.Table) else pa.Table.from_batches([batch])
+
+
+def write_partitioned_parquet(
+    batches: Iterable[pa.RecordBatch | pa.Table],
+    *,
+    root: str | Path,
+    dataset: str,
+    schema_name: str,
+    source: str,
+    source_uri: str = "synthetic://local",
+    downloaded_at_utc: str | None = None,
+    source_checksum_sha256: str | None = None,
+    requested_start_ns: int | None = None,
+    requested_end_ns: int | None = None,
+    time_column: str = "event_ts_ns",
+    max_rows_per_file: int = 250_000,
+    max_input_batch_rows: int = 250_000,
+    compression: str = "zstd",
+) -> DatasetWriteResult:
+    """Stream batches into immutable Parquet parts partitioned by venue/symbol/day.
+
+    Each input batch is split only within that bounded batch, so this function
+    never requires the complete data set in memory.  Existing content-addressed
+    parts are reused rather than overwritten.
+    """
+    if max_rows_per_file < 1:
+        raise ValueError("max_rows_per_file must be positive")
+    if max_input_batch_rows < 1:
+        raise ValueError("max_input_batch_rows must be positive")
+    destination_root = Path(root)
+    destination_root.mkdir(parents=True, exist_ok=True)
+    download_time = downloaded_at_utc or utc_now_iso()
+    artifacts: list[PartitionArtifact] = []
+
+    for raw_batch in batches:
+        table = _as_table(raw_batch)
+        if table.num_rows > max_input_batch_rows:
+            raise StorageError(
+                f"input batch has {table.num_rows} rows, above the bounded-memory limit "
+                f"{max_input_batch_rows}"
+            )
+        ensure_schema(table, schema_name)
+        if time_column not in table.column_names:
+            raise StorageError(f"partition time column is missing: {time_column}")
+        groups: dict[tuple[str, str, str], list[int]] = defaultdict(list)
+        venues = table.column("venue").to_pylist()
+        symbols = table.column("symbol").to_pylist()
+        timestamps = table.column(time_column).to_pylist()
+        for row_index, (venue, symbol, timestamp_ns) in enumerate(
+            zip(venues, symbols, timestamps, strict=True)
+        ):
+            groups[(str(venue), str(symbol), _partition_date(int(timestamp_ns)))].append(row_index)
+
+        for (venue, symbol, date), indices in groups.items():
+            for offset in range(0, len(indices), max_rows_per_file):
+                selected = indices[offset : offset + max_rows_per_file]
+                part = table.take(pa.array(selected, type=pa.int64()))
+                artifacts.append(
+                    _write_parquet_part(
+                        table=part,
+                        root=destination_root,
+                        dataset=dataset,
+                        schema_name=schema_name,
+                        venue=venue,
+                        symbol=symbol,
+                        date=date,
+                        source=source,
+                        source_uri=source_uri,
+                        downloaded_at_utc=download_time,
+                        source_checksum_sha256=source_checksum_sha256,
+                        requested_start_ns=requested_start_ns,
+                        requested_end_ns=requested_end_ns,
+                        time_column=time_column,
+                        compression=compression,
+                        write_ordinal=len(artifacts),
+                    )
+                )
+
+    artifact_entries = [
+        {
+            "data_path": str(item.data_path.relative_to(destination_root)),
+            "manifest_path": str(item.manifest_path.relative_to(destination_root)),
+            "data_sha256": item.data_sha256,
+            "manifest_sha256": item.manifest_sha256,
+            "rows": item.rows,
+            "write_ordinal": item.write_ordinal,
+            "observed_range_ns": {
+                "start": item.observed_start_ns,
+                "end_inclusive": item.observed_end_inclusive_ns,
+            },
+        }
+        for item in artifacts
+    ]
+    stable_identity: dict[str, Any] = {
+        "manifest_version": MANIFEST_VERSION,
+        "dataset": dataset,
+        "schema_version": SCHEMA_VERSION,
+        "source": source,
+        "source_uri": source_uri,
+        "downloaded_at_utc": download_time,
+        "requested_range_ns": {"start": requested_start_ns, "end_exclusive": requested_end_ns},
+        "artifacts": artifact_entries,
+        "rows": sum(item.rows for item in artifacts),
+    }
+    manifest_directory = destination_root / "_manifests"
+    manifest_directory.mkdir(parents=True, exist_ok=True)
+    manifest_path, manifest_sha = _immutable_json(
+        manifest_directory, f"{_safe(dataset, 'dataset')}.manifest", stable_identity
+    )
+    return DatasetWriteResult(
+        dataset=dataset,
+        schema_version=SCHEMA_VERSION,
+        rows=sum(item.rows for item in artifacts),
+        artifacts=tuple(artifacts),
+        manifest_path=manifest_path,
+        manifest_sha256=manifest_sha,
+    )
+
+
+def write_capture_parquet(
+    batches: Iterable[pa.RecordBatch | pa.Table],
+    *,
+    root: str | Path,
+    dataset: str,
+    schema_name: str,
+    venue: str,
+    symbol: str,
+    capture_id: str,
+    source: str,
+    source_uri: str,
+    downloaded_at_utc: str | None = None,
+    source_checksum_sha256: str | None = None,
+    requested_start_ns: int | None = None,
+    requested_end_ns: int | None = None,
+    time_column: str = "event_ts_ns",
+    max_input_batch_rows: int = 16_384,
+    compression: str = "zstd",
+) -> CaptureDatasetWriteResult:
+    """Write one live-capture Parquet artifact from a bounded batch iterator.
+
+    The Parquet writer emits one bounded row group per input batch and retains
+    exactly one output descriptor, independent of capture length.  Live capture
+    data is partitioned by immutable ``capture_id`` rather than UTC day because
+    capture-order quality evidence must not be reordered to satisfy a partition.
+    """
+    if max_input_batch_rows < 1:
+        raise ValueError("max_input_batch_rows must be positive")
+    safe_dataset = _safe(dataset, "dataset")
+    safe_schema = _safe(SCHEMA_VERSION, "schema version")
+    safe_venue = _safe(venue, "venue")
+    safe_symbol = _safe(symbol, "symbol")
+    safe_capture_id = _safe(capture_id, "capture ID")
+    schema = get_schema(schema_name)
+    if time_column not in schema.names:
+        raise StorageError(f"partition time column is missing: {time_column}")
+
+    destination_root = Path(root)
+    partition = (
+        destination_root
+        / safe_dataset
+        / f"schema-{safe_schema}"
+        / f"venue-{safe_venue}"
+        / f"symbol-{safe_symbol}"
+        / f"capture-{safe_capture_id}"
+    )
+    partition.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary_name = tempfile.mkstemp(
+        dir=partition,
+        prefix=".capture-",
+        suffix=".parquet.tmp",
+    )
+    os.close(descriptor)
+    temporary = Path(temporary_name)
+    writer: pq.ParquetWriter | None = None
+    rows = 0
+    observed_start_ns: int | None = None
+    observed_end_ns: int | None = None
+    destination: Path | None = None
+    checksum: str | None = None
+    try:
+        writer = pq.ParquetWriter(
+            temporary,
+            schema,
+            compression=compression,
+            use_dictionary=True,
+            write_statistics=True,
+        )
+        for raw_batch in batches:
+            table = _as_table(raw_batch)
+            if table.num_rows > max_input_batch_rows:
+                raise StorageError(
+                    f"input batch has {table.num_rows} rows, above the bounded-memory "
+                    f"limit {max_input_batch_rows}"
+                )
+            ensure_schema(table, schema_name)
+            if table.num_rows == 0:
+                continue
+            if set(table.column("venue").to_pylist()) != {venue}:
+                raise StorageError("live capture batch contains an unexpected venue")
+            if set(table.column("symbol").to_pylist()) != {symbol}:
+                raise StorageError("live capture batch contains an unexpected symbol")
+            bounds = pc.min_max(table.column(time_column)).as_py()
+            if bounds is None or bounds["min"] is None or bounds["max"] is None:
+                raise StorageError("cannot write a live capture batch without timestamps")
+            batch_start = int(bounds["min"])
+            batch_end = int(bounds["max"])
+            observed_start_ns = (
+                batch_start if observed_start_ns is None else min(observed_start_ns, batch_start)
+            )
+            observed_end_ns = (
+                batch_end if observed_end_ns is None else max(observed_end_ns, batch_end)
+            )
+            writer.write_table(table, row_group_size=max_input_batch_rows)
+            rows += table.num_rows
+        writer.close()
+        writer = None
+        if rows == 0:
+            temporary.unlink()
+        else:
+            with temporary.open("rb") as handle:
+                os.fsync(handle.fileno())
+            checksum = sha256_file(temporary)
+            destination = partition / f"capture-{checksum[:20]}.parquet"
+            if destination.exists():
+                if sha256_file(destination) != checksum:
+                    raise StorageError(f"content-address collision at {destination}")
+                temporary.unlink()
+            else:
+                os.replace(temporary, destination)
+    except BaseException:
+        if writer is not None:
+            with suppress(BaseException):
+                writer.close()
+        temporary.unlink(missing_ok=True)
+        raise
+
+    download_time = downloaded_at_utc or utc_now_iso()
+    data_path = destination
+    data_sha256 = checksum
+    artifact_entry: dict[str, Any] | None = None
+    if data_path is not None and data_sha256 is not None:
+        artifact_payload: dict[str, Any] = {
+            "manifest_version": MANIFEST_VERSION,
+            "artifact_kind": "normalized_live_capture_parquet",
+            "dataset": dataset,
+            "schema_name": schema_name,
+            "schema_version": SCHEMA_VERSION,
+            "venue": venue,
+            "symbol": symbol,
+            "capture_id": capture_id,
+            "source": source,
+            "source_uri": source_uri,
+            "downloaded_at_utc": download_time,
+            "requested_range_ns": {
+                "start": requested_start_ns,
+                "end_exclusive": requested_end_ns,
+            },
+            "observed_range_ns": {
+                "start": observed_start_ns,
+                "end_inclusive": observed_end_ns,
+            },
+            "source_checksum_sha256": source_checksum_sha256,
+            "checksum": {"algorithm": "sha256", "value": data_sha256},
+            "rows": rows,
+            "bytes": data_path.stat().st_size,
+            "path": str(data_path.relative_to(destination_root)),
+            "transformations": [
+                "normalized field names and types",
+                "UTC epoch-nanosecond timestamp conversion",
+                "exact integer tick/lot conversion where scale supplied",
+            ],
+        }
+        artifact_manifest_path, artifact_manifest_sha = _immutable_json(
+            partition,
+            f"capture-{data_sha256[:20]}.manifest",
+            artifact_payload,
+        )
+        artifact_entry = {
+            "data_path": str(data_path.relative_to(destination_root)),
+            "manifest_path": str(artifact_manifest_path.relative_to(destination_root)),
+            "data_sha256": data_sha256,
+            "manifest_sha256": artifact_manifest_sha,
+            "rows": rows,
+            "write_ordinal": 0,
+            "observed_range_ns": artifact_payload["observed_range_ns"],
+        }
+
+    dataset_payload: dict[str, Any] = {
+        "manifest_version": MANIFEST_VERSION,
+        "dataset": dataset,
+        "schema_version": SCHEMA_VERSION,
+        "source": source,
+        "source_uri": source_uri,
+        "downloaded_at_utc": download_time,
+        "requested_range_ns": {
+            "start": requested_start_ns,
+            "end_exclusive": requested_end_ns,
+        },
+        "partitioning": {"kind": "capture_id", "value": capture_id},
+        "artifacts": [artifact_entry] if artifact_entry is not None else [],
+        "rows": rows,
+    }
+    manifest_directory = destination_root / "_manifests"
+    manifest_directory.mkdir(parents=True, exist_ok=True)
+    manifest_path, manifest_sha = _immutable_json(
+        manifest_directory,
+        f"{safe_dataset}.capture-{safe_capture_id}.manifest",
+        dataset_payload,
+    )
+    return CaptureDatasetWriteResult(
+        dataset=dataset,
+        schema_version=SCHEMA_VERSION,
+        rows=rows,
+        data_path=data_path,
+        data_sha256=data_sha256,
+        manifest_path=manifest_path,
+        manifest_sha256=manifest_sha,
+    )
+
+
+def parquet_paths(result: DatasetWriteResult) -> Sequence[Path]:
+    """Return concrete parts in manifest order for Polars/DuckDB consumers."""
+    return tuple(item.data_path for item in result.artifacts)