Direct answer: I could not verify the manifest hashes or run any analysis, so I have no measured evidence that waiting, abstaining or any session or macro window beats the current baseline. The numbers below come from the published files and are descriptive only. Everything else is a plan or unexecuted code.

I had no shell in this run. I read research_brief.md, known_issues.md, data_dictionary.md, manifest.json and summary_stats.json. I did not open README.md or strategy_config.json. I could not download the gz files or compute any SHA-256, so I did no row-level analysis. The pages came back through a summarizing fetcher, and I read known_issues.md and parts of the dictionary and brief from the saved raw text.

1. Coverage and missingness audit

Measured, from the published summaries (not recomputed):

• Row counts: 237 executions, 289 rounds, 86,710 index ticks, 52,917 book snapshots, 19 entry attempts, 1,541 order-state events and 1,439 factor rows.
• Execution states: 215 settled and 22 unfilled. Only settled rows have realized PnL.
• Settled PnL: -76.6165 USDC on 1,502.14 USDC of all-in entry value, about -5.1%.
• By close reason: early exit +80.55 (44 fills), expiry DOWN -35.72 (87), expiry UP -121.44 (84). The early-exit gain is conditional on the exit rule only firing when net is positive. It is a selected subset, not evidence that exits create edge.
• By cohort: cohort 9 was -29.08 on 95 fills, cohort 8 +15.87 on 81, cohort 6 +0.80 on 1, and cohorts 5, 7 and 10 negative. Cohorts must stay separate because they have different limits.
• Outcomes: 147 DOWN and 141 UP among 288 rounds with a recorded outcome. One round has no committed outcome.
• Books: 37,679 two-sided, 14,490 one-sided (about 27%) and 748 empty snapshots.
• Missing features: known_issues.md says futures-flow flags "are false in many rows; those features were not captured, not zero." Calendar fields are populated on only about 515 of 1,439 factor rows, and holiday status is unknown.
• Decision-time gap: there is no dedicated decision or forecast timestamp. factor_observations.asof is the closest to a forecast clock. executions.created is an intent or state record, not a fill time.

Unresolved:

• How many of the 289 rounds had a decision opportunity.
• Why 52 rounds have no execution row. 237 executions in 289 rounds, with several cohorts, may also mean multiple rows per round.
• Collateral and margin balance. No collateral field exists; the dictionary shows only entry_all_in, min_notional and margin_mode. Treat collateral as unknown.
• Whether the 19 entry attempts are complete. known_issues.md says attempts that never reached the venue may be missing.
• Prediction-contract exit quotes for early exits. The BTC index is not an exit quote.

2. Competing explanations for the loss (none tested)

1. No edge, plus fees and spread. The zero-drift model may simply not beat the market price.
2. Adverse selection at fill. Fills may come only when the book has moved against the model. This needs book snapshots around created.
3. Bad calibration in the tails. The diffusion model may be overconfident near the target at 20–45 seconds.
4. Volatility misestimation. Possible, but the brief says not to assume it.
5. Cohort composition. Cohort 9 (95 fills) drives most of the loss, so this may be a parameter effect rather than a time effect.
6. Exit asymmetry. There is no stop-loss, only positive-net early exits. This truncates winners and leaves losers to expire.
7. Noise. With 215 fills and roughly a ±1 USDC per-trade scale, -76.6 may not be distinguishable from zero. I have not computed this.

3. Entry-window, waiting and abstaining specialty

Timing is tracked as separate clocks. All stored times are UTC epoch ms.

• Source time is ts.
• Receive time is received.
• Forecast time is the factor asof.
• Decision time is the created record, which is intent time and not a fill time.
• Label time is result_committed_at or settled_at.

A feature at decision time t may use only rows with received ≤ t. Joining on source ts alone is lookahead if receive latency is nonzero.

Sessions (my knowledge, not from the dataset; verify before use).

