Microstructure/src/microstructure/public_pipeline.py

"""Frozen public aggregate-trade research-run producer.

This producer is deliberately narrower than the synthetic vertical slice.  It
loads one explicitly manifested, bounded public trade ingestion; proves trade-ID
and availability-clock continuity before deriving research epochs; evaluates
each instrument independently; and publishes predictive diagnostics only.  It
never invokes the execution simulator or calculates P&L.
"""

from __future__ import annotations

import hashlib
import json
import math
import os
import tempfile
from collections.abc import Mapping, Sequence
from dataclasses import asdict, dataclass
from datetime import UTC, datetime
from pathlib import Path
from typing import Any, cast

import numpy as np
import polars as pl

from microstructure.config import ProjectConfig
from microstructure.provenance import (
    provenance_header,
    read_json,
    sha256_file,
    write_json,
)
from microstructure.public_data import PublicTrades, read_public_trades
from microstructure.reporting import (
    load_run_bundle,
    render_executive_memo,
    render_model_comparison,
    render_technical_report,
    write_checksum_manifest,
)
from microstructure.research.analysis import (
    feature_stability_summary,
    ofi_future_return_association,
)
from microstructure.research.models import (
    block_bootstrap_metric,
    evaluate_model_ladder,
    paired_block_bootstrap_difference,
)
from microstructure.research.splits import WalkForwardPlan, expanding_walk_forward_splits
from microstructure.research.trade_only import (
    build_trade_only_research_frame,
    validate_trade_only_temporal_contract,
)

PUBLIC_PIPELINE_SCHEMA_VERSION = "1.0.0"
PUBLIC_EVIDENCE_TIER = "PUBLIC_SAMPLE_PARTIAL"
EXECUTION_EXCLUSION_REASON = (
    "Not run: aggregate-trade history has no contemporaneous quotes, depth, queue state, "
    "or local receipt clock, so execution, fees-to-alpha conversion, P&L, fills, and capacity "
    "would be unsupported claims."
)
HYPOTHESIS_BASELINE = "historical_prior"
HYPOTHESIS_BLOCK_POLICY = "fixed_contiguous_2x_label_horizon"
HYPOTHESIS_CAVEAT = (
    "Exploratory paired percentile interval on a bounded retrospective sample; it is a "
    "dependence diagnostic, not a p-value, confirmatory significance test, or basis for "
    "rejecting H0."
)
CROSS_INSTRUMENT_CONCLUSION = (
    "No pooled or cross-instrument conclusion is inferred: BTCUSDT and ETHUSDT are separate "
    "sample-specific diagnostics. They cannot support a persistent-alpha claim, regardless "
    "of their point-estimate directions."
)

__all__ = [
    "EXECUTION_EXCLUSION_REASON",
    "PUBLIC_EVIDENCE_TIER",
    "PUBLIC_PIPELINE_SCHEMA_VERSION",
    "PublicPipelineError",
    "produce_public_trade_run",
]


class PublicPipelineError(RuntimeError):
    """Raised when the frozen public run cannot be produced honestly."""


@dataclass(frozen=True, slots=True)
class _SymbolResult:
    symbol: str
    research: pl.DataFrame
    evaluation: pl.DataFrame
    plan: WalkForwardPlan
    predictions: pl.DataFrame
    comparison: pl.DataFrame
    selected_predictions: pl.DataFrame
    selected_model: str
    feature_columns: tuple[str, ...]
    temporal_audit: Mapping[str, Any]
    hypothesis_evaluation: Mapping[str, Any]


def _json_safe(value: Any) -> Any:
    if isinstance(value, np.generic):
        return _json_safe(value.item())
    if isinstance(value, float) and not math.isfinite(value):
        return None
    if isinstance(value, Path):
        return str(value)
    if isinstance(value, Mapping):
        return {str(key): _json_safe(item) for key, item in value.items()}
    if isinstance(value, (list, tuple)):
        return [_json_safe(item) for item in value]
    return value


def _write_json(path: Path, payload: Mapping[str, Any] | list[Any]) -> None:
    clean = _json_safe(payload)
    if not isinstance(clean, (dict, list)):
        raise TypeError("JSON artifact payload must be an object or list")
    write_json(path, clean)


def _atomic_write_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,
    )
    try:
        with os.fdopen(descriptor, "w", encoding="utf-8", newline="\n") as handle:
            handle.write(content.rstrip() + "\n")
        os.replace(temporary_name, path)
    except BaseException:
        Path(temporary_name).unlink(missing_ok=True)
        raise


def _freeze_protocol(config: ProjectConfig, stage: Path) -> tuple[str, str]:
    source = config.project_root / "docs" / "PUBLIC_TRADE_PROTOCOL.md"
    if not source.is_file():
        raise PublicPipelineError(f"frozen public trade protocol is missing: {source}")
    before = sha256_file(source)
    try:
        content = source.read_bytes()
    except OSError as exc:
        raise PublicPipelineError(f"cannot read frozen public trade protocol: {source}") from exc
    after = sha256_file(source)
    if before != after or hashlib.sha256(content).hexdigest() != before:
        raise PublicPipelineError("public trade protocol changed while it was being frozen")

    relative = "protocol/PUBLIC_TRADE_PROTOCOL.md"
    destination = stage / relative
    destination.parent.mkdir(parents=True, exist_ok=True)
    descriptor, temporary_name = tempfile.mkstemp(
        dir=destination.parent,
        prefix=f".{destination.name}.",
        suffix=".tmp",
    )
    try:
        with os.fdopen(descriptor, "wb") as handle:
            handle.write(content)
            handle.flush()
            os.fsync(handle.fileno())
        os.replace(temporary_name, destination)
    except BaseException:
        Path(temporary_name).unlink(missing_ok=True)
        raise
    if sha256_file(destination) != before:
        raise PublicPipelineError("frozen protocol copy does not match its source SHA-256")
    return relative, before


def _utc_from_ns(timestamp_ns: int) -> str:
    seconds, nanoseconds = divmod(timestamp_ns, 1_000_000_000)
    instant = datetime.fromtimestamp(seconds, tz=UTC)
    return f"{instant:%Y-%m-%dT%H:%M:%S}.{nanoseconds:09d}Z"


def _stable_sha256(payload: Mapping[str, Any]) -> str:
    encoded = json.dumps(payload, sort_keys=True, separators=(",", ":"), allow_nan=False)
    return hashlib.sha256(encoded.encode("utf-8")).hexdigest()


def _mapping(value: object) -> Mapping[str, Any] | None:
    if not isinstance(value, Mapping) or not all(isinstance(key, str) for key in value):
        return None
    return cast(Mapping[str, Any], value)


def _project_path(path: Path, project_root: Path) -> str:
    resolved = path.resolve()
    try:
        return resolved.relative_to(project_root.resolve()).as_posix()
    except ValueError:
        return str(resolved)


def _verified_manifest_object(path: Path, expected_sha256: str) -> Mapping[str, Any]:
    before = sha256_file(path)
    if before != expected_sha256:
        raise PublicPipelineError(f"input manifest changed after verified loading: {path}")
    payload = _mapping(read_json(path))
    after = sha256_file(path)
    if after != expected_sha256 or after != before:
        raise PublicPipelineError(f"input manifest changed while capturing lineage: {path}")
    if payload is None:
        raise PublicPipelineError(f"verified input manifest is not a JSON object: {path}")
    return payload


