Datasets:

ShawnChamberlain
/

open-economic-quant-research-data

	"""One explicit four-day public aggregate-trade exploratory study.

	This producer is deliberately separate from the frozen M8 trade and live-L2
	authorities. It reuses their bounded archive, normalization, causal-feature,
	and numeric fitted-state primitives without weakening either frozen contract.
	"""

	from __future__ import annotations

	import argparse
	import hashlib
	import json
	import os
	import shutil
	import tempfile
	import tomllib
	from collections.abc import Mapping, Sequence
	from dataclasses import asdict
	from datetime import date
	from pathlib import Path
	from typing import Any, cast

	import polars as pl

	from microstructure.config import FeatureConfig, ModelConfig
	from microstructure.data.binance import BinancePublicClient, SymbolMetadata
	from microstructure.data.binance_archive import (
	AcquiredDailyArchive,
	ArchiveDownloadLimits,
	BinanceArchiveClient,
	DailyArchiveRequest,
	)
	from microstructure.data.evidence_budget import RetainedEvidenceBudget
	from microstructure.m8_config import (
	M8Claims,
	M8Features,
	M8Models,
	M8Period,
	M8Quality,
	M8Study,
	M8StudyConfig,
	)
	from microstructure.m8_manifest import M8ArchiveEntry, M8SymbolMetadata
	from microstructure.m8_normalization import normalize_m8_archive
	from microstructure.provenance import (
	git_source_tree_sha256,
	read_json,
	sha256_file,
	strict_git_state,
	utc_now_iso,
	)
	from microstructure.research.multidate import (
	AnalysisLock,
	LockedSelection,
	evaluate_locked_multidate_tests,
	select_multidate_model,
	)
	from microstructure.research.trade_only import (
	build_trade_only_research_frame,
	validate_trade_only_temporal_contract,
	)

	SCHEMA_VERSION = "exploratory-aggtrades-study-v1"
	EVIDENCE_TIER = "PUBLIC_ARCHIVE_EXPLORATORY"
	EXPECTED_DATES = (
	("2026-08-05", "train"),
	("2026-08-06", "validation"),
	("2026-08-07", "primary_test"),
	("2026-08-08", "replication_test"),
	)
	EXPECTED_SYMBOLS = ("BTCUSDT", "ETHUSDT")
	PROTOCOL_RELATIVE_PATH = "docs/EXPLORATORY_AGGTRADES_2026_08_05_08.md"
	SUCCESS_BYTES = b"complete\n"


	class ExploratoryStudyError(RuntimeError):
	"""Raised when the exploratory producer cannot preserve its authority."""


	def _canonical_bytes(value: object) -> bytes:
	return json.dumps(
	value,
	sort_keys=True,
	separators=(",", ":"),
	allow_nan=False,
	).encode("utf-8")


	def _sha_bytes(value: bytes) -> str:
	return hashlib.sha256(value).hexdigest()


	def _atomic_write(path: Path, content: bytes) -> None:
	path.parent.mkdir(parents=True, exist_ok=True)
	descriptor, raw_temporary = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
	temporary = Path(raw_temporary)
	try:
	with os.fdopen(descriptor, "wb") as handle:
	handle.write(content)
	handle.flush()
	os.fsync(handle.fileno())
	os.replace(temporary, path)
	parent = os.open(path.parent, os.O_RDONLY)
	try:
	os.fsync(parent)
	finally:
	os.close(parent)
	finally:
	temporary.unlink(missing_ok=True)


	def _write_json(path: Path, value: object) -> None:
	_atomic_write(path, _canonical_bytes(value) + b"\n")


	def _mapping(value: object, label: str) -> Mapping[str, Any]:
	if not isinstance(value, Mapping) or not all(isinstance(key, str) for key in value):
	raise ExploratoryStudyError(f"{label} must be a string-keyed table")
	return cast(Mapping[str, Any], value)


	def _exact_keys(value: Mapping[str, Any], expected: set[str], label: str) -> None:
	if set(value) != expected:
	raise ExploratoryStudyError(f"{label} keys differ from the exploratory contract")


	def _load_config(path: Path) -> M8StudyConfig:
	source_path = path.resolve()
	source = source_path.read_bytes()
	try:
	payload = tomllib.loads(source.decode("utf-8"))
	except (UnicodeDecodeError, tomllib.TOMLDecodeError) as error:
	raise ExploratoryStudyError("cannot parse exploratory configuration") from error
	root = _mapping(payload, "configuration")
	_exact_keys(root, {"study", "periods", "features", "models", "quality", "claims"}, "config")
	study_raw = _mapping(root["study"], "study")
	periods_raw = root["periods"]
	features_raw = _mapping(root["features"], "features")
	models_raw = _mapping(root["models"], "models")
	quality_raw = _mapping(root["quality"], "quality")
	claims_raw = _mapping(root["claims"], "claims")
	if not isinstance(periods_raw, list) or len(periods_raw) != 4:
	raise ExploratoryStudyError("periods must declare exactly four dates")

	study = M8Study(
	name=str(study_raw["name"]),
	protocol_version=str(study_raw["protocol_version"]),
	evidence_tier=str(study_raw["evidence_tier"]),
	seed=int(study_raw["seed"]),
	source=str(study_raw["source"]),
	symbols=tuple(str(value) for value in cast(Sequence[object], study_raw["symbols"])),
	selection_metric=str(study_raw["selection_metric"]),
	target=str(study_raw["target"]),
	label_horizon_events=int(study_raw["label_horizon_events"]),
	calibration_fraction=float(study_raw["calibration_fraction"]),
	bootstrap_samples=int(study_raw["bootstrap_samples"]),
	bootstrap_block_events=int(study_raw["bootstrap_block_events"]),
	feature_stability_bins=int(study_raw["feature_stability_bins"]),
	max_archive_compressed_bytes=int(study_raw["max_archive_compressed_bytes"]),
	max_archive_uncompressed_bytes=int(study_raw["max_archive_uncompressed_bytes"]),
	max_total_download_bytes=int(study_raw["max_total_download_bytes"]),
	)
	periods = tuple(
	M8Period(
	date=date.fromisoformat(str(_mapping(value, "period")["date"])),
	role=cast(Any, str(_mapping(value, "period")["role"])),
	)
	for value in periods_raw
	)
	features = M8Features(
	trade_windows=tuple(
	int(cast(Any, value)) for value in cast(Sequence[object], features_raw["trade_windows"])
	),
	volatility_window=int(features_raw["volatility_window"]),
	intensity_window=int(features_raw["intensity_window"]),
	large_trade_quantile=float(features_raw["large_trade_quantile"]),
	)
	models = M8Models(
	logistic_c_values=tuple(
	float(cast(Any, value))
	for value in cast(Sequence[object], models_raw["logistic_c_values"])
	),
	tree_max_depth_values=tuple(
	int(cast(Any, value))
	for value in cast(Sequence[object], models_raw["tree_max_depth_values"])
	),
	tree_min_samples_leaf=int(models_raw["tree_min_samples_leaf"]),
	)
	quality = M8Quality(
	fail_on_error=bool(quality_raw["fail_on_error"]),
	require_complete_daily_archive=bool(quality_raw["require_complete_daily_archive"]),
	require_contiguous_trade_ids_within_symbol_date=bool(
	quality_raw["require_contiguous_trade_ids_within_symbol_date"]
	),
	require_nondecreasing_event_time=bool(quality_raw["require_nondecreasing_event_time"]),
	allow_quality_warnings=bool(quality_raw["allow_quality_warnings"]),
	)
	claims = M8Claims(
	allow_p_values=bool(claims_raw["allow_p_values"]),
	allow_significance_claim=bool(claims_raw["allow_significance_claim"]),
	allow_cross_instrument_pooling=bool(claims_raw["allow_cross_instrument_pooling"]),
	allow_execution_claim=bool(claims_raw["allow_execution_claim"]),
	allow_profitability_claim=bool(claims_raw["allow_profitability_claim"]),
	)
	config = M8StudyConfig(
	path=source_path,
	source_sha256=_sha_bytes(source),
	study=study,
	periods=periods,
	features=features,
	models=models,
	quality=quality,
	claims=claims,
	)
	observed_dates = tuple((item.date.isoformat(), item.role) for item in config.periods)
	if (
	config.study.name != "binance-aggtrades-2026-08-05-08-exploratory"
	or config.study.protocol_version != "1.0.0"
	or config.study.evidence_tier != EVIDENCE_TIER
	or config.study.source != "binance_spot_daily_aggtrades_archive"
	or config.study.symbols != EXPECTED_SYMBOLS
	or observed_dates != EXPECTED_DATES
	or config.study.selection_metric != "log_loss"
	or config.study.target != "future_trade_up"
	or config.study.label_horizon_events != 20
	or not config.quality.fail_on_error
	or not config.quality.allow_quality_warnings
	or any(asdict(config.claims).values())
	):
	raise ExploratoryStudyError("configuration differs from the declared exploratory study")
	if config.study.max_total_download_bytes < 1:
	raise ExploratoryStudyError("total retained-evidence budget must be positive")
	return config


	def _protocol_path(config: M8StudyConfig) -> Path:
	result = config.path.parent.parent / PROTOCOL_RELATIVE_PATH
	if not result.is_file() or result.is_symlink():
	raise ExploratoryStudyError("exploratory protocol document is missing or symbolic")
	return result


	def _metadata_authority(value: SymbolMetadata) -> M8SymbolMetadata:
	sidecar = _mapping(read_json(value.source_manifest_path), "exchangeInfo sidecar")
	source_uri = sidecar.get("source_uri")
	if type(source_uri) is not str or not source_uri:
	raise ExploratoryStudyError("exchangeInfo sidecar lacks its source URI")
	return M8SymbolMetadata(
	symbol=value.symbol,
	status=value.status,
	tick_size=value.tick_size,
	lot_size=value.lot_size,
	observed_ts_ns=value.observed_ts_ns,
	raw_path=value.source_path.resolve(),
	raw_sha256=sha256_file(value.source_path),
	raw_bytes=value.source_path.stat().st_size,
	source_uri=source_uri,
	source_manifest_path=value.source_manifest_path.resolve(),
	source_manifest_sha256=sha256_file(value.source_manifest_path),
	source_manifest_bytes=value.source_manifest_path.stat().st_size,
	)


	def _feature_config(config: M8StudyConfig) -> FeatureConfig:
	return FeatureConfig(
	trade_windows=config.features.trade_windows,
	volatility_window=config.features.volatility_window,
	intensity_window=config.features.intensity_window,
	label_horizon_events=config.study.label_horizon_events,
	large_trade_quantile=config.features.large_trade_quantile,
	)


	def _model_config(config: M8StudyConfig) -> ModelConfig:
	return ModelConfig(
	selection_metric=config.study.selection_metric,
	logistic_c_values=config.models.logistic_c_values,
	tree_max_depth_values=config.models.tree_max_depth_values,
	tree_min_samples_leaf=config.models.tree_min_samples_leaf,
	)


	def _feature_columns(config: M8StudyConfig) -> tuple[str, ...]:
	columns = ["log_trade_return_1"]
	for window in config.features.trade_windows:
	columns.extend(
	(
	f"signed_trade_volume_w{window}",
	f"trade_volume_w{window}",
	f"trade_imbalance_w{window}",
	)
	)
	columns.extend(
	(
	f"trade_count_w{config.features.intensity_window}",
	f"trade_intensity_w{config.features.intensity_window}",
	f"realized_volatility_w{config.features.volatility_window}",
	)
	)
	return tuple(dict.fromkeys(columns))


	def _evaluation_columns(config: M8StudyConfig) -> tuple[str, ...]:
	return (
	"study_date",
	"study_role",
	"symbol",
	"decision_ts_ns",
	"decision_sequence",
	"decision_trade_id",
	"continuity_id",
	"feature_continuity_id",
	"label_continuity_id",
	"max_feature_source_ts_ns",
	"max_feature_source_trade_id",
	"label_start_ts_ns",
	"label_start_trade_id",
	"label_information_end_ts_ns",
	"label_information_end_trade_id",
	"feature_ready",
	"right_censored",
	config.study.target,
	*_feature_columns(config),
	)


	def _entry_payload(entry: M8ArchiveEntry, root: Path) -> dict[str, object]:
	return {
	"symbol": entry.symbol,
	"date": entry.date.isoformat(),
	"role": entry.role,
	"rows": entry.rows,
	"first_trade_id": entry.first_trade_id,
	"last_trade_id": entry.last_trade_id,
	"observed_start_ns": entry.observed_start_ns,
	"observed_end_inclusive_ns": entry.observed_end_inclusive_ns,
	"quality_errors": entry.quality_errors,
	"quality_warnings": entry.quality_warnings,
	"raw_zip": {
	"path": str(entry.raw_zip_path.relative_to(root)),
	"sha256": entry.raw_zip_sha256,
	"bytes": entry.raw_zip_bytes,
	},
	"official_checksum": {
	"path": str(entry.raw_checksum_path.relative_to(root)),
	"sha256": entry.raw_checksum_sha256,
	"bytes": entry.raw_checksum_bytes,
	},
	"normalized_manifest": {
	"path": str(entry.normalized_dataset_manifest_path.relative_to(root)),
	"sha256": entry.normalized_dataset_manifest_sha256,
	"bytes": entry.normalized_dataset_manifest_bytes,
	},
	"parts": [
	{
	"path": str(item.data_path.relative_to(root)),
	"sha256": item.data_sha256,
	"bytes": item.data_bytes,
	"rows": item.rows,
	}
	for item in entry.normalized_parts
	],
	"quality_report": {
	"path": str(entry.quality_report_path.relative_to(root)),
	"sha256": entry.quality_report_sha256,
	"bytes": entry.quality_report_bytes,
	},
	"quality_findings": {
	"path": str(entry.quality_findings_path.relative_to(root)),
	"sha256": entry.quality_findings_sha256,
	"bytes": entry.quality_findings_bytes,
	},
	}


	def _build_evaluation_frame(
	entry: M8ArchiveEntry,
	config: M8StudyConfig,
	data_root: Path,
	) -> Path:
	paths = [item.data_path for item in entry.normalized_parts]
	frame = pl.read_parquet(paths, rechunk=False)
	research = build_trade_only_research_frame(frame, _feature_config(config)).with_columns(
	pl.lit(entry.date.isoformat()).alias("study_date"),
	pl.lit(entry.role).alias("study_role"),
	)
	validate_trade_only_temporal_contract(research)
	result = research.select(_evaluation_columns(config))
	output = data_root / "derived" / "research" / entry.symbol / entry.date.isoformat()
	output.mkdir(parents=True, exist_ok=True)
	destination = output / "evaluation.parquet"
	result.write_parquet(destination, compression="zstd", statistics=True)
	del frame, research, result
	return destination


	def _source_authority(project_root: Path) -> dict[str, object]:
	state = strict_git_state(project_root)
	if state.dirty:
	raise ExploratoryStudyError("exploratory producer requires a clean committed source")
	return {
	"commit": state.commit,
	"dirty": False,
	"source_tree_sha256": git_source_tree_sha256(project_root),
	}


	def _raw_manifest(
	config: M8StudyConfig,
	metadata: Mapping[str, M8SymbolMetadata],
	archives: Mapping[tuple[str, str], AcquiredDailyArchive],
	data_root: Path,
	) -> tuple[Path, str]:
	raw_root = data_root / "raw"
	payload = {
	"schema_version": "exploratory-aggtrades-raw-v1",
	"config_sha256": config.hash,
	"config_source_sha256": config.source_sha256,
	"protocol_sha256": sha256_file(_protocol_path(config)),
	"csv_members_opened": False,
	"metadata": [
	{
	"symbol": symbol,
	"status": item.status,
	"tick_size": str(item.tick_size),
	"lot_size": str(item.lot_size),
	"path": str(item.raw_path.relative_to(raw_root)),
	"sha256": item.raw_sha256,
	"bytes": item.raw_bytes,
	"sidecar_path": str(item.source_manifest_path.relative_to(raw_root)),
	"sidecar_sha256": item.source_manifest_sha256,
	"sidecar_bytes": item.source_manifest_bytes,
	}
	for symbol, item in sorted(metadata.items())
	],
	"archives": [
	{
	"symbol": symbol,
	"date": day,
	"role": next(item.role for item in config.periods if item.date.isoformat() == day),
	"zip_path": str(value.archive_artifact.path.relative_to(raw_root)),
	"zip_sha256": value.archive_artifact.sha256,
	"zip_bytes": value.archive_artifact.bytes,
	"zip_sidecar_path": str(value.archive_artifact.manifest_path.relative_to(raw_root)),
	"zip_sidecar_sha256": value.archive_artifact.manifest_sha256,
	"checksum_path": str(value.checksum_artifact.path.relative_to(raw_root)),
	"checksum_sha256": value.checksum_artifact.sha256,
	"checksum_bytes": value.checksum_artifact.bytes,
	"checksum_sidecar_path": str(
	value.checksum_artifact.manifest_path.relative_to(raw_root)
	),
	"checksum_sidecar_sha256": value.checksum_artifact.manifest_sha256,
	"official_zip_sha256": value.upstream_sha256,
	"declared_uncompressed_bytes": value.declared_uncompressed_bytes,
	}
	for (symbol, day), value in sorted(archives.items())
	],
	}
	destination = data_root / "raw_manifest.json"
	if destination.exists():
	raise ExploratoryStudyError("raw manifest target already exists")
	_write_json(destination, payload)
	return destination, sha256_file(destination)


	def _persist_locks(
	selections: Mapping[str, LockedSelection],
	stage: Path,
	*,
	config: M8StudyConfig,
	raw_manifest_sha256: str,
	source: Mapping[str, object],
	) -> tuple[Path, str]:
	child_claims: dict[str, dict[str, object]] = {}
	for symbol, selection in sorted(selections.items()):
	child = stage / "analysis" / "locks" / f"{symbol}.selection.json"
	_atomic_write(child, selection.lock.payload_json.encode("utf-8") + b"\n")
	child_claims[symbol] = {
	"path": str(child.relative_to(stage)),
	"sha256": sha256_file(child),
	"selection_lock_sha256": selection.lock.sha256,
	"fitted_state_sha256": selection.fitted_state.sha256,
	"selected_model": selection.selected_model,
	}
	comparison = stage / "models" / f"{symbol}.validation_candidates.parquet"
	comparison.parent.mkdir(parents=True, exist_ok=True)
	selection.validation_comparison.write_parquet(comparison, compression="zstd")
	payload = {
	"schema_version": "exploratory-aggtrades-analysis-lock-v1",
	"created_at_utc": utc_now_iso(),
	"config_sha256": config.hash,
	"config_source_sha256": config.source_sha256,
	"protocol_sha256": sha256_file(_protocol_path(config)),
	"raw_manifest_sha256": raw_manifest_sha256,
	"source": dict(source),
	"children": child_claims,
	"development_dates": ["2026-08-05", "2026-08-06"],
	"heldout_dates": ["2026-08-07", "2026-08-08"],
	"heldout_csv_members_opened_before_lock": False,
	}
	aggregate = stage / "analysis" / "analysis_lock.json"
	_write_json(aggregate, payload)
	digest = sha256_file(aggregate)
	_atomic_write(aggregate.with_suffix(".sha256"), f"{digest} {aggregate.name}\n".encode())
	return aggregate, digest


	def _lock_guard(
	*,
	aggregate_path: Path,
	aggregate_sha256: str,
	config: M8StudyConfig,
	project_root: Path,
	source: Mapping[str, object],
	) -> None:
	if sha256_file(config.path) != config.source_sha256:
	raise ExploratoryStudyError("configuration changed before held-out member open")
	if sha256_file(_protocol_path(config)) != cast(
	str, read_json(aggregate_path)["protocol_sha256"]
	):
	raise ExploratoryStudyError("protocol changed before held-out member open")
	if sha256_file(aggregate_path) != aggregate_sha256:
	raise ExploratoryStudyError("aggregate lock changed before held-out member open")
	if _source_authority(project_root) != dict(source):
	raise ExploratoryStudyError("source identity changed before held-out member open")
	aggregate = _mapping(read_json(aggregate_path), "analysis lock")
	children = _mapping(aggregate["children"], "analysis lock children")
	for claim in children.values():
	child = _mapping(claim, "child lock claim")
	path = aggregate_path.parents[1] / str(child["path"])
	if sha256_file(path) != child["sha256"]:
	raise ExploratoryStudyError("child lock changed before held-out member open")


	def _checksums(root: Path) -> tuple[Path, str]:
	paths = sorted(
	item
	for item in root.rglob("*")
	if item.is_file() and item.name not in {"CHECKSUMS.sha256", "_SUCCESS"}
	)
	lines = [f"{sha256_file(item)} {item.relative_to(root).as_posix()}" for item in paths]
	destination = root / "CHECKSUMS.sha256"
	_atomic_write(destination, ("\n".join(lines) + "\n").encode("utf-8"))
	return destination, sha256_file(destination)


	def verify_exploratory_run(run_dir: str \| Path) -> dict[str, object]:
	root = Path(run_dir).resolve()
	marker = root / "_SUCCESS"
	if marker.read_bytes() != SUCCESS_BYTES:
	raise ExploratoryStudyError("run success marker is missing or invalid")
	checksums = root / "CHECKSUMS.sha256"
	for line in checksums.read_text(encoding="utf-8").splitlines():
	digest, relative = line.split(" ", 1)
	path = root / relative
	if not path.is_file() or path.is_symlink() or sha256_file(path) != digest:
	raise ExploratoryStudyError(f"run artifact failed checksum verification: {relative}")
	evidence = _mapping(read_json(root / "data" / "input_evidence.json"), "input evidence")
	for item in cast(Sequence[object], evidence["files"]):
	claim = _mapping(item, "input evidence file")
	path = Path(str(claim["absolute_path"]))
	if path.stat().st_size != int(claim["bytes"]) or sha256_file(path) != claim["sha256"]:
	raise ExploratoryStudyError(f"external input changed: {path}")
	manifest = root / "run_manifest.json"
	return {
	"status": "COMPLETE",
	"integrity": "verified",
	"run_dir": str(root),
	"run_manifest": str(manifest),
	"run_manifest_sha256": sha256_file(manifest),
	"checksums": str(checksums),
	"checksums_sha256": sha256_file(checksums),
	}


	def run_exploratory_study(
	config_path: str \| Path,
	data_root: str \| Path,
	run_dir: str \| Path,
	) -> dict[str, object]:
	config = _load_config(Path(config_path))
	project_root = config.path.parent.parent.resolve()
	source = _source_authority(project_root)
	destination_data = Path(data_root).resolve()
	destination_run = Path(run_dir).resolve()
	if destination_run.exists():
	raise ExploratoryStudyError("run target already exists; immutable runs are not overwritten")
	if (destination_data / "derived").exists() or (destination_data / "raw_manifest.json").exists():
	raise ExploratoryStudyError("derived/input-manifest target already exists")
	destination_data.mkdir(parents=True, exist_ok=True)
	raw_root = destination_data / "raw"
	budget = RetainedEvidenceBudget(raw_root, config.study.max_total_download_bytes)
	metadata_client = BinancePublicClient(retained_evidence_budget=budget)
	archive_client = BinanceArchiveClient(retained_evidence_budget=budget)
	metadata: dict[str, M8SymbolMetadata] = {}
	raw_metadata: dict[str, SymbolMetadata] = {}
	for symbol in config.study.symbols:
	observed = metadata_client.fetch_exchange_info(symbol=symbol, raw_root=raw_root)
	raw_metadata[symbol] = observed
	metadata[symbol] = _metadata_authority(observed)
	limits = ArchiveDownloadLimits(
	max_compressed_bytes=config.study.max_archive_compressed_bytes,
	max_uncompressed_bytes=config.study.max_archive_uncompressed_bytes,
	)
	archives: dict[tuple[str, str], AcquiredDailyArchive] = {}
	for period in config.periods:
	for symbol in config.study.symbols:
	item = raw_metadata[symbol]
	archives[(symbol, period.date.isoformat())] = archive_client.acquire(
	DailyArchiveRequest(
	symbol=symbol,
	date=period.date,
	tick_size=item.tick_size,
	lot_size=item.lot_size,
	),
	raw_root=raw_root,
	limits=limits,
	)
	raw_manifest_path, raw_manifest_sha256 = _raw_manifest(
	config, metadata, archives, destination_data
	)
	if sha256_file(config.path) != config.source_sha256:
	raise ExploratoryStudyError("configuration changed during raw acquisition")

	stage = destination_run.parent / f".{destination_run.name}.staging-{os.getpid()}"
	if stage.exists():
	raise ExploratoryStudyError("run staging directory already exists")
	stage.mkdir(parents=True)
	normalized: dict[tuple[str, str], M8ArchiveEntry] = {}
	evaluation_paths: dict[tuple[str, str], Path] = {}
	selections: dict[str, LockedSelection] = {}
	try:
	development = config.periods[:2]
	heldout = config.periods[2:]
	for period in development:
	for symbol in config.study.symbols:
	normalized_result = normalize_m8_archive(
	config,
	period,
	metadata[symbol],
	archives[(symbol, period.date.isoformat())],
	raw_root,
	output_root=destination_data / "derived",
	)
	normalized[(symbol, period.date.isoformat())] = normalized_result.entry
	evaluation_paths[(symbol, period.date.isoformat())] = _build_evaluation_frame(
	normalized_result.entry, config, destination_data
	)
	for symbol_index, symbol in enumerate(config.study.symbols):
	frames = [
	pl.read_parquet(evaluation_paths[(symbol, period.date.isoformat())])
	for period in development
	]
	selections[symbol] = select_multidate_model(
	frames,
	_model_config(config),
	feature_columns=_feature_columns(config),
	declared_test_dates=[item.date.isoformat() for item in heldout],
	seed=config.study.seed + symbol_index,
	calibration_bins=config.study.feature_stability_bins,
	target=config.study.target,
	calibration_fraction=config.study.calibration_fraction,
	bootstrap_draws=config.study.bootstrap_samples,
	block_width_events=config.study.bootstrap_block_events,
	)
	del frames
	aggregate_path, aggregate_sha256 = _persist_locks(
	selections,
	stage,
	config=config,
	raw_manifest_sha256=raw_manifest_sha256,
	source=source,
	)
	for period in heldout:
	for symbol in config.study.symbols:
	normalized_result = normalize_m8_archive(
	config,
	period,
	metadata[symbol],
	archives[(symbol, period.date.isoformat())],
	raw_root,
	output_root=destination_data / "derived",
	before_member_open=lambda: _lock_guard(
	aggregate_path=aggregate_path,
	aggregate_sha256=aggregate_sha256,
	config=config,
	project_root=project_root,
	source=source,
	),
	)
	normalized[(symbol, period.date.isoformat())] = normalized_result.entry
	evaluation_paths[(symbol, period.date.isoformat())] = _build_evaluation_frame(
	normalized_result.entry, config, destination_data
	)

	summaries: dict[str, object] = {}
	for symbol in config.study.symbols:
	development_frames = [
	pl.read_parquet(evaluation_paths[(symbol, period.date.isoformat())])
	for period in development
	]
	test_frames = [
	pl.read_parquet(evaluation_paths[(symbol, period.date.isoformat())])
	for period in heldout
	]
	locked = AnalysisLock.restore(
	selections[symbol].lock.payload_json,
	selections[symbol].lock.sha256,
	)
	evaluation_result = evaluate_locked_multidate_tests(
	development_frames, test_frames, locked
	)
	model_root = stage / "models" / symbol
	metric_root = stage / "metrics" / symbol
	model_root.mkdir(parents=True, exist_ok=True)
	metric_root.mkdir(parents=True, exist_ok=True)
	evaluation_result.predictions.write_parquet(
	model_root / "selected_and_prior_predictions.parquet", compression="zstd"
	)
	evaluation_result.paired_log_loss.per_date.write_parquet(
	metric_root / "paired_log_loss_by_date.parquet", compression="zstd"
	)
	evaluation_result.feature_stability.write_parquet(
	metric_root / "feature_stability.parquet", compression="zstd"
	)
	aggregate = evaluation_result.paired_log_loss.aggregate
	summaries[symbol] = {
	"selected_model": evaluation_result.selected_model,
	"selection_lock_sha256": evaluation_result.lock_sha256,
	"replication_status": evaluation_result.paired_log_loss.replication_status,
	"equal_date_selected_minus_prior_log_loss": {
	"point_estimate": aggregate.point_estimate,
	"ci_low": aggregate.lower,
	"ci_high": aggregate.upper,
	"bootstrap_samples": aggregate.n_bootstrap,
	"blocks": aggregate.n_blocks,
	"status": aggregate.status,
	},
	"per_date": evaluation_result.paired_log_loss.per_date.to_dicts(),
	}
	del development_frames, test_frames, evaluation_result

	evidence_files: list[dict[str, object]] = []
	for path in sorted(
	item for item in destination_data.rglob("*") if item.is_file() and not item.is_symlink()
	):
	evidence_files.append(
	{
	"absolute_path": str(path),
	"sha256": sha256_file(path),
	"bytes": path.stat().st_size,
	}
	)
	_write_json(
	stage / "data" / "input_evidence.json",
	{
	"raw_manifest": str(raw_manifest_path),
	"raw_manifest_sha256": raw_manifest_sha256,
	"files": evidence_files,
	},
	)
	archive_rows = [
	_entry_payload(normalized[(symbol, period.date.isoformat())], destination_data)
	for period in config.periods
	for symbol in config.study.symbols
	]
	_write_json(stage / "metrics" / "exploratory_summary.json", summaries)
	_write_json(
	stage / "run_manifest.json",
	{
	"schema_version": SCHEMA_VERSION,
	"status": "COMPLETE",
	"evidence_tier": EVIDENCE_TIER,
	"evidence_scope": "trade_only_complete_public_daily_archives_retrospective",
	"generated_at_utc": utc_now_iso(),
	"config": config.public_dict(),
	"protocol": {
	"path": PROTOCOL_RELATIVE_PATH,
	"sha256": sha256_file(_protocol_path(config)),
	},
	"source": source,
	"raw_manifest_sha256": raw_manifest_sha256,
	"analysis_lock_sha256": aggregate_sha256,
	"archive_evidence": archive_rows,
	"symbol_results": summaries,
	"claims": {
	"p_values_computed": False,
	"significance_claim_authorized": False,
	"cross_instrument_pooling": False,
	"execution": "NOT_RUN",
	"profitability_claim_authorized": False,
	"live_l2_claim_authorized": False,
	},
	},
	)
	report_lines = [
	"# August 5-8 aggregate-trade exploratory result",
	"",
	"PUBLIC_ARCHIVE_EXPLORATORY — retrospective trade-only evidence.",
	"",
	"This result contains no L2, execution, profitability, capacity, or significance claim.",
	"",
	]
	for symbol in config.study.symbols:
	summary = cast(Mapping[str, Any], summaries[symbol])
	report_aggregate = cast(
	Mapping[str, Any], summary["equal_date_selected_minus_prior_log_loss"]
	)
	report_lines.extend(
	[
	f"## {symbol}",
	"",
	f"- Selected model: `{summary['selected_model']}`",
	f"- Equal-date selected-minus-prior log-loss delta: `{report_aggregate['point_estimate']}`",
	f"- Descriptive 95% interval: `[{report_aggregate['ci_low']}, {report_aggregate['ci_high']}]`",
	f"- Directional replication status: `{summary['replication_status']}`",
	"",
	]
	)
	_atomic_write(stage / "reports" / "technical_report.md", "\n".join(report_lines).encode())
	_checksums(stage)
	_atomic_write(stage / "_SUCCESS", SUCCESS_BYTES)
	destination_run.parent.mkdir(parents=True, exist_ok=True)
	os.rename(stage, destination_run)
	parent = os.open(destination_run.parent, os.O_RDONLY)
	try:
	os.fsync(parent)
	finally:
	os.close(parent)
	except BaseException:
	if stage.exists():
	shutil.rmtree(stage)
	raise
	return verify_exploratory_run(destination_run)


	def _parser() -> argparse.ArgumentParser:
	parser = argparse.ArgumentParser(description=__doc__)
	parser.add_argument("--config", required=True, type=Path)
	parser.add_argument("--data-root", required=True, type=Path)
	parser.add_argument("--run-dir", required=True, type=Path)
	parser.add_argument("--verify-only", action="store_true")
	return parser


	def main() -> int:
	args = _parser().parse_args()
	result = (
	verify_exploratory_run(args.run_dir)
	if args.verify_only
	else run_exploratory_study(args.config, args.data_root, args.run_dir)
	)
	print(json.dumps(result, sort_keys=True, allow_nan=False))
	return 0


	if __name__ == "__main__":
	raise SystemExit(main())