• London left DST on 2026-10-25, so its open is 08:00Z. Tokyo opens at 00:00Z and Hong Kong at about 01:30Z.
• New York is still on EDT until 2026-11-01, so its open is 13:30Z and its close about 20:00Z.
• The window 13:22Z to 13:22Z contains one US open (13:30Z on Oct 28) and one Asia and one Europe session.
• The next US open at 13:30Z on Oct 29 falls after the window ends. The dictionary's us_open_near15 flag is populated on only 515 rows.
• This is one day with no recurring-session evidence and no known macro releases, because holiday and macro status are unknown. Session results will be anecdotal at under 50 fills per bucket.

4. Candidate rules (up to three, all unvalidated)

R1. Abstain when the book is thin or one-sided.

at decision t (earliest 45s, cutoff 20s):
  book = latest snapshot with received <= t
  if book.state != "two_sided" or book.quality != "ok": abstain
  if protected_depth(book, side, size) < size or net_edge < half_edge_threshold: abstain

• Addresses explanations 2 and 6.
• Test: equal-risk comparison against baseline on the same rounds.

R2. Wait-for-edge instead of earliest entry.

for t in 45s..(expiry-20s), every snapshot:
  if net_edge(t) >= threshold and depth_ok(t): enter once, then stop
  else continue; if no t qualifies: abstain

• Compares the first-qualifying time against the 45s entry on rounds where both are observable.
• It must not use any information after t.

R3. Late-window abstention near expiry.

if remaining_seconds < X and abs(distance_to_target) < k * sigma60 * sqrt(remaining): abstain

• X and k are fixed before any holdout.
• Pick them from a coarse grid fixed in advance, and count every cell tried.

I recommend R1 first. It is the simplest, it needs only data the system already records, and it removes trades rather than adding a signal. R2 and R3 add free parameters that one day cannot support. A session-gated rule would be pure overfitting on this data, so I propose none.

5. Code (unexecuted)

# run: python3 -I audit.py DATA_DIR   (script lives outside DATA_DIR)
import sys, gzip, hashlib, json, csv, os
d = sys.argv[1]
man = json.load(open(os.path.join(d, "manifest.json")))
for f in man["files"]:   # adjust to the manifest's actual schema
    h = hashlib.sha256(open(os.path.join(d, f["path"]), "rb").read()).hexdigest()
    assert h == f["sha256"], f["path"]
# then: join executions->rounds on round id; for each round and each t in [45, T-20]
# take the latest book with received <= round_start + t; tabulate book.state,
# whether an execution exists, and net edge; report fill/no-fill/no-order separately.

Matched baseline and equal-risk comparison (planned).

• Compare each rule to the baseline on identical rounds.
• Rescale to equal notional or equal worst-case loss, so that dollar scaling is not mistaken for a better probability.
• Net inventory is signed, so offsetting UP and DOWN positions must be netted before costs.

Stress tests (planned).

• Fees ×1.5 and ×2.
• Depth haircut of 50%, and a one-level-worse fill price.
• Receive latency of +1s and +3s.

Downside, concentration and session checks (planned).

• Report max drawdown.
• Report PnL share from the top 5 fills and top 5 rounds.
• Report leave-one-cohort-out results.
• Report Asia, Europe and US splits.

Significance: none computed. Any test after this needs time-ordered purged splits and multiple-comparison control across every rule and parameter tried.

6. Strongest falsification

The strongest attack on any candidate is a placebo. Apply the same rule to the unfilled and no-order rounds, and to shuffled entry times within the same round, and check whether its apparent improvement disappears. Also check that R1's improvement comes from avoiding losses and not from trading less, by comparing PnL per unit of risk at equal exposure. If the baseline loss is within noise, no rule can be distinguished from "do nothing" on this dataset.

7. Ranked missing-data requests