def _input_lineage(public: PublicTrades, config: ProjectConfig) -> dict[str, Any]:
    ingestion = _verified_manifest_object(
        public.ingestion_manifest_path, public.ingestion_manifest_sha256
    )
    dataset = _verified_manifest_object(
        public.dataset_manifest_path, public.dataset_manifest_sha256
    )

    manifest_hashes = set(public.input_manifest_sha256s)
    data_hashes = set(public.raw_artifact_sha256s)
    raw_entries = ingestion.get("raw_artifacts")
    if not isinstance(raw_entries, list):
        raise PublicPipelineError("verified ingestion manifest has no raw artifact array")
    for entry_value in raw_entries:
        entry = _mapping(entry_value)
        if entry is None:
            raise PublicPipelineError("verified raw artifact entry is not an object")
        raw_sha = entry.get("sha256")
        raw_manifest_sha = entry.get("manifest_sha256")
        if isinstance(raw_sha, str):
            data_hashes.add(raw_sha)
            raw_path = public.ingestion_manifest_path.parent.parent / str(entry.get("path"))
            if sha256_file(raw_path) != raw_sha:
                raise PublicPipelineError(f"raw input changed while capturing lineage: {raw_path}")
        if isinstance(raw_manifest_sha, str):
            manifest_hashes.add(raw_manifest_sha)
            raw_manifest_path = public.ingestion_manifest_path.parent.parent / str(
                entry.get("manifest_path")
            )
            if sha256_file(raw_manifest_path) != raw_manifest_sha:
                raise PublicPipelineError(
                    f"raw manifest changed while capturing lineage: {raw_manifest_path}"
                )

    part_entries = dataset.get("artifacts")
    if not isinstance(part_entries, list):
        raise PublicPipelineError("verified dataset manifest has no artifact array")
    for entry_value in part_entries:
        entry = _mapping(entry_value)
        if entry is None:
            raise PublicPipelineError("verified normalized artifact entry is not an object")
        data_sha = entry.get("data_sha256")
        part_manifest_sha = entry.get("manifest_sha256")
        if isinstance(data_sha, str):
            data_hashes.add(data_sha)
            data_path = public.dataset_manifest_path.parent.parent / str(entry.get("data_path"))
            if sha256_file(data_path) != data_sha:
                raise PublicPipelineError(
                    f"normalized part changed while capturing lineage: {data_path}"
                )
        if isinstance(part_manifest_sha, str):
            manifest_hashes.add(part_manifest_sha)
            part_manifest_path = public.dataset_manifest_path.parent.parent / str(
                entry.get("manifest_path")
            )
            if sha256_file(part_manifest_path) != part_manifest_sha:
                raise PublicPipelineError(
                    "normalized part manifest changed while capturing lineage: "
                    f"{part_manifest_path}"
                )

    return {
        "ingestion_manifest": {
            "absolute_path": str(public.ingestion_manifest_path.resolve()),
            "project_relative_or_absolute_path": _project_path(
                public.ingestion_manifest_path, config.project_root
            ),
            "sha256": public.ingestion_manifest_sha256,
        },
        "normalized_dataset_manifest": {
            "absolute_path": str(public.dataset_manifest_path.resolve()),
            "project_relative_or_absolute_path": _project_path(
                public.dataset_manifest_path, config.project_root
            ),
            "sha256": public.dataset_manifest_sha256,
        },
        "normalized_parts": [
            _project_path(path, config.project_root) for path in public.part_paths
        ],
        "raw_artifacts": [
            _project_path(path, config.project_root) for path in public.raw_artifact_paths
        ],
        "raw_manifests": [
            _project_path(path, config.project_root) for path in public.raw_manifest_paths
        ],
        "manifest_sha256": sorted(manifest_hashes),
        "data_sha256": sorted(data_hashes),
    }


def _derive_verified_continuity(
    public: PublicTrades, config: ProjectConfig
) -> tuple[pl.DataFrame, list[dict[str, Any]]]:
    if public.rows > public.row_bound:
        raise PublicPipelineError("materialized public rows exceed the verified configured bound")
    raw = public.polars_trades
    expected_symbols = set(config.data.symbols)
    if set(str(value) for value in raw.get_column("symbol").unique()) != expected_symbols:
        raise PublicPipelineError("materialized public symbols do not match the configuration")
    if raw.get_column("continuity_id").null_count() != raw.height:
        raise PublicPipelineError(
            "archive normalized rows must retain null source continuity before derivation"
        )

    derived_frames: list[pl.DataFrame] = []
    audits: list[dict[str, Any]] = []
    for symbol in config.data.symbols:
        source = raw.filter(pl.col("symbol") == symbol).sort("trade_id")
        if source.is_empty():
            raise PublicPipelineError(f"verified public input has no rows for {symbol}")
        ids = source.get_column("trade_id").to_numpy().astype(np.int64)
        available = source.get_column("available_ts_ns").to_numpy().astype(np.int64)
        event = source.get_column("event_ts_ns").to_numpy().astype(np.int64)
        if np.any(np.diff(ids) != 1):
            raise PublicPipelineError(f"aggregate trade IDs are not contiguous by one for {symbol}")
        if np.any(np.diff(available) < 0):
            raise PublicPipelineError(
                f"availability clock reverses in aggregate-trade-ID order for {symbol}"
            )
        if np.any(available < event):
            raise PublicPipelineError(f"availability precedes event time for {symbol}")
        bases = set(str(value) for value in source.get_column("availability_basis").unique())
        if bases != {"exchange_event_time_proxy"}:
            raise PublicPipelineError(
                f"historical public trades require the exchange-event-time proxy for {symbol}"
            )
        if source.get_column("received_ts_ns").null_count() != source.height:
            raise PublicPipelineError(
                f"historical public trades cannot claim local receipt time for {symbol}"
            )

        continuity_id = (
            f"public-aggtrade:{public.ingestion_manifest_sha256[:16]}:{symbol}:"
            f"{int(ids[0])}-{int(ids[-1])}"
        )
        derived_frames.append(source.with_columns(pl.lit(continuity_id).alias("continuity_id")))
        audits.append(
            {
                "symbol": symbol,
                "rows": source.height,
                "first_trade_id": int(ids[0]),
                "last_trade_id": int(ids[-1]),
                "trade_id_step": 1,
                "trade_ids_contiguous": True,
                "availability_clock_nondecreasing": True,
                "tied_availability_rows": int(np.count_nonzero(np.diff(available) == 0)),
                "availability_basis": "exchange_event_time_proxy",
                "local_receipt_time_available": False,
                "derived_continuity_id": continuity_id,
                "derivation_timing": "assigned only after ID and clock verification",
                "source_rows_mutated": False,
            }
        )
    return pl.concat(derived_frames).sort(["symbol", "trade_id"]), audits


def _trade_feature_columns(config: ProjectConfig, frame: pl.DataFrame) -> tuple[str, ...]:
    columns: list[str] = ["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}",
            ]
        )
    intensity = config.features.intensity_window
    columns.extend([f"trade_count_w{intensity}", f"trade_intensity_w{intensity}"])
    columns.append(f"realized_volatility_w{config.features.volatility_window}")
    selected = tuple(dict.fromkeys(columns))
    missing = sorted(set(selected).difference(frame.columns))
    if missing:
        raise PublicPipelineError(f"declared trade-only model features are missing: {missing}")
    return selected


