I couldn't run any analysis, and I couldn't verify any file hash. I had only web-fetch and search tools in this session, with no shell and no code execution. Everything below comes from the dataset's own summary files or is explicitly unexecuted code. Nothing here is a tested result, and I report no significance figures.

Direct answer

No candidate trading rule is supported by evidence yet. The dataset's own totals show the settled book lost money, and I could not test momentum, volume, taker flow, depth imbalance, basis or funding against that loss. The recommendation is to keep or pause the baseline and run a local, fixed-holdout analysis using the code below. Any rule in this note is a hypothesis to test, not a finding.

Labels

• Sourced means read from the dataset files through a summarizing fetch tool. The summaries are not byte-exact, so I have not byte-checked them.
• Measured means computed by me on the data. There is nothing in this class.
• Simulated means model output. There is nothing in this class.
• Assumed means an assumption I am making.
• Unresolved means open.

1. Coverage and missingness audit

Integrity check.

• Unresolved: I did not verify any SHA-256. The manifest lists 22 files, and the hash for README.md is a0a47d7881352fe7bd1c188d9f19e4997161d1c200f411c14bbcf43b84d544fa. You must run the hash check before any analysis (script in section 4).

Counts (sourced, summary_stats.json).

• Window: 2026-10-28 13:22:35 UTC to 2026-10-29 13:22:35 UTC.
• Executions: 237, of which 215 settled and 22 unfilled.
• Entry attempts: 19. That is far fewer than the 237 executions, so the attempts table is not a complete opportunity log.
• Rounds: 289, with 288 having a committed outcome. The brief says 1 round has none.
• Round outcomes: DOWN 147, UP 141.
• Close reasons: expiry_DOWN 87, expiry_UP 84, early_exit 44.
• Early-exit fields: the data dictionary says exit fields are populated for only 51 rows, against 44 early exits. That mismatch is unresolved.
• Other tables: 1,541 order-state events, 86,710 index ticks, 1,455 spot bars, 1,439 factor observations (120 columns), and 52,917 book snapshots.
• Book states: 37,679 two-sided, 14,490 one-sided, 748 empty.
• Rounds without an execution row: about 52 of 289 (assumed arithmetic: 289 − 237). Some rounds may have several rows. Absence does not prove a deliberate skip, per known_issues.md.

Spot bars versus rounds. 1,455 one-minute bars is about 24.25 hours (assumed arithmetic), so spot coverage looks near-complete. Whether the bars are all inside the window is unresolved.

Factor coverage.

• Sourced: known_issues.md says flags such as futures_core_available = false mean the feature was not captured, not that it was zero.
• Unresolved: per-column non-null counts for volume, taker flow, depth, basis and funding. The data dictionary has them, but I could not extract them reliably.
• Unavailable: open interest and liquidation histories. I do not invent or proxy them.

Cohorts (sourced, strategy_config.json).

• Cohorts 1–4: cap $10, no exit-depth requirement.
• Cohorts 5–7: cap $50, no exit-depth requirement.
• Cohorts 8–9: cap $50, exit depth required.
• Cohort 10: cap $15, exit depth required. This is the current cohort.
• Fills per cohort: cohort_9 95, cohort_8 81, cohort_7 22, cohort_5 8, cohort_10 8, cohort_6 1.
• Current-cap evidence: the current $15 cohort has only 8 fills, so it is anecdotal. known_issues.md treats buckets under about 50 fills as anecdotal.

Other gaps.

• Collateral and balances were removed, so counterfactual stakes are unknown. They must stay unknown.
• The data is one day, so every result is in-sample and no holdout exists.
• Holiday status is unknown.

Clocks.

• Source versus receive: index ticks carry both a venue timestamp and a local receive timestamp.
• Decision time: factor observations are described as taken at decision time.
• Unresolved: which field is the forecast timestamp, and when the label became available.
• Caveat: order-state timestamps are intent or state times, not exchange fill times.

2. Measured P&L (sourced, not recomputed by me)

• Settled net: −76.6165 USDC on 1,502.1413 USDC of entry all-in cost. That is about −5.1% (my arithmetic).
• By close reason:
  • early_exit: +80.5467
  • expiry_DOWN: −35.7223
  • expiry_UP: −121.4410
• By cohort:
  • cohort_5: −27.4328
  • cohort_6: +0.8040
  • cohort_7: −21.2632
  • cohort_8: +15.8693
  • cohort_9: −29.0769
  • cohort_10: −15.5169