1. A decision-opportunity log for every round: evaluated or not, the reason, and the decision timestamp.
2. Exchange fill timestamps and prices, and prediction-contract exit quotes and depth.
3. Collateral and margin balance over time.
4. A fixed local holdout from future days, with cohort parameters frozen.
5. Futures flow, open interest and liquidation streams, which are currently uncaptured.
6. A calendar of macro events and holidays.
7. Multi-day data covering all three sessions.

Label summary:

• Measured: the counts and PnL figures in section 1, from the published summaries and not recomputed by me.
• Sourced: the dataset documentation.
• Simulated: nothing.
• Assumed: the DST and session times in section 3.
• Unresolved: all causal claims, hash verification and the candidate rules' performance.

Direct answer. This dataset can't support adopting a timing, session or macro rule. The supported conclusion is to keep cohort 10 ($15 cap) at its current settings, or pause it, while the analysis below is actually run. I could not run it here. I had no shell or gzip/hash tool, so I could not decompress raw/ or csv/, and I could not compute SHA-256 hashes against manifest.json. No file is hash-verified and no row-level statistic below was computed by me. Every number comes from the dataset's own docs, from public calendars, or from simple arithmetic on those. The code in §4 has not been run.

Labels: [SRC-DS] from dataset docs/summary · [SRC-PUB] public source · [DER] arithmetic on sourced numbers · [ASM] assumption · [UNR] unresolved · [UNEXEC] code not run.

---

1. Coverage and missingness audit

Integrity

• [UNR] SHA-256 not verified for any of the 21 files in the manifest.
• [DER] The four markdown files came back at about the manifest byte sizes: brief ≈7.6 KB vs 7733 B, README ≈1.8 KB vs 1826 B, known_issues ≈1.4 KB vs 1433 B, dictionary ≈20.6 KB vs 21080 B. Size matching is not integrity verification.
• Gate: run verify() in §4 first. Abort on any mismatch.

Totals and checks

Item	Value	Check
Executions	237 = 215 settled + 22 unfilled [SRC-DS]	—
Settled close reasons	87 expiry_DOWN + 84 expiry_UP + 44 early_exit = 215 [SRC-DS]	sums [DER]
Net settled	−76.6165 USDC on 1,502.14 entry all-in [SRC-DS]	≈ −5.1% of deployed [DER]
Net by reason	early_exit +80.55, expiry_DOWN −35.72, expiry_UP −121.44 [SRC-DS]	sums to −76.62 [DER]
Rounds	289; 288 with an outcome (147 DOWN / 141 UP); 1 uncommitted [SRC-DS]	—
Book snapshots	37,679 two-sided + 14,490 one-sided + 748 empty = 52,917 [SRC-DS]	sums [DER]; ≈27% not two-sided [DER]
Index ticks	86,710 [SRC-DS]	≈1.00/s over 86,400 s [DER]
Spot bars	1,455 [SRC-DS]	1,440 expected in 24 h; 15 extra (overlap or duplicates?) [UNR]
Factor observations	1,439 [SRC-DS]	≈5 per round [DER], so likely several decision checkpoints per round; this is what makes the waiting analysis possible [ASM]

Discrepancies to resolve before analysis

1. 22 unfilled execution rows vs 19 entry_attempts rows [SRC-DS]. Attempts that never reached the venue may be missing entirely.
2. Exit fields are filled for 51 rows vs 44 early_exit closes [SRC-DS]. About 7 rows look like exit attempts that failed or partly filled [ASM].
3. order_state_events (1,541 rows) has only created, symbol, previous_state, new_state. Order IDs were removed, so joining events to executions is ambiguous [SRC-DS → UNR].
4. Futures features flagged unavailable are missing, not zero. Holiday status is unknown [SRC-DS].
5. Collateral and balances were removed [SRC-DS], so margin-driven no-orders can't be told apart from model skips [UNR].

Cohorts [SRC-DS]