def _serialize_plan(plan: WalkForwardPlan) -> dict[str, Any]:
    return {
        "contract": (
            "single-symbol decision-time buckets; expanding training; feature-ready and "
            "uncensored evaluation; labels ending at or beyond evaluation are purged; "
            "configured embargo applied"
        ),
        "index_basis": "zero-based row positions in this symbol's evaluation_frame.parquet",
        "decision_time_count": plan.decision_time_count,
        "folds": [
            {
                "fold_id": fold.fold_id,
                "train_indices": [int(value) for value in fold.train_indices.tolist()],
                "validation_indices": [int(value) for value in fold.validation_indices.tolist()],
                "train_start_ts_ns": fold.train_start_ts_ns,
                "train_end_ts_ns": fold.train_end_ts_ns,
                "validation_start_ts_ns": fold.validation_start_ts_ns,
                "validation_end_ts_ns": fold.validation_end_ts_ns,
                "purged_rows": fold.purged_rows,
                "embargoed_time_buckets": fold.embargoed_time_buckets,
            }
            for fold in plan.folds
        ],
        "final_train_indices": [int(value) for value in plan.final_train_indices.tolist()],
        "test_indices": [int(value) for value in plan.test_indices.tolist()],
        "test_start_ts_ns": plan.test_start_ts_ns,
        "test_end_ts_ns": plan.test_end_ts_ns,
        "test_used_for_selection": False,
    }


def _add_fixed_blocks(predictions: pl.DataFrame, *, block_width: int) -> pl.DataFrame:
    group = ["split", "fold_id"]
    return (
        predictions.with_columns(
            pl.col("decision_sequence").min().over(group).alias("_block_origin_trade_id")
        )
        .with_columns(
            ((pl.col("decision_sequence") - pl.col("_block_origin_trade_id")) // block_width)
            .cast(pl.Int64)
            .alias("_block_index")
        )
        .with_columns(
            pl.concat_str(
                [
                    "symbol",
                    "split",
                    pl.col("fold_id").cast(pl.String),
                    pl.col("_block_index").cast(pl.String),
                ],
                separator=":",
            ).alias("bootstrap_block"),
            (pl.col("_block_origin_trade_id") + pl.col("_block_index") * block_width).alias(
                "bootstrap_block_start_trade_id"
            ),
        )
        .with_columns(
            (pl.col("bootstrap_block_start_trade_id") + block_width - 1).alias(
                "bootstrap_block_end_trade_id"
            ),
            pl.lit(block_width, dtype=pl.Int64).alias("bootstrap_block_width_trades"),
            pl.lit("fixed_contiguous_2x_label_horizon").alias("bootstrap_block_policy"),
        )
        .drop("_block_origin_trade_id", "_block_index")
    )


def _bootstrap_comparison(
    comparison: pl.DataFrame,
    predictions: pl.DataFrame,
    *,
    symbol: str,
    selected_model: str,
    metric: str,
    n_bootstrap: int,
    seed: int,
    horizon: int,
) -> pl.DataFrame:
    rows: list[dict[str, Any]] = []
    block_width = 2 * horizon
    for index, source_row in enumerate(
        comparison.sort(["split", "fold_id", "requested_model"]).to_dicts()
    ):
        row = dict(source_row)
        requested_model = str(row.get("requested_model", row["model"]))
        row["selected_on_validation"] = requested_model == selected_model
        row["selected_on"] = "validation" if requested_model == selected_model else None
        row["selection_contract"] = "validation folds only; final test opened after selection"
        row["test_used_for_selection"] = False
        row["evidence_tier"] = PUBLIC_EVIDENCE_TIER
        row["execution_evaluated"] = False
        row[f"{metric}_ci_low"] = None
        row[f"{metric}_ci_high"] = None
        row["bootstrap_status"] = None
        row["bootstrap_blocks"] = None
        row["bootstrap_samples"] = None
        row["bootstrap_seed"] = None
        row["bootstrap_block_width_trades"] = None
        row["bootstrap_block_policy"] = None
        row["bootstrap_limitation"] = None
        if row["split"] == "test":
            evaluated = predictions.filter(
                (pl.col("split") == "test")
                & (pl.col("model") == str(row["model"]))
                & (pl.col("requested_model") == requested_model)
            )
            interval_seed = seed + index
            interval = block_bootstrap_metric(
                evaluated,
                metric=metric,
                block_column="bootstrap_block",
                n_bootstrap=n_bootstrap,
                seed=interval_seed,
            )
            row[f"{metric}_ci_low"] = interval.lower
            row[f"{metric}_ci_high"] = interval.upper
            row["bootstrap_status"] = interval.status
            row["bootstrap_blocks"] = interval.n_blocks
            row["bootstrap_samples"] = interval.n_bootstrap
            row["bootstrap_seed"] = interval_seed
            row["bootstrap_block_width_trades"] = block_width
            row["bootstrap_block_policy"] = "fixed_contiguous_2x_label_horizon"
            row["bootstrap_limitation"] = (
                "percentile dependence diagnostic on fixed trade blocks; not a p-value or "
                "confirmatory coverage guarantee"
            )
        rows.append(row)
    return pl.DataFrame(rows, infer_schema_length=None).with_columns(
        pl.lit(symbol).alias("symbol"),
        pl.lit(symbol).alias("instrument"),
        pl.lit(symbol).alias("instrument_scope"),
    )


def _metric_delta_direction(metric: str) -> tuple[str, int]:
    if metric in {"log_loss", "brier_score", "expected_calibration_error"}:
        return "negative_selected_minus_prior_is_favorable", -1
    if metric in {"accuracy", "balanced_accuracy", "roc_auc", "pr_auc"}:
        return "positive_selected_minus_prior_is_favorable", 1
    raise PublicPipelineError(f"unsupported paired hypothesis metric: {metric}")


def _paired_hypothesis_evaluation(
    predictions: pl.DataFrame,
    *,
    symbol: str,
    selected_model: str,
    metric: str,
    n_bootstrap: int,
    seed: int,
    horizon: int,
) -> dict[str, Any]:
    selected = predictions.filter(
        (pl.col("split") == "test") & (pl.col("requested_model") == selected_model)
    )
    baseline = predictions.filter(
        (pl.col("split") == "test") & (pl.col("requested_model") == HYPOTHESIS_BASELINE)
    )
    if selected.is_empty():
        raise PublicPipelineError(
            f"validation-selected test predictions are missing for paired test: {symbol}"
        )
    if baseline.is_empty():
        raise PublicPipelineError(f"historical-prior test predictions are missing for {symbol}")

    identity_columns = [
        "row_id",
        "y_true",
        "bootstrap_block",
        "bootstrap_block_start_trade_id",
        "bootstrap_block_end_trade_id",
        "bootstrap_block_width_trades",
        "bootstrap_block_policy",
    ]
    for name, frame in (("selected", selected), ("historical_prior", baseline)):
        missing = sorted(set(identity_columns).difference(frame.columns))
        if missing:
            raise PublicPipelineError(
                f"{name} predictions lack paired-bootstrap identity columns: {missing}"
            )
        if frame.get_column("row_id").n_unique() != frame.height:
            raise PublicPipelineError(f"{name} predictions contain duplicate row IDs for {symbol}")

    selected_identity = selected.select(identity_columns).sort("row_id")
    baseline_identity = baseline.select(identity_columns).sort("row_id")
    if not selected_identity.equals(baseline_identity):
        raise PublicPipelineError(
            f"selected and historical-prior predictions do not share identical rows/blocks for {symbol}"
        )

    block_width = 2 * horizon
    policies = selected.get_column("bootstrap_block_policy").unique().to_list()
    widths = selected.get_column("bootstrap_block_width_trades").unique().to_list()
    if policies != [HYPOTHESIS_BLOCK_POLICY] or widths != [block_width]:
        raise PublicPipelineError(
            f"paired hypothesis blocks do not implement the frozen 2x-horizon policy for {symbol}"
        )

    interval = paired_block_bootstrap_difference(
        selected,
        baseline,
        metric=metric,
        block_column="bootstrap_block",
        n_bootstrap=n_bootstrap,
        seed=seed,
    )
    favorable_direction, favorable_sign = _metric_delta_direction(metric)
    signed_point = favorable_sign * interval.point_estimate
    if not math.isfinite(signed_point):
        point_assessment = "unavailable"
        point_favorable: bool | None = None
    elif signed_point > 0:
        point_assessment = "favorable_point_only"
        point_favorable = True
    elif signed_point < 0:
        point_assessment = "unfavorable_point"
        point_favorable = False
    else:
        point_assessment = "point_tie"
        point_favorable = False

    if interval.lower is None or interval.upper is None:
        interval_relation = "unavailable"
    elif interval.lower <= 0.0 <= interval.upper:
        interval_relation = "includes_zero"
    elif favorable_sign * interval.lower > 0.0 and favorable_sign * interval.upper > 0.0:
        interval_relation = "entirely_favorable"
    else:
        interval_relation = "entirely_unfavorable"

    return {
        "symbol": symbol,
        "selected_model": selected_model,
        "baseline": HYPOTHESIS_BASELINE,
        "metric": metric,
        "delta_definition": "selected_model_minus_historical_prior",
        "point_delta": interval.point_estimate,
        "ci_level": 0.95,
        "ci_low": interval.lower,
        "ci_high": interval.upper,
        "n_obs": selected.height,
        "n_blocks": interval.n_blocks,
        "samples": interval.n_bootstrap,
        "seed": interval.seed,
        "status": interval.status,
        "block_column": "bootstrap_block",
        "block_policy": HYPOTHESIS_BLOCK_POLICY,
        "block_width_trades": block_width,
        "paired_row_ids_identical": True,
        "paired_blocks_identical": True,
        "favorable_direction": favorable_direction,
        "point_favorable": point_favorable,
        "point_assessment": point_assessment,
        "interval_relation_to_zero": interval_relation,
        "exploratory": True,
        "significance_claim_authorized": False,
        "h0_rejection_authorized": False,
        "caveat": HYPOTHESIS_CAVEAT,
        "cross_instrument_conclusion": CROSS_INSTRUMENT_CONCLUSION,
    }


def _attach_paired_hypothesis_to_comparison(
    comparison: pl.DataFrame,
    hypothesis: Mapping[str, Any],
) -> pl.DataFrame:
    selected_model = str(hypothesis["selected_model"])
    rows: list[dict[str, Any]] = []
    attached = 0
    for source in comparison.to_dicts():
        row = dict(source)
        selected_test = row["split"] == "test" and row.get("requested_model") == selected_model
        paired_fields = {
            "paired_baseline": None,
            "paired_metric": None,
            "paired_metric_delta": None,
            "paired_metric_delta_ci_low": None,
            "paired_metric_delta_ci_high": None,
            "paired_n_obs": None,
            "paired_bootstrap_blocks": None,
            "paired_bootstrap_samples": None,
            "paired_bootstrap_seed": None,
            "paired_bootstrap_status": None,
            "paired_bootstrap_block_policy": None,
            "paired_favorable_direction": None,
            "paired_point_favorable": None,
            "paired_exploratory": None,
            "paired_significance_claim_authorized": None,
        }
        if selected_test:
            attached += 1
            paired_fields.update(
                {
                    "paired_baseline": hypothesis["baseline"],
                    "paired_metric": hypothesis["metric"],
                    "paired_metric_delta": hypothesis["point_delta"],
                    "paired_metric_delta_ci_low": hypothesis["ci_low"],
                    "paired_metric_delta_ci_high": hypothesis["ci_high"],
                    "paired_n_obs": hypothesis["n_obs"],
                    "paired_bootstrap_blocks": hypothesis["n_blocks"],
                    "paired_bootstrap_samples": hypothesis["samples"],
                    "paired_bootstrap_seed": hypothesis["seed"],
                    "paired_bootstrap_status": hypothesis["status"],
                    "paired_bootstrap_block_policy": hypothesis["block_policy"],
                    "paired_favorable_direction": hypothesis["favorable_direction"],
                    "paired_point_favorable": hypothesis["point_favorable"],
                    "paired_exploratory": hypothesis["exploratory"],
                    "paired_significance_claim_authorized": hypothesis[
                        "significance_claim_authorized"
                    ],
                }
            )
        row.update(paired_fields)
        rows.append(row)
    if attached != 1:
        raise PublicPipelineError(
            "paired hypothesis metadata must attach to exactly one selected test comparison row"
        )
    return pl.DataFrame(rows, infer_schema_length=None)


def _rows_by_plan(
    evaluation: pl.DataFrame, indices: np.ndarray[Any, np.dtype[np.int64]]
) -> pl.DataFrame:
    indexed = evaluation.with_row_index("_research_row_id")
    return indexed.filter(pl.col("_research_row_id").is_in(indices)).drop("_research_row_id")


def _evaluate_symbol(
    trades: pl.DataFrame,
    *,
    config: ProjectConfig,
    symbol_index: int,
) -> _SymbolResult:
    symbol = str(trades.get_column("symbol")[0])
    research = build_trade_only_research_frame(trades, config.features).with_columns(
        pl.col("label_horizon_trades").alias("label_horizon_events")
    )
    temporal = validate_trade_only_temporal_contract(research)
    evaluation = research.filter(pl.col("feature_ready"))
    if evaluation.is_empty():
        raise PublicPipelineError(f"trade-only feature construction produced no rows for {symbol}")
    features = _trade_feature_columns(config, evaluation)
    plan = expanding_walk_forward_splits(evaluation, config.evaluation)
    ladder = evaluate_model_ladder(
        evaluation,
        plan,
        config.models,
        seed=config.run.seed + symbol_index * 100_000,
        calibration_bins=config.evaluation.calibration_bins,
        target="future_trade_up",
        features=features,
    )
    block_width = 2 * config.features.label_horizon_events
    predictions = _add_fixed_blocks(ladder.predictions, block_width=block_width)
    comparison = _bootstrap_comparison(
        ladder.comparison,
        predictions,
        symbol=symbol,
        selected_model=ladder.selected_model,
        metric=ladder.selection_metric,
        n_bootstrap=config.evaluation.bootstrap_samples,
        seed=config.run.seed + symbol_index * 100_000 + 10_000,
        horizon=config.features.label_horizon_events,
    )
    selected = predictions.filter(
        (pl.col("split") == "test") & (pl.col("requested_model") == ladder.selected_model)
    )
    if selected.is_empty() or selected.get_column("requested_model").n_unique() != 1:
        raise PublicPipelineError(f"validation-selected test predictions are missing for {symbol}")
    hypothesis = _paired_hypothesis_evaluation(
        predictions,
        symbol=symbol,
        selected_model=ladder.selected_model,
        metric=ladder.selection_metric,
        n_bootstrap=config.evaluation.bootstrap_samples,
        seed=config.run.seed + symbol_index * 100_000 + 20_000,
        horizon=config.features.label_horizon_events,
    )
    comparison = _attach_paired_hypothesis_to_comparison(comparison, hypothesis)
    return _SymbolResult(
        symbol=symbol,
        research=research,
        evaluation=evaluation,
        plan=plan,
        predictions=predictions,
        comparison=comparison,
        selected_predictions=selected,
        selected_model=ladder.selected_model,
        feature_columns=features,
        temporal_audit=asdict(temporal),
        hypothesis_evaluation=hypothesis,
    )


def _trade_summary(
    trades: pl.DataFrame, continuity_audits: Sequence[Mapping[str, Any]]
) -> pl.DataFrame:
    continuity = {
        str(row["symbol"]): str(row["derived_continuity_id"]) for row in continuity_audits
    }
    rows: list[dict[str, Any]] = []
    for frame in trades.partition_by("symbol", maintain_order=True):
        symbol = str(frame.get_column("symbol")[0])
        buy = frame.filter(pl.col("aggressor_side") == "buy")
        sell = frame.filter(pl.col("aggressor_side") == "sell")
        rows.append(
            {
                "symbol": symbol,
                "rows": frame.height,
                "first_trade_id": int(cast(int, frame.get_column("trade_id").min())),
                "last_trade_id": int(cast(int, frame.get_column("trade_id").max())),
                "observed_start_utc": _utc_from_ns(
                    int(cast(int, frame.get_column("event_ts_ns").min()))
                ),
                "observed_end_utc": _utc_from_ns(
                    int(cast(int, frame.get_column("event_ts_ns").max()))
                ),
                "total_quantity": float(cast(float, frame.get_column("quantity").sum())),
                "total_quote_quantity": float(
                    cast(float, frame.get_column("quote_quantity").sum())
                ),
                "buy_rows": buy.height,
                "sell_rows": sell.height,
                "buy_quantity": float(cast(float, buy.get_column("quantity").sum())),
                "sell_quantity": float(cast(float, sell.get_column("quantity").sum())),
                "derived_continuity_id": continuity[symbol],
                "availability_basis": "exchange_event_time_proxy",
                "analysis_kind": "public_trade_sample_summary_descriptive",
                "descriptive_only": True,
            }
        )
    return pl.DataFrame(rows).sort("symbol")


def _write_analyses(
    *,
    trades: pl.DataFrame,
    symbol_results: Sequence[_SymbolResult],
    continuity_audits: Sequence[Mapping[str, Any]],
    config: ProjectConfig,
    stage: Path,
    generated_at_utc: str,
) -> dict[str, str]:
    summary = _trade_summary(trades, continuity_audits)
    stability_frames: list[pl.DataFrame] = []
    flow_frames: list[pl.DataFrame] = []
    flow_feature = f"trade_imbalance_w{max(config.features.trade_windows)}"
    for result in symbol_results:
        train = _rows_by_plan(result.evaluation, result.plan.final_train_indices)
        test = _rows_by_plan(result.evaluation, result.plan.test_indices)
        stability_frames.append(
            feature_stability_summary(
                train,
                test,
                feature_columns=result.feature_columns,
                group_columns=("symbol",),
            ).with_columns(
                pl.lit("final_training_period").alias("reference_period"),
                pl.lit("untouched_final_test").alias("comparison_period"),
                pl.lit(PUBLIC_EVIDENCE_TIER).alias("evidence_tier"),
            )
        )
        labeled = result.evaluation.filter(~pl.col("right_censored"))
        flow_frames.append(
            ofi_future_return_association(
                labeled,
                horizon_return_columns={
                    config.features.label_horizon_events: "future_trade_return"
                },
                ofi_column=flow_feature,
                min_observations=3,
            ).with_columns(
                pl.lit("all_feature_ready_labeled_rows").alias("analysis_scope"),
                pl.lit(PUBLIC_EVIDENCE_TIER).alias("evidence_tier"),
            )
        )
    stability = pl.concat(stability_frames)
    flow_return = pl.concat(flow_frames)
    artifacts = {
        "trade_summary": "analysis/trade_summary.parquet",
        "feature_stability": "analysis/feature_stability.parquet",
        "flow_return_analysis": "analysis/flow_return_analysis.parquet",
    }
    for name, frame in (
        ("trade_summary", summary),
        ("feature_stability", stability),
        ("flow_return_analysis", flow_return),
    ):
        path = stage / artifacts[name]
        path.parent.mkdir(parents=True, exist_ok=True)
        frame.write_parquet(path)
    _write_json(
        stage / "analysis" / "manifest.json",
        {
            "generated_at_utc": generated_at_utc,
            "evidence_tier": PUBLIC_EVIDENCE_TIER,
            "descriptive_only": True,
            "economic_claim_authorized": False,
            "execution_claim_authorized": False,
            "artifacts": {
                "trade_summary": {"path": artifacts["trade_summary"], "rows": summary.height},
                "feature_stability": {
                    "path": artifacts["feature_stability"],
                    "rows": stability.height,
                    "reference": "final training period",
                    "comparison": "untouched final test",
                },
                "flow_return_analysis": {
                    "path": artifacts["flow_return_analysis"],
                    "rows": flow_return.height,
                    "scope": "all feature-ready labeled rows",
                },
            },
            "limitations": [
                "Retrospective bounded sample; no confirmatory significance claim.",
                "Exchange event time is an availability proxy, not local receipt evidence.",
                "Trade-only observations cannot support book or execution analysis.",
            ],
        },
    )
    return {**artifacts, "analysis_manifest": "analysis/manifest.json"}


def _quality_payload(
    public: PublicTrades,
    continuity_audits: Sequence[Mapping[str, Any]],
    *,
    generated_at_utc: str,
) -> dict[str, Any]:
    return {
        "generated_at_utc": generated_at_utc,
        "dataset": "manifested_public_aggregate_trades",
        "rows_checked": public.validation.rows_checked,
        "summary": {
            "errors": public.validation.error_count,
            "warnings": public.validation.warning_count,
        },
        "normalized_schema_validation": {
            "dataset": public.validation.dataset,
            "rows_checked": public.validation.rows_checked,
            "errors": public.validation.error_count,
            "warnings": public.validation.warning_count,
            "findings": [asdict(finding) for finding in public.validation.findings],
        },
        "aggregate_trade_continuity": list(continuity_audits),
        "row_bound": public.row_bound,
        "row_bound_respected": public.rows <= public.row_bound,
        "canonical_source_order": list(public.canonical_order),
        "mutation_policy": (
            "verified normalized observations were not repaired or overwritten; continuity "
            "exists only in persisted derived research frames"
        ),
    }


def _hypothesis_number(value: object) -> str:
    if value is None:
        return "N/A"
    if isinstance(value, (int, float)) and not isinstance(value, bool):
        number = float(value)
        return f"{number:.6f}" if math.isfinite(number) else "N/A"
    return str(value)


def _render_hypothesis_report_section(stage: Path) -> str:
    artifact = stage / "metrics" / "hypothesis_evaluation.json"
    payload = _mapping(read_json(artifact))
    if payload is None:
        raise PublicPipelineError("serialized hypothesis evaluation must be a JSON object")
    rows = payload.get("per_symbol")
    if not isinstance(rows, list) or not rows:
        raise PublicPipelineError("serialized hypothesis evaluation has no per-symbol rows")

    lines = [
        "## Paired H0/H1 diagnostic",
        "",
        (
            "The frozen comparison is validation-selected test predictions versus the "
            "historical-prior baseline on identical `row_id` and fixed 2x-horizon blocks. "
            "For Δ log-loss (selected minus historical prior), a negative value favors the "
            "selected model."
        ),
        "",
        (
            "| Symbol | Selected model | Baseline | Metric | Point Δ | Paired 95% interval | "
            "Observations | Blocks | Samples | Seed | Status |"
        ),
        "| --- | --- | --- | --- | ---: | --- | ---: | ---: | ---: | ---: | --- |",
    ]
    for value in rows:
        row = _mapping(value)
        if row is None:
            raise PublicPipelineError("serialized per-symbol hypothesis row is not an object")
        interval = (
            f"[{_hypothesis_number(row.get('ci_low'))}, {_hypothesis_number(row.get('ci_high'))}]"
        )
        cells = (
            row.get("symbol"),
            row.get("selected_model"),
            row.get("baseline"),
            row.get("metric"),
            _hypothesis_number(row.get("point_delta")),
            interval,
            row.get("n_obs"),
            row.get("n_blocks"),
            row.get("samples"),
            row.get("seed"),
            row.get("status"),
        )
        lines.append(
            "| "
            + " | ".join(str(cell).replace("|", "\\|").replace("\n", " ") for cell in cells)
            + " |"
        )
    lines.extend(
        [
            "",
            (
                "These paired percentile intervals are dependence diagnostics, not p-values "
                "or confirmatory significance intervals; H0 is not rejected by this "
                "exploratory design."
            ),
            "",
            (
                "No cross-instrument estimate was pooled. Mixed directions, if present, "
                "cannot support persistent alpha; even matching directions would remain "
                "bounded, sample-specific diagnostics."
            ),
        ]
    )
    return "\n".join(lines)


def _report_set(stage: Path) -> None:
    bundle = load_run_bundle(stage, require_complete=False, verify_integrity=False)
    hypothesis_section = _render_hypothesis_report_section(stage)
    _atomic_write_text(
        stage / "reports" / "technical_report.md",
        render_technical_report(bundle),
    )
    _atomic_write_text(
        stage / "reports" / "executive_memo.md",
        render_executive_memo(bundle),
    )
    _atomic_write_text(
        stage / "reports" / "model_comparison.md",
        render_model_comparison(bundle)
        + "\nExecution status: `NOT_RUN`. Reason: "
        + EXECUTION_EXCLUSION_REASON
        + "\n\n"
        + hypothesis_section
        + "\n",
    )


def produce_public_trade_run(
    config: ProjectConfig,
    stage: Path,
    *,
    ingestion_manifest_path: str | Path,
    ingestion_manifest_sha256: str,
) -> None:
    """Populate an empty atomic stage with one verified public trade-only run.

    The caller owns staging-directory creation, cleanup on failure, and final
    rename.  This function writes ``_SUCCESS`` only after every artifact, report,
    and checksum is durable in the supplied stage.
    """

    destination = stage.resolve()
    if destination.exists() and any(destination.iterdir()):
        raise PublicPipelineError("public run stage must be empty")
    destination.mkdir(parents=True, exist_ok=True)

    if config.data.mode != "binance_rest":
        raise PublicPipelineError("public trade producer requires data.mode='binance_rest'")
    explicit_manifest_path = Path(ingestion_manifest_path).resolve()
    public = read_public_trades(
        config,
        explicit_manifest_path,
        ingestion_manifest_sha256=ingestion_manifest_sha256,
    )
    if public.evidence_tier == "FULL_DATA" and not public.all_requested_ranges_complete:
        raise PublicPipelineError("reader evidence tier contradicts manifested completeness")
    derived_trades, continuity_audits = _derive_verified_continuity(public, config)
    if public.validation.has_errors:
        raise PublicPipelineError("verified public normalized input has quality errors")

    generated = provenance_header(
        project_root=config.project_root,
        config_hash=config.hash,
        evidence_tier=PUBLIC_EVIDENCE_TIER,
        input_manifests=[],
    )
    generated_at = cast(str, generated["generated_at_utc"])
    lineage = _input_lineage(public, config)
    manifest_hashes = cast(list[str], lineage["manifest_sha256"])
    data_hashes = cast(list[str], lineage["data_sha256"])
    protocol_path, protocol_sha256 = _freeze_protocol(config, destination)

    symbol_results: list[_SymbolResult] = []
    for symbol_index, symbol in enumerate(config.data.symbols):
        symbol_results.append(
            _evaluate_symbol(
                derived_trades.filter(pl.col("symbol") == symbol),
                config=config,
                symbol_index=symbol_index,
            )
        )

    research_root = destination / "research"
    model_root = destination / "models"
    combined_research: list[pl.DataFrame] = []
    combined_evaluation: list[pl.DataFrame] = []
    combined_predictions: list[pl.DataFrame] = []
    combined_comparison: list[pl.DataFrame] = []
    combined_selected: list[pl.DataFrame] = []
    symbol_manifest: dict[str, Any] = {}
    for result in symbol_results:
        slug = result.symbol.lower()
        symbol_research = research_root / slug
        symbol_models = model_root / slug
        symbol_research.mkdir(parents=True, exist_ok=True)
        symbol_models.mkdir(parents=True, exist_ok=True)
        result.research.write_parquet(symbol_research / "research_frame.parquet")
        result.evaluation.write_parquet(symbol_research / "evaluation_frame.parquet")
        _write_json(symbol_research / "folds.json", _serialize_plan(result.plan))
        result.predictions.write_parquet(symbol_models / "predictions.parquet")
        result.comparison.write_parquet(symbol_models / "comparison.parquet")
        result.selected_predictions.write_parquet(
            symbol_models / "selected_test_predictions.parquet"
        )
        combined_research.append(result.research)
        combined_evaluation.append(result.evaluation)
        combined_predictions.append(result.predictions)
        combined_comparison.append(result.comparison)
        combined_selected.append(result.selected_predictions)
        symbol_manifest[result.symbol] = {
            "research_frame": f"research/{slug}/research_frame.parquet",
            "evaluation_frame": f"research/{slug}/evaluation_frame.parquet",
            "folds": f"research/{slug}/folds.json",
            "predictions": f"models/{slug}/predictions.parquet",
            "comparison": f"models/{slug}/comparison.parquet",
            "selected_test_predictions": f"models/{slug}/selected_test_predictions.parquet",
            "selected_model": result.selected_model,
            "selection_metric": config.models.selection_metric,
            "selection_source": "validation folds only",
            "test_used_for_selection": False,
            "feature_columns": list(result.feature_columns),
            "temporal_audit": dict(result.temporal_audit),
            "paired_hypothesis_evaluation": dict(result.hypothesis_evaluation),
            "test_start_utc": _utc_from_ns(result.plan.test_start_ts_ns),
            "test_end_utc": _utc_from_ns(result.plan.test_end_ts_ns),
        }

    research = pl.concat(combined_research)
    evaluation = pl.concat(combined_evaluation)
    predictions = pl.concat(combined_predictions)
    comparison = pl.concat(combined_comparison)
    selected_predictions = pl.concat(combined_selected)
    research.write_parquet(research_root / "research_frame.parquet")
    evaluation.write_parquet(research_root / "evaluation_frame.parquet")
    predictions.write_parquet(model_root / "predictions.parquet")
    comparison.write_parquet(model_root / "comparison.parquet")
    selected_predictions.write_parquet(model_root / "selected_test_predictions.parquet")

    metrics_root = destination / "metrics"
    _write_json(metrics_root / "predictive_metrics.json", comparison.to_dicts())
    hypothesis_rows = [dict(result.hypothesis_evaluation) for result in symbol_results]
    hypothesis_payload = {
        "schema_version": PUBLIC_PIPELINE_SCHEMA_VERSION,
        "generated_at_utc": generated_at,
        "evidence_tier": PUBLIC_EVIDENCE_TIER,
        "hypotheses": {
            "H0": (
                "The validation-selected model does not improve held-out selection-metric "
                "performance over the historical-prior classifier."
            ),
            "H1_exploratory": (
                "Causal aggregate-trade features improve held-out selection-metric "
                "performance relative to the historical prior."
            ),
        },
        "comparison_contract": (
            "per-symbol validation-selected final-test predictions minus historical-prior "
            "predictions on identical row_id and fixed dependency block"
        ),
        "selection_metric": config.models.selection_metric,
        "delta_definition": "selected_model_minus_historical_prior",
        "bootstrap": {
            "method": "paired fixed-block percentile bootstrap",
            "ci_level": 0.95,
            "samples": config.evaluation.bootstrap_samples,
            "seed_policy": "run_seed + symbol_index*100000 + 20000",
            "block_policy": HYPOTHESIS_BLOCK_POLICY,
            "block_width_trades": 2 * config.features.label_horizon_events,
        },
        "per_symbol": hypothesis_rows,
        "cross_instrument_conclusion": {
            "status": "not_inferred",
            "pooling_performed": False,
            "persistent_alpha_claim_authorized": False,
            "text": CROSS_INSTRUMENT_CONCLUSION,
        },
        "exploratory": True,
        "significance_claim_authorized": False,
        "caveat": HYPOTHESIS_CAVEAT,
    }
    _write_json(metrics_root / "hypothesis_evaluation.json", hypothesis_payload)
    _write_json(metrics_root / "execution_metrics.json", [])
    _write_json(metrics_root / "execution_sensitivity.json", [])
    _write_json(
        metrics_root / "execution_exclusion.json",
        {
            "status": "NOT_RUN",
            "reason": EXECUTION_EXCLUSION_REASON,
            "execution_metrics_rows": 0,
            "execution_sensitivity_rows": 0,
            "pnl_calculated": False,
            "profitability_claim_authorized": False,
        },
    )

    analysis_artifacts = _write_analyses(
        trades=derived_trades,
        symbol_results=symbol_results,
        continuity_audits=continuity_audits,
        config=config,
        stage=destination,
        generated_at_utc=generated_at,
    )
    quality = _quality_payload(public, continuity_audits, generated_at_utc=generated_at)
    _write_json(destination / "quality" / "summary.json", quality)

    market_state = evaluation.select(
        "symbol",
        "decision_ts_ns",
        "decision_trade_id",
        "price",
        "quantity",
        "aggressor_side",
        f"trade_imbalance_w{max(config.features.trade_windows)}",
        f"realized_volatility_w{config.features.volatility_window}",
        pl.lit(PUBLIC_EVIDENCE_TIER).alias("evidence_tier"),
        pl.lit("trade_only_no_book_state").alias("market_state_scope"),
    ).sort(["decision_ts_ns", "symbol", "decision_trade_id"])
    dashboard_path = destination / "dashboard" / "market_state.parquet"
    dashboard_path.parent.mkdir(parents=True, exist_ok=True)
    market_state.write_parquet(dashboard_path)

    data_snapshot = {
        "schema_version": PUBLIC_PIPELINE_SCHEMA_VERSION,
        "mode": "binance_rest_trade_only",
        "source": config.data.source,
        "evidence_tier": PUBLIC_EVIDENCE_TIER,
        "reader_effective_evidence_tier": public.evidence_tier,
        "configured_requested_evidence_tier": config.run.evidence_tier,
        "producer_evidence_policy": (
            "always PUBLIC_SAMPLE_PARTIAL for this retrospective exploratory protocol"
        ),
        "requested_period_utc": {
            "start": config.data.start.isoformat().replace("+00:00", "Z"),
            "end": config.data.end.isoformat().replace("+00:00", "Z") if config.data.end else None,
        },
        "observed_period_utc": {
            "start": public.observed.start_utc,
            "end_inclusive": public.observed.end_inclusive_utc,
        },
        "rows": public.rows,
        "row_bound": public.row_bound,
        "all_requested_ranges_complete": public.all_requested_ranges_complete,
        "canonical_order": list(public.canonical_order),
        "manifest_authority": {
            "policy": "explicit path and caller-supplied SHA-256; no directory discovery",
            "absolute_path": str(public.ingestion_manifest_path.resolve()),
            "project_relative_or_absolute_path": _project_path(
                public.ingestion_manifest_path, config.project_root
            ),
            "sha256": public.ingestion_manifest_sha256,
        },
        "lineage": lineage,
        "symbols": [
            {
                "symbol": item.symbol,
                "rows": item.rows,
                "complete_range": item.complete_range,
                "tick_size": str(item.tick_size),
                "lot_size": str(item.lot_size),
                "observed_start_utc": item.observed.start_utc,
                "observed_end_inclusive_utc": item.observed.end_inclusive_utc,
            }
            for item in public.symbols
        ],
        "transformation": (
            "source normalized rows unchanged; one derived continuity epoch per symbol was "
            "assigned only after contiguous aggregate-ID and nonreversing-clock checks"
        ),
    }
    _write_json(destination / "data" / "manifest_snapshot.json", data_snapshot)

    resolved_config = config.public_dict()
    resolved_config["effective_evidence_tier"] = PUBLIC_EVIDENCE_TIER
    resolved_config["reader_effective_evidence_tier"] = public.evidence_tier
    resolved_config["evidence_policy"] = (
        "retrospective public trade protocol cannot be promoted above PUBLIC_SAMPLE_PARTIAL"
    )
    resolved_config["protocol"] = {
        "path": protocol_path,
        "sha256": protocol_sha256,
    }
    _write_json(destination / "resolved_config.json", resolved_config)

    git_metadata = cast(Mapping[str, Any], generated["git"])
    run_key_inputs = {
        "config_sha256": config.hash,
        "input_manifest_sha256": manifest_hashes,
        "input_data_sha256": data_hashes,
        "protocol_sha256": protocol_sha256,
        "git": {
            "commit": str(git_metadata.get("commit", "UNKNOWN")),
            "dirty": bool(git_metadata.get("dirty", False)),
            "source_tree_sha256": str(git_metadata.get("source_tree_sha256", "UNKNOWN")),
        },
        "seed": config.run.seed,
        "protocol": "public_aggregate_trade_exploratory_v1",
    }
    run_key = _stable_sha256(run_key_inputs)
    generated.update(
        {
            "evidence_tier": PUBLIC_EVIDENCE_TIER,
            "requested_evidence_tier": config.run.evidence_tier,
            "effective_evidence_tier": PUBLIC_EVIDENCE_TIER,
            "reader_effective_evidence_tier": public.evidence_tier,
            "input_manifest_sha256": manifest_hashes,
            "input_data_sha256": data_hashes,
            "ingestion_manifest_path": _project_path(
                public.ingestion_manifest_path, config.project_root
            ),
            "ingestion_manifest_absolute_path": str(public.ingestion_manifest_path.resolve()),
            "ingestion_manifest_sha256": public.ingestion_manifest_sha256,
            "ingestion_manifest_authority": (
                "explicit path and caller-supplied SHA-256; no directory discovery"
            ),
            "protocol_path": protocol_path,
            "protocol_sha256": protocol_sha256,
            "run_key": run_key,
            "run_key_inputs": run_key_inputs,
            "pipeline_schema_version": PUBLIC_PIPELINE_SCHEMA_VERSION,
            "seed": config.run.seed,
            "observed_start_utc": public.observed.start_utc,
            "observed_end_utc": public.observed.end_inclusive_utc,
            "data_availability_clock": "exchange_event_time_proxy",
            "local_receipt_time_available": False,
            "execution_simulated": False,
        }
    )
    _write_json(destination / "provenance.json", generated)

    artifacts = {
        "resolved_config": "resolved_config.json",
        "protocol": protocol_path,
        "data_manifest_snapshot": "data/manifest_snapshot.json",
        "quality_summary": "quality/summary.json",
        "research_frame": "research/research_frame.parquet",
        "evaluation_frame": "research/evaluation_frame.parquet",
        "predictions": "models/predictions.parquet",
        "selected_test_predictions": "models/selected_test_predictions.parquet",
        "model_comparison_data": "models/comparison.parquet",
        "predictive_metrics": "metrics/predictive_metrics.json",
        "hypothesis_evaluation": "metrics/hypothesis_evaluation.json",
        "execution_metrics": "metrics/execution_metrics.json",
        "execution_sensitivity": "metrics/execution_sensitivity.json",
        "execution_exclusion": "metrics/execution_exclusion.json",
        "market_state": "dashboard/market_state.parquet",
        "technical_report": "reports/technical_report.md",
        "executive_memo": "reports/executive_memo.md",
        "model_comparison": "reports/model_comparison.md",
        **analysis_artifacts,
    }
    run_manifest = {
        "schema_version": PUBLIC_PIPELINE_SCHEMA_VERSION,
        "run_id": config.run.name,
        "run_key": run_key,
        "status": "complete",
        "evidence_tier": PUBLIC_EVIDENCE_TIER,
        "data": {
            "mode": "binance_rest_trade_only",
            "source": config.data.source,
            "symbols": list(config.data.symbols),
            "rows": public.rows,
            "row_bound": public.row_bound,
            "all_requested_ranges_complete": public.all_requested_ranges_complete,
            "reader_effective_evidence_tier": public.evidence_tier,
            "configured_requested_evidence_tier": config.run.evidence_tier,
            "observed_start_utc": public.observed.start_utc,
            "observed_end_utc": public.observed.end_inclusive_utc,
            "observed_start_ts_ns": public.observed.start_ns,
            "observed_end_ts_ns": public.observed.end_inclusive_ns,
            "availability_basis": "exchange_event_time_proxy",
            "local_receipt_time_available": False,
            "symbol_coverage": [
                {
                    "symbol": item.symbol,
                    "rows": item.rows,
                    "complete_range": item.complete_range,
                    "observed_start_utc": item.observed.start_utc,
                    "observed_end_inclusive_utc": item.observed.end_inclusive_utc,
                }
                for item in public.symbols
            ],
        },
        "artifacts": artifacts,
        "research": {
            "question": (
                "whether recent observable aggregate-trade direction and size contain "
                "out-of-time information about future trade-price direction"
            ),
            "target": "future_trade_up",
            "label_horizon_trades": config.features.label_horizon_events,
            "evaluation_contract": "separate per-symbol expanding purged walk-forward",
            "selection_contract": "validation folds only; final test never used for selection",
            "bootstrap_contract": {
                "samples": config.evaluation.bootstrap_samples,
                "seeded": True,
                "block_width_trades": 2 * config.features.label_horizon_events,
                "block_policy": "fixed_contiguous_2x_label_horizon",
                "status": "dependence diagnostic, not confirmatory significance",
            },
            "hypothesis_evaluation": {
                "artifact": "metrics/hypothesis_evaluation.json",
                "hypotheses": ["H0", "H1_exploratory"],
                "baseline": HYPOTHESIS_BASELINE,
                "metric": config.models.selection_metric,
                "delta_definition": "selected_model_minus_historical_prior",
                "paired_on": ["row_id", "bootstrap_block"],
                "per_symbol_only": True,
                "cross_instrument_pooling": False,
                "persistent_alpha_claim_authorized": False,
                "exploratory": True,
                "significance_claim_authorized": False,
                "caveat": HYPOTHESIS_CAVEAT,
                "cross_instrument_conclusion": CROSS_INSTRUMENT_CONCLUSION,
            },
            "symbols": symbol_manifest,
            "descriptive_analysis": {
                "manifest": analysis_artifacts["analysis_manifest"],
                "descriptive_only": True,
                "economic_claim_authorized": False,
            },
        },
        "execution_assumptions": {
            "status": "NOT_RUN",
            "reason": EXECUTION_EXCLUSION_REASON,
            "pnl_calculated": False,
            "fills_calculated": False,
            "capacity_calculated": False,
            "profitability_claim_authorized": False,
        },
        "warnings": [
            "PUBLIC_SAMPLE_PARTIAL: results are bounded, retrospective, and sample-specific.",
            "Exchange event time is an availability proxy and not local receipt evidence.",
            EXECUTION_EXCLUSION_REASON,
            "Bootstrap intervals are dependence diagnostics and not significance claims.",
            CROSS_INSTRUMENT_CONCLUSION,
        ],
    }
    _write_json(destination / "run_manifest.json", run_manifest)
    _report_set(destination)
    if _input_lineage(public, config) != lineage:
        raise PublicPipelineError("external input lineage changed while producing the run")
    write_checksum_manifest(destination)
    descriptor = os.open(destination / "_SUCCESS", os.O_CREAT | os.O_EXCL | os.O_WRONLY)
    with os.fdopen(descriptor, "w", encoding="utf-8") as success:
        success.write("complete\n")
    load_run_bundle(destination)