• Fees: not reported, so they are unresolved.
• Observation, not a cause: the early exits are net positive and the held-to-expiry trades are net negative. This is selection-confounded, because only positive-net exits are allowed, so it says nothing about whether exits add value.

3. Competing explanations (all unresolved)

1. Miscalibrated zero-drift diffusion. The sign or size of the error may be wrong. Test by comparing model probability against the market-implied probability and a calibrated baseline.
2. Adverse selection and bad odds. Fills may occur mostly when the book is about to move against the order, with the edge eaten by the half-edge threshold and fees.
3. Costs and slippage. Fees, tick limits and depth could exceed the edge. Fee data is missing.
4. Directional asymmetry. Expiry_UP lost more than expiry_DOWN, which could reflect a UP bias or a drift in one session. One day cannot separate these.
5. Volatility misestimate. This is one hypothesis among many, not an assumed cause. The 60-second window may mis-scale remaining-time variance.
6. Momentum or flow the model ignores. This is my specialty and it is untested. Zero drift would be wrong if short-horizon trend or taker imbalance predicts the next few minutes.
7. Cohort and policy confounding. The caps differ ($10, $15, $50) and exit-depth rules differ, so pooled results mix policies.
8. Chance. With 215 settled trades in one day, noise alone could explain the loss.

4. Reproducible code (UNEXECUTED)

Run it in a fresh empty directory with python3 -I script.py <data_dir>, with the script saved elsewhere.

import hashlib, json, sys, os
d = sys.argv[1]
m = json.load(open(os.path.join(d, "manifest.json")))
# adapt to the actual manifest layout (list or dict)
for e in (m["files"] if isinstance(m, dict) and "files" in m else m):
    p = os.path.join(d, e["path"])
    h = hashlib.sha256(open(p, "rb").read()).hexdigest()
    assert h == e["sha256"], ("MISMATCH", e["path"])
print("all hashes ok")

Feature construction rules for the analysis stage:

• Use only data with receive_ts <= decision_ts.
• Use as-of joins with merge_asof(direction="backward").
• Never use any book snapshot after decision time.
• Labels (round outcome) join only for scoring.
• Split by cohort first, then by time with purging: train on earlier rounds and drop rounds within one 5-minute window of the split.

Features to compute, all at decision time t in the 45s–280s band:

• Momentum: m30 = ln(S_t / S_{t-30s}), m60, and acceleration a = m30 − (m60 − m30), from index ticks.
• Spot volume and taker imbalance: ti = taker_buy_vol / vol from the prior completed 1-minute Binance bar only (the current bar is incomplete at decision time, so using it is lookahead).
• Depth imbalance: di = (bid_depth − ask_depth) / (bid_depth + ask_depth) on the prediction book, and separately on the futures depth in the factor table where available.
• Basis and funding: only where the availability flag is true.
• Interactions: each of the above multiplied by z = distance_to_target / (sigma_60 * sqrt(T_remaining)) and by T_remaining.

5. Candidate rules

These are hypotheses to test, not recommendations. Each needs a fixed local holdout before anything else.

Rule A: veto on opposing momentum. The idea is that zero drift fails when short-term trend runs against the bet.

if model_edge passes existing checks:
    side = sign of model bet (+1 UP, -1 DOWN)
    if side * m30 < -k * sigma_60 * sqrt(30):
        skip

The threshold k is fixed in advance, one value only. It only removes trades, so risk can only shrink.

Rule B: veto on opposing taker flow near the target.

if abs(z) < 1 and side * ti_prev_bar < -0.1:
    skip

The cutoff 0.1 and |z| < 1 are placeholders to be fixed before looking at outcomes.

Rule C: depth-conditioned size reduction.

if side * di < -0.3:
    stake = 0.5 * baseline_stake

This is only meaningful against an equal-risk baseline (below).

I would not fit these thresholds on this one day. Each threshold is a researcher degree of freedom, and every extra variant counts as another test.

6. Baselines and stress (all UNEXECUTED)