• Max entry: cohorts 1–4 $10; cohorts 5–9 $50; cohort 10 $15.
• Only cohorts 8–10 have require_exit_depth_at_entry.
• Shared: Kelly 0.25, cutoff 20 s, min edge 0.005, max price 2 ticks.
• Cohort net: 8 = +15.87, 9 = −29.08, 6 ≈ +0.80; 5, 7 and 10 negative.
• The decision population is cohort 10 only. Its row count is unknown to me and is almost certainly under 50 fills, which the docs treat as anecdotal [ASM].

The five clocks (keep them separate)

Clock	Field	Note
Source	index_ticks.ts, books.ts	—
Receive	.received ("Local receive timestamp, epoch ms UTC.") [SRC-DS]	—
Forecast	factor_observations.asof, features.asof	—
Decision / intent	executions.created ("when the row was recorded by the strategy") [SRC-DS]	Not an exchange fill time
Label	market_rounds.result_committed_at, s1	—

There are no exchange fill timestamps anywhere [UNR]. Features and books must be selected by received ≤ decision_time, never by ts.

2. Competing explanations for the loss (none assumed)

1. The exit rule creates a selection effect [DER, most likely mechanical]. Early exits can only fire when they are net positive, and there is no stop-loss. So exits take winners off early and leave losers to expiry. That alone guarantees early_exit > 0 and expiry < 0. It doesn't show the exit rule adds value: the counterfactual "hold to expiry" P&L for the 44 exited trades has to be computed.
2. The model has no edge against the market. A zero-drift diffusion on index distance may just restate what the book already prices. Fees and the half-edge discount then make the expected value negative.
3. Adverse selection, stale quotes or latency. IOC orders fill when the book is lagging the index, i.e. the model trades against faster participants.
4. Depth and book state. About 27% of snapshots are one-sided or empty. Fills there are thin, which hurts exit liquidity.
5. Cohort mix. The $50 cohorts dominate notional, so the aggregate tells you little about cohort 10.
6. Volatility or regime. Possible, but not assumed. Test it against 2–5 on the same rounds.
7. Session or event effects. One instance per anchor (§3), so this can't be identified.
8. Directional imbalance. expiry_UP lost much more than expiry_DOWN (−121 vs −36) [SRC-DS]. That could be a one-day trend against signed exposure, which is noise rather than structure [ASM].

3. Sessions, DST and macro anchors in this window

• UK: clocks went back 25 Oct 2026, so London = UTC [SRC-PUB].
• US: DST ends 1 Nov 2026, so New York = EDT (UTC−4) for the whole window [SRC-PUB].
• Consequence [DER]: this is the one-week DST mismatch. The NYSE core session ("9:30 a.m. to 4:00 p.m. ET") runs 13:30–20:00Z, one hour earlier than after 1 Nov. Static UTC session buckets will be wrong next week.

Anchors in the window:

Anchor	Time (UTC)	Basis
NYSE open	28 Oct 13:30Z, 8 min after window start	[DER]
NYSE close	28 Oct 20:00Z	[DER]
Tokyo open	≈00:00Z	[ASM]
Hong Kong open	≈01:30Z	[ASM]
London open	08:00Z	[ASM]
FOMC meeting	27–28 Oct [SRC-PUB]; statement assumed 14:00 ET = 18:00Z 28 Oct, presser ≈18:30Z	[ASM — time not verified]
29 Oct NYSE open	13:30Z, after the 13:22Z window end, so excluded	[DER]
US GDP advance	A search result claimed 29 Oct 08:30 ET (12:30Z). BEA's live schedule shows nothing before 4 Nov.	[UNR — don't use]

So: each session bucket has n = 1 day, there is one FOMC, one US open and one close. Per-cohort fills per bucket are probably 10–30 [ASM]. No recurring session or macro alpha can be inferred. Before using any macro_* or session_* feature, check that features.calendar_known_at ≤ decision_time.

4. Reproducible code [UNEXEC]

# python -I analysis.py <dataset_dir>   (dataset in its own dir; script elsewhere)
import sys, json, hashlib, gzip, pandas as pd, numpy as np
D = sys.argv[1]
def verify():
    m = json.load(open(f"{D}/manifest.json"))
    bad = []
    for f in m["files"]:
        b = open(f"{D}/{f['path']}", "rb").read()
        if len(b) != f["bytes"] or hashlib.sha256(b).hexdigest() != f["sha256"]:
            bad.append(f["path"])
    if bad: raise SystemExit(f"HASH FAIL {bad}")   # gate: no analysis on mismatch
verify()
rd = lambda n: pd.read_csv(f"{D}/csv/{n}.csv.gz")
ex, rnd, bk, fo = rd("executions"), rd("market_rounds"), rd("prediction_books_top"), rd("factor_observations")
ex10 = ex[ex.cohort.astype(str).str.endswith("10")]          # $15 cohort only; others reported separately

# Universe = all 289 rounds, left-joined; states: filled / unfilled / no_record(UNKNOWN) / no_outcome
U = rnd.merge(ex10[["market","state","net_usdc","created","direction"]],
              left_on="symbol", right_on="market", how="left")
U["status"] = np.select([U.outcome.isna(), U.state.eq("settled"), U.state.eq("unfilled")],
                        ["no_outcome","filled","unfilled"], "no_record_unknown")

def book_asof(mkt, t_dec, latency_ms=0):
    b = bk[(bk.market == mkt) & (bk.received <= t_dec - latency_ms)]   # receive clock, no lookahead
    return b.iloc[-1] if len(b) else None

def p_model(dist, rem_s, sigma60):                            # zero-drift diffusion baseline
    from scipy.stats import norm
    return norm.cdf(dist / (sigma60 * np.sqrt(max(rem_s, 1e-9))))

def protected_edge(p, side, b, fee, slip_ticks=0, tick=0.01):
    if b is None or b.state != "two_sided": return np.nan
    px = (b.best_ask if side == "UP" else 1 - b.best_bid) + slip_ticks * tick
    q = p if side == "UP" else 1 - p
    return q - px - fee * px                                  # per-share, fee model per entry_fee_coefficient [ASM form]

# Counterfactual for early exits: hold-to-expiry value vs realized
ee = ex10[ex10.close_reason == "early_exit"].merge(rnd[["symbol","outcome"]], left_on="market", right_on="symbol")
ee["hold_pnl"] = np.where(ee.direction.eq(ee.outcome), ee["entry.quantity"], 0) - ee.entry_all_in
# Exit valuation must use prediction-book bid of held side, NEVER the BTC index.

# Equal-risk paired comparison, block bootstrap by clock hour
def paired(pnl_a, pnl_b, risk_a, risk_b, hours, B=5000, seed=7):
    r = np.random.default_rng(seed); d = pnl_a/risk_a - pnl_b/risk_b
    H = np.unique(hours); bs = []
    for _ in range(B):
        s = r.choice(H, len(H)); bs.append(np.mean(np.concatenate([d[hours == h] for h in s])))
    return d.mean(), np.percentile(bs, [2.5, 97.5])

Session mapping: use zoneinfo for "America/New_York", "Europe/London", "Asia/Tokyo" and "Asia/Hong_Kong" applied to the decision clock. Never hard-code UTC offsets.

5. Candidate rules (at most three; none endorsed)

R1 — Executable-edge abstention (priority). At each decision time t in [45 s, T−20 s], read the book with received ≤ t − L. Enter only if all of these hold:

• book state is two-sided and quality is OK;
• protected edge after fee and +1 tick is ≥ 0.02 per share;
• ask depth at ≤ max_price ≥ 2 × planned quantity;
• bid depth on the held side ≥ planned quantity (exit liquidity);
• the $15 all-in cap and venue lot/notional minimums are met.

Otherwise abstain.

for t in checkpoints(45s .. T-20s):
  b = book_asof(t - L); if not ok(b): continue
  e = protected_edge(p_model(t), side, b, fee, slip=1)
  if e >= 0.02 and depth_ok(b, 2*q) and exit_depth_ok(b, q): enter(min(kelly_q, cap15)); break

R2 — Persistent-edge wait. Enter at the first t ≥ 45 s where R1 passes on two consecutive snapshots at least 1 s apart. This filters stale-quote fills. It must be compared with entering at the earliest permitted time (45 s, baseline thresholds) on the same rounds, not with a single checkpoint. Variants are fixed in advance: E ∈ {45, 90, 150} s. Report all three; no picking the best afterwards.

R3 — Pre-announced anchor blackout (exploratory, weakest). No new entries within ±10 min of the US open or close, computed in local time via zoneinfo, or within [−5, +30] min of a scheduled FOMC, CPI or NFP release, and only where calendar_known_at ≤ t. Using one day of data, this can only be tested prospectively.

6. Baseline matching and stress tests [UNEXEC; design only]

• Baseline: the recorded cohort-10 policy, replayed on the same 288 rounds. The same simulator scores both baseline and candidate so that replay bias cancels out [ASM].
• Equal risk: compare P&L / all-in risk. Also scale the candidate so its total deployed equals the baseline's. Check whether gains just come from trading less (a "no-trade" baseline scores 0).
• Cost and depth grid:
  • fee × {1, 1.5, 2};
  • slippage {0, 1, 2} ticks;
  • latency L ∈ {0, 250, 1000} ms;
  • fill only if quantity ≤ {100, 50, 25}% of displayed depth;
  • exits at bid minus 1 tick, partial fills allowed;
  • unfilled IOC stays unfilled.
• Downside and concentration:
  • worst 5 rounds and worst hour;
  • share of P&L from the top 3 rounds;
  • max drawdown within the session;
  • net signed inventory per round (SELL = DOWN; never treat UP and DOWN as separate inventory);
  • results with 18:00–19:00Z (FOMC) and 13:22–14:00Z (US open) removed.
• Sessions: report Asia / Europe / US / off-hours with n and bootstrap CIs. Mark anything under 50 fills as anecdotal [SRC-DS rule].
• Multiple comparisons: 3 rules × 3 E-variants × 27 stress cells. Report all of them. No significance claims on in-sample data.

7. Strongest falsification

1. Compare model calibration with book-mid calibration on all 288 settled rounds, at the earliest permitted entry, using receive-clock books. If the book mid's Brier score/log-loss is no worse than p_model's, there is no edge for R1/R2 to filter, and the timing rules are just trading less.
2. If the hold-to-expiry counterfactual for the 44 early exits roughly equals their +80.55, then the exit rule only rearranges where losses show up.
3. If R2's gain disappears under L = 1000 ms or +1 tick, it is a latency artifact.

8. Missing-data requests (ranked)

1. Exchange fill records: fill timestamp, price, quantity and fee per fill, linked to intent rows by hashed order IDs.
2. A decision/liveness log for every round and checkpoint, with the reason for each no-order (signal, depth, cap, margin, error).
3. Hashed order IDs that link order_state_events to executions.
4. Cohort active periods and collateral or margin-available flags (redacted magnitudes are fine).
5. Full-depth books at decision receive times, plus exit fills.
6. Several weeks of data covering the 1 Nov DST change and several CPI/NFP/FOMC events. The future holdout should stay local and fixed, defined before anyone looks at it.
7. An explanation for the 15 extra spot bars and the 22 vs 19 attempts gap.

No orders, credentials, wallets, installs or live changes were used. Nothing in the source text was treated as instructions.

Sources: research_brief, known_issues, data_dictionary, summary_stats, strategy_config, manifest, Fed FOMC calendar, NIST DST, GOV.UK clocks, NYSE hours, BEA schedule, BEA listing (search result)