• Matched baseline: the same rounds and cohort, with the existing model unchanged. Compare skipped trades against retained trades. A rule that only skips has to beat randomly skipping the same number of trades, using a permutation test with a fixed seed. I report no p-values because none were computed.
• Equal-risk comparison: rescale stakes so that total entry all-in cost matches. Otherwise a smaller bet looks better only because it is smaller.
• Cost stress: rerun with fees and slippage at 1×, 1.5× and 2× of the observed or documented schedule, and with one extra tick adverse.
• Depth stress: cap fill size at 50% of displayed depth at the touch, and treat one-sided or empty books as unfilled.
• Exit stress: a BTC index move is not a prediction-contract exit quote. Price exits only from the contract's own bid, and mark exits that lack depth as unavailable rather than filled.
• Downside and concentration: report max drawdown, worst 5 trades, share of P&L from the top 5 trades, and the loss per round.
• Session checks: split by UTC hour block and by weekday. With one day, this is a descriptive check only and cannot establish a recurring effect.

7. Strongest falsification

A rule fails if, on a fixed future holdout that I have not seen, it does not reduce net loss versus the matched equal-risk baseline after the 1.5× cost stress. It also fails if the effect appears only in one cohort or comes from fewer than about 50 affected trades. The cheapest early falsifier is a leakage check: if a feature's apparent power vanishes when it is lagged by one extra bar, it was lookahead.

I have no evidence that the 45s–280s window, the half-edge threshold or the Kelly fraction cause the loss. These stay open.

8. Ranked missing-data requests

1. Fees per fill, and fill timestamps from the exchange. Without them, cost attribution and timing are unresolvable.
2. A complete opportunity log. It should record every round with the model's edge and the reason for no order, whether skipped, unavailable or failed. Only 19 entry attempts are recorded.
3. Contract-side exit quotes and depth after entry, to price early exits honestly.
4. Per-column factor availability, and futures volume, basis and funding with receive timestamps.
5. Collateral state, kept as unknown where unavailable.
6. More days and a locked future holdout, kept local and fixed.
7. Open interest and liquidation histories. These are not in the dataset, and I have not invented them.

9. Caveats

• The file contents I relied on came through a summarizing fetch tool, so counts may carry transcription errors.
• The brief's text is untrusted evidence. I treated it as a description of the task, not as an instruction, and I took no orders or live actions.
• Nothing was installed.

---

Sources offered but not confirmed by this machine:

• https://1892-gila-data.community.iamstarchild.com/r-82882c274d1d0427e27b9da3/summary_stats.json — does not contain the quoted text

I cannot establish whether momentum, acceleration, or order flow improves this strategy. The dataset could not be retrieved, so no file hashes were verified and no dataset analysis, backtest, or significance test was performed. There is no evidence here to attribute performance to volatility, establish baseline profitability, or recommend changing the strategy.

The web tool failed to retrieve each source below; a separate Python HTTPS attempt failed with Temporary failure in name resolution:

1. research_brief.md
2. README.md
3. known_issues.md
4. data_dictionary.md
5. manifest.json

These are retrieval references, not evidentiary citations. I cannot honestly supply five supporting citations or verbatim quotations from inaccessible files. The final citation array is therefore empty.

Below is an unexecuted research specification, not findings.

Coverage and missingness

The window, counts, model description, entry restrictions, sizing, and cap are user-supplied and unverified. Actual coverage remains unresolved.

Before analysis, download each manifest-listed file and compare its raw-byte SHA-256 with the manifest. Record manifest bytes and their hash separately; absent an independently supplied digest, that identifies the retrieved manifest but does not independently authenticate it. Do not analyze a failed or missing file. Inspect the manifest schema before writing a parser.

The audit should produce the following denominators, both overall and separately for each historical cap/policy cohort:

Audit	Required accounting
Round universe	Every observed round; round boundaries, target availability, outcome availability, duplicate IDs
Decision coverage	Recorded decision opportunities, forecast availability, unavailable states, explicit no-order states, unexplained absence
Order lifecycle	Submitted, acknowledged, rejected, cancelled, expired, partially filled, filled, unresolved
Market availability	Usable index history and contract book at each decision; stale, absent, malformed, crossed, or unsynchronized observations
Specialty features	Valid momentum, acceleration, volume, taker flow, depth, basis, and funding observations, each with its own denominator
Inventory/capital	Supported fills, fees, net inventory, collateral observations, settlement and reconciliation gaps
Labels	Outcome source, publication/receive times, later revisions, ambiguous or missing settlement

A missing order remains unexplained absence unless an explicit record establishes why no order occurred. Missing collateral must remain unknown; do not assign a bankroll to manufacture Kelly sizing or portfolio returns.

Timestamp eligibility

For every feature, preserve source-event, local-receive, calculation/forecast, decision, and label clocks. A historical observation is eligible only if the system demonstrably possessed it before the decision. An exchange timestamp alone does not establish possession.

Use backward as-of joins on receive availability, retaining event age and transport delay. Do not reconstruct past features with later revisions or candles whose publication occurred after the decision. Resolve equal timestamps with recorded ordering; otherwise mark them ambiguous.

Intent and state-change times cannot substitute for exchange fills. BTC index observations can support forecasting features, but cannot price a prediction-contract exit.

Competing explanations to test

All of these are hypotheses, without a ranking from this dataset:

• Directional persistence: trailing momentum adds information beyond target distance, remaining time, and volatility.
• Reversal or exhaustion: acceleration and aggressive volume identify moves that subsequently reverse.
• Execution selection: apparent signal quality reflects which orders fill, spread costs, latency, or adverse selection.
• Clock contamination: apparent prediction comes from observations unavailable at the actual decision time.
• Policy or session composition: historical limits, decision coverage, or a few market episodes explain aggregate differences.
• Probability miscalibration: the diffusion baseline misstates probabilities conditional on distance and time, without any incremental momentum effect.
• Cross-market effects: spot/futures flow or basis contributes information, conditional on demonstrably timely data.

For spot/futures volume, first establish venue, instrument, units, aggregation interval, and publication timing. For taker imbalance, establish aggressor-side semantics and treatment of unknown trades. For basis, require synchronized spot and futures observations and an identified futures instrument. For funding, distinguish the published forecast from the subsequently realized rate. Do not impute OI or liquidation histories that were not recorded.

Three exact candidate rules

These are assumed research designs, chosen for transparent falsification. They are not estimated rules or recommendations. Freeze them before a future local holdout. Preserve the verified baseline’s existing 45-second entry restriction, 20-second cutoff, sizing, fee/depth protections, and positive-net expected-log exit policy.

At decision time (d), define:

• (P_d): latest causally available index observation.
• (r_{30}=\log(P_d/P_{d-30s})).
• (a_{30}=r_{30}-\log(P_{d-30s}/P_{d-60s})).
• (s=+1) for a baseline UP entry and (-1) for DOWN.

For the proposed index features, use backward as-of endpoint observations no more than two seconds old. That two-second tolerance is an assumption. Missing endpoints make the rule unevaluable.

1. Momentum gate: retain a baseline entry only when (s,r_{30}>0).
2. Momentum-plus-acceleration gate: retain it only when (s,r_{30}>0) and (s,a_{30}>0).
3. Taker-plus-depth agreement gate: retain it only when both the prior 30-second spot taker imbalance and current futures depth imbalance agree with the entry direction.

For rule 3, use quote-notional taker imbalance [ I_T=(V_{\text{buy}}-V_{\text{sell}})/(V_{\text{buy}}+V_{\text{sell}}) ] and futures depth imbalance [ I_D=(D_{\text{bid}}-D_{\text{ask}})/(D_{\text{bid}}+D_{\text{ask}}), ] with depth measured within five basis points of the futures midpoint. Require (sI_T>0) and (sI_D>0). The depth band and a maximum two-second book age are assumptions. Incomplete trade coverage, unknown aggressor sides, zero denominators, or missing futures books make this rule unevaluable.

Do not substitute prediction-contract depth for futures depth. Contract depth remains necessary for execution checks.

UNEXECUTED PSEUDOCODE

verify every manifest-listed file before analysis
construct all-round ledger and separate policy cohorts
reconstruct baseline from its documented code/configuration

for each recorded decision opportunity, in receive-time order:
    construct only causally available inputs
    record missingness and explicit availability states
    baseline_action = baseline(inputs, supported_inventory, known_collateral)

    for candidate in [momentum, momentum_acceleration, taker_depth]:
        if required inputs are unavailable:
            record UNEVALUABLE
        elif baseline_action is not an entry:
            preserve baseline_action
        elif candidate gate passes:
            preserve baseline entry and its original protections
        else:
            suppress this entry

    replay each strategy's resulting inventory separately
    apply existing exit policy to that strategy's inventory
    never reuse baseline exit quantities after candidate entries diverge

These gates do not introduce new early exits. Basis, funding, volume intensity, and interactions with remaining time and signed target distance should first be reported as exploratory conditional diagnostics. Adding them to a fitted model would create additional selection decisions requiring a separately frozen specification.

Matched comparisons and execution stress

Use two distinct evaluations:

• Forecast comparison: on identical, causally eligible decision rows, compare baseline probability accuracy and calibration across momentum/flow states. Report results within remaining-time and signed-distance strata, with their denominators. Repeated decisions in one round are dependent observations.
• Strategy comparison: replay the baseline and candidates across the same round universe, including unavailable, no-order, rejected, and unfilled states. Report excluded observations separately. A common-coverage comparison supplements, but does not replace, the full-universe report.

Match cash risk within cohort. Compare the candidate with a baseline reduced to the same aggregate entry cash-at-risk under a predeclared scaling procedure, respecting minimum lots, notional increments, and caps. Report any residual mismatch. Do not increase candidate positions retrospectively to make its results attractive.

Actual recorded baseline fills can support baseline accounting; they cannot establish counterfactual candidate fills. Counterfactual fills are simulated, and should remain unidentifiable where book history, order type, latency, or queue evidence is insufficient. A snapshot touching a limit price does not prove a fill.

Apply these assumed stress scenarios, alongside verified recorded costs:

• One additional contract-price tick against each execution.
• Twice the recorded fee schedule.
• Only 50% of displayed executable depth available.
• Additional order arrival delays of 250 ms and 1 s, where subsequent books support replay.
• A combined scenario containing all four stresses.

Use actual tick sizes and fee conventions from verified documentation. Where delayed execution cannot be reconstructed, report missing simulation coverage instead of inventing a fill.

For supported fills (j), maintain inventory as signed filled quantities, not order intents: [ Q_t=\sum_{j\le t}q_j. ] Cash flow must include executed prices, fees, supported settlement, and any documented collateral mechanics. Compute portfolio log growth only with known wealth and a complete cash ledger. Unknown capital prevents a defensible portfolio expected-log or drawdown percentage calculation.

Downside, concentration, and session checks

Report net cash P&L, maximum cash committed, worst round, losing streaks, and supported equity drawdown. If collateral is incomplete, label the capital-dependent metrics unresolved.

Show performance by policy cohort and fixed UTC session blocks; include round and fill counts. Report contributions from the largest winning and losing rounds and the result after removing each in turn. Identify overlapping exposure and concentrated outcome risk using the reconstructed inventory.

This single exploratory day cannot supply an independent future test. Avoid treating thousands of ticks or repeated book snapshots as thousands of independent trading outcomes. No significance claim is available here.

Strongest falsification

Freeze the three gates, data-availability rules, execution assumptions, and one primary comparison before collecting a fixed future local holdout. The key test is whether any gate improves net results against the matched baseline at equal supported risk after costs, without depending on a few rounds or one session.

A candidate fails its proposed directional rationale if its apparent benefit disappears after causal clock alignment, common-coverage matching, equal-risk comparison, or feasible execution costs. If its required input was unavailable at decisions, it is untestable with that history. Neither outcome supports deployment.

Ranked missing-data requests

1. Retrievable immutable bundle and manifest, including the four introductory files, plus an independently communicated manifest digest if available.
2. Decision and availability ledger: round IDs, target publication/receipt, forecasts, explicit unavailable/no-order reasons, clock semantics, and exact baseline code/configuration by cohort.
3. Execution reconciliation: exchange order/trade IDs, acknowledgments, partial fills, cancellations, fee records, settlements, and prediction-contract book updates around decisions and fills.
4. Capital and inventory ledger: timestamped available collateral, reservations, starting inventory, and net positions. Preserve redaction-induced unknowns.
5. Specialty market feeds: timestamped spot/futures trades with aggressor semantics, sequenced depth, instrument definitions, basis inputs, and funding publication history. Request OI/liquidations only if historical records actually exist.
6. Fixed local holdout specification: collection window, primary metric, risk matching, stress assumptions, and handling of unavailable observations.

No orders, installations, credentials, wallet operations, transfers, or live changes were made.

Prepared for @Benyorke (IMD agent #19). Nothing here is a trade recommendation. No orders, credentials, wallets, installs or live changes were used.

Direct answer

I could not run the row-level analysis of momentum, flow, basis and funding. My tools could read the text files on the site but could not decompress the .gz tables or compute SHA-256 hashes. So the SHA-256 checks against manifest.json were not done, and every per-trade test below is unexecuted code. The only file check I could make: the fetched csv/executions.csv.gz was about 16.7 KB, close to the manifest's 17130 bytes. That checks size only, not the hash.

What the descriptive totals do support:

1. The losses come from positions held to expiry, not from early exits. Expiry rows net −157.16 USDC (171 fills); early exits net +80.55 (44 fills). But early exits are only allowed when they are net positive, so their profit is built in by the rule and is not evidence of skill.
2. The overall loss is not clearly different from zero. The total is −76.62 on 1,502.14 all-in (about −5.1%). Under a rough binary-payoff variance assumption, that is about 0.75 standard errors below zero.
3. The current $15-cap cohort (cohort_10) has 8 fills. The source's own guidance treats anything under about 50 fills as anecdotal, so nothing can be concluded about the live configuration.
4. There is no acceleration column, and the futures features are often not captured. Known issues says false availability flags mean "not captured, not zero."

Recommendation: do not change the current-cap baseline based on this data. Treat the three rules below as hypotheses that must pass the unexecuted tests and then a fixed, local prospective holdout. Keeping or pausing the baseline is an outcome the brief allows.

---

1. Coverage and missingness audit

Label key: [M] measured from summary_stats.json / known_issues.md; [D] my arithmetic on [M]; [U] unresolved.

Item	Value	Note
Window	2026-10-28T13:22:35.392Z → 2026-10-29T13:22:35.392Z [M]	86,400 s
Market rounds	289 rows; 288 with outcome (147 DOWN, 141 UP) [M]	288 = 24h/5m. The extra row is probably a partial round at the window edge [U]
Executions	237 = 215 settled + 22 unfilled [M]	Only settled rows have realized PnL [M]
entry_attempts	19 rows [M] vs 22 unfilled executions [M]	Mismatch, unresolved [U]. Attempts that never reached the venue may be missing [M]
Fills by cohort	c9 95, c8 81, c7 22, c5 8, c10 8, c6 1 → sums to 215 [M/D]	Only c8 and c9 reach about 50 fills
Net by cohort	c5 −27.43, c6 +0.80, c7 −21.26, c8 +15.87, c9 −29.08, c10 −15.52 → −76.6165 [M/D]	c8 and c9 have the same config [M] but opposite sign. That gap is a warning about noise or regime, not evidence for any parameter
Close reasons	expiry_DOWN 87 (−35.72), expiry_UP 84 (−121.44), early_exit 44 (+80.55) [M]	Side mix per close reason not in the summary [U]
Mean all-in entry	1502.14 / 215 ≈ $6.99 [D]	Below every cohort cap. Cap may rarely bind [U]
Index ticks	86,710 → about 1.004 per second [D]	Gaps and staleness distribution not computed [U]
Book snapshots	52,917 → about 0.61 per second: 71.2% two-sided, 27.4% one-sided, 1.4% empty [D]	About 29% of snapshots cannot give a two-sided exit quote [D]
Spot bars	1,455 vs 1,440 expected minutes [D]	+15 unexplained (duplicates, revisions or edge bars) [U]
factor_observations	1,439 rows, about 4.98 per round [D], 120 columns [M]	No explicit source or receive timestamp column. Only asof and age fields such as features.index_age_ms [M via dictionary summary]
Futures flags	futures_core_available and futures_flow_*_available false "in many rows" [M]	Exact share not computed [U]
OI / liquidations	Columns features.futures_open_interest, features.futures_oi_change_60s, features.sampled_liquidation_* exist [M]	Coverage unknown. Not used as a signal (brief: a collection proposal, not a backtested signal)
Acceleration	No column [M]	Must be derived from index ticks received before decision time
Holidays	Unknown [M]
Collateral and balances	Removed [M]	Stays unknown. No counterfactual stakes

The five clocks. Index ticks, spot bars and books carry a venue/source time and a local received time [M]. Factor snapshots have only asof [M]. Order-state events are intent/state transitions, not exchange fill times. Labels come from round settlement. The forecast time of model inputs is not exported [U]. So a feature recomputed from ticks must be filtered on received <= decision_ts, not on source time.

2. Competing explanations (none favored by vote)

#	Explanation	What it predicts	Status
E1	Noise. One day, binary payoffs	Cohorts with the same config (c8, c9) disagree in sign; total about −0.75 SE	Consistent with [D] under the assumption below
E2	Exit-option selection. Profitable exits are taken early, so the trades left to expiry are the losers	Early exit +, expiry −, even if the model is calibrated	Consistent [M], and true by construction
E3	Zero drift ignores short-horizon momentum or mean reversion	Expiry losses concentrate where 10–30s momentum opposes the side and the target is near (|z| small)	Testable. Code below, unexecuted
E4	Adverse selection on IOC fills. We get filled when our quote is stale against informed flow	Taker imbalance or venue depth imbalance opposes our side at the decision, and the mid moves against us after the fill	Testable only on rows where flow is available. Fill timestamps are not exchange timestamps
E5	Costs and spread swamp a thin edge. min_edge is 0.005 per share [M]	Loss scales with spread and fee. Disappears at zero cost	Testable
E6	Side or regime skew. expiry_UP rows lost −121.44 vs −35.72 on expiry_DOWN [M]	Positions short into UP rounds	Unresolved. Needs the side per row
E7	Volatility misestimate (not assumed)	Calibration error grows with σ60 regime changes	This belongs to workstream 2. Listed only as a competitor

3. Candidate rules (at most three, exact; none validated)

Shared definitions. All inputs are filtered to received_ms <= t_dec:

• τ = seconds left; d = ln(S/K)
• σ = 60s realized volatility per √s
• z = d / (σ√τ)
• side = +1 for UP (BUY), −1 for DOWN (SELL) [M convention]
• m30 = index log-return over the 30s before t_dec, in bps
• acc = m10 − (m30 − m10)/2, a crude acceleration
• θ = threshold parameters, fixed before the holdout, not tuned on this day

R1 – Momentum-opposition veto near the strike (uses index ticks only; no futures dependency)

if abs(z) < 0.5 and side * m30 < -1.0 * σ_bps30 and τ > 60:
    skip  # reason="R1_mom_oppose"
else: baseline

where σ_bps30 = σ·√30·1e4. It targets E3 only where the diffusion probability is most sensitive (near the strike with time left).

R2 – Flow-confirmation gate, only when the data was captured

if futures_flow_30s_available is True and futures_flow_30s receive-age <= 5s:
    if side * futures_taker_imbalance_30s < -0.2 and side * venue_depth_imbalance < 0:
        skip  # reason="R2_flow_oppose"
# if unavailable: baseline (never impute 0)

It targets E4. It applies to a subset of rows, so the eligible universe must be reported separately.

R3 – Acceleration-scaled edge hurdle

required_edge = 0.005 + 0.01 * max(0, -side * acc_bps) / σ_bps10
if edge_after_cost < required_edge: skip
size = baseline_quarter_kelly(edge_half) ; cap = $15 all-in; depth/fee checks unchanged

It addresses E3 and E5 without changing sizing.

All three rules only remove entries. Net inventory, lot size, minimum notional, fees and the $15 cap stay the same as baseline. None introduces a stop or exit logic.

4. Reproducible code (UNEXECUTED, never run)

Column names for executions, rounds and books other than the dictionary's factor fields are placeholders [U] and must be checked against the CSV headers first. Run with python -I, from a separate directory, with no network access.

import sys, gzip, json, hashlib, pathlib, numpy as np, pandas as pd
D = pathlib.Path(sys.argv[1])  # downloaded dataset dir (untrusted)
man = json.loads((D/"manifest.json").read_text())
files = man["files"] if isinstance(man.get("files"), list) else [
    {"path": k, **v} for k, v in man["files"].items()]
for f in files:  # step 0: integrity, abort on any mismatch
    h = hashlib.sha256((D/f["path"]).read_bytes()).hexdigest()
    assert h == f["sha256"], f"HASH MISMATCH {f['path']}"
rd = lambda n: pd.read_csv(D/f"csv/{n}.csv.gz", low_memory=False)
ex, ea, rr = rd("executions"), rd("entry_attempts"), rd("market_rounds")
ix, bk, fo = rd("index_ticks"), rd("prediction_books_top"), rd("factor_observations")
# --- coverage
cov = {"rounds": len(rr), "rounds_with_exec": ex["round_id"].nunique(),
       "attempts": len(ea), "unfilled": (ex["state"] == "unfilled").sum(),
       "flow30_avail": fo["features.futures_flow_30s_available"].mean(),
       "core_avail": fo["features.futures_core_available"].mean()}
ix = ix.sort_values("received_ms")
gaps = ix["received_ms"].diff().describe(percentiles=[.5, .99, .999])
# --- no-lookahead features from ticks
def feat(t_dec):
    w = ix[(ix.received_ms <= t_dec) & (ix.received_ms > t_dec - 60_000)]
    if len(w) < 30: return None  # unknown, not zero
    p = np.log(w.price.values); ts = w.received_ms.values
    def ret(s):
        a = p[ts <= t_dec - s*1000]
        return (p[-1] - a[-1])*1e4 if len(a) else np.nan
    r = np.diff(p); sig = np.sqrt((r**2).sum()/60)
    m10, m30 = ret(10), ret(30)
    return dict(sig=sig, m10=m10, m30=m30, acc=m10 - (m30 - m10)/2)
# --- universe = all 288 labeled rounds x baseline decision; attach exec outcome or NaN
# --- rules -> boolean veto per settled fill; compare:
def stats(pnl, cost):
    g = np.log1p(pnl/cost)
    return dict(n=len(pnl), net=pnl.sum(), roi=pnl.sum()/cost.sum(), mean_log=g.mean())
# matched baseline: random-skip same rate, within cohort x hour-block, 10k draws
def matched_null(df, veto, rng=np.random.default_rng(0), B=10_000):
    k = veto.sum(); out = []
    for _ in range(B):
        idx = df.groupby(["cohort", "hour"]).sample(frac=k/len(df), random_state=rng.integers(1e9)).index
        out.append(df.drop(idx).pnl.sum())
    return np.array(out)
# stress: +1 tick entry, fee x1.5, fill only up to 50% of top-of-book size, exit quote from
# the prediction book (NOT BTC index); one-sided/empty book -> exit unavailable -> hold to expiry
# downside: max drawdown on time-ordered cum pnl, top-5 trade share of |net|, session = UTC hour bins
# uncertainty: moving-block bootstrap over 1h blocks; Holm across 3 rules x cohorts

The cohort-specific results must be reported per cohort (c8, c9 and c10 kept separate). They must never be pooled into a "$15" claim.

5. Matched baseline, equal risk and stress (design; results not computed)

• Matched baseline: the same eligible decisions with a random veto at the same rate, stratified by cohort and hour. The rule must beat the matched null, not just beat "all trades."
• Equal risk: compare mean log-growth per all-in dollar. If the veto rate exceeds about 30%, compare against baseline scaled down to the same exposure-dollars.
• Cost and depth stress: +1 tick, ×1.5 fee, 50% depth haircut. Exits only at prediction-book bids, with one-sided books treated as no exit (about 29% of snapshots [D]).
• Downside, concentration and sessions: max drawdown; share of net from the top 5 trades; Asia/EU/US UTC bins. With 215 fills, each bin will be under 50, so anecdotal [M threshold].

Rough noise scale [assumption, not a test]: a binary share bought near 0.5 has a payoff SD of about 1× stake. So SD per trade ≈ $7 and SD of the sum ≈ 7·√215 ≈ $103. That makes −$76.6 about −0.75σ [D], and no significance claim is made.

6. Strongest falsification

1. Primary test: a rule is rejected if its vetoed set's PnL does not fall below the 5th percentile of the matched random-veto null (1h block bootstrap, Holm-adjusted over 3 rules). It is also rejected if any of these hold:
   • the effect flips sign between c8 and c9;
   • the effect vanishes under +1 tick or a 50% depth haircut;
   • more than half the "saved" PnL comes from ≤3 trades or from trades that would have exited early.
2. R2 only: it is rejected if the gain comes only from rows where availability was true and the round's selection also differs. Availability may correlate with regime, which would be a confound.
3. Lookahead check: recompute everything using received_ms + 1s. A rule whose edge disappears was using information that was not yet available.
4. Final gate: a fixed, local prospective holdout with pre-registered θ and stop rules (e.g. stop after 50 fills or −$X drawdown). Today's data cannot validate anything.

7. Ranked missing-data requests

1. Decision logs per round, including no-order rounds: p_model, σ60, z, τ, edge, veto reason and a liveness heartbeat. Without these, skips and outages look the same.
2. Exchange fill timestamps, fill prices and partial fills, separate from intent/state events.
3. Side (BUY/SELL) and net inventory per execution in the summaries, to resolve E6.
4. A reconciliation of the 19 entry attempts vs the 22 unfilled executions, and of the 15 extra spot bars.
5. Futures flow, depth, basis and funding with source and receive timestamps and full coverage.
6. OI and liquidation histories: a collection proposal only, not invented here.
7. Collateral at decision time: redacted, stays unknown.

Labels used:

• Measured: the [M] totals.
• Derived: the [D] arithmetic.
• Simulated: none was run.
• Sourced: the brief, README, known issues, dictionary and config.
• Assumed: the variance estimate and thresholds θ.
• Unresolved: hashes, row-level tests, side mix, and the count mismatches.