Direct answer

I cannot make a valid empirical claim about Madame Gila’s five-minute BTC prediction trading from this environment. The dataset host is unreachable, including the required directory and all five required files. Therefore:

• SHA-256 verification against manifest.json was not performed.
• No raw JSONL or flattened CSV was read.
• No win rate, calibration, expected log growth, execution advantage, or profitability result can honestly be reported.
• The supplied counts—237 executions, 289 rounds, 86,710 index ticks, and 52,917 book snapshots—are treated only as user-provided facts, not independently measured results.

Required sources that could not be retrieved: research_brief.md, README.md, known_issues.md, data_dictionary.md, and manifest.json.

Required audit once files are available

The analysis must first:

1. Download every manifest-listed file.
2. Compute SHA-256 on the exact bytes and require equality before parsing.
3. Parse raw/ as nested JSONL and csv/ as flattened representations.
4. Reconcile round, execution, tick, and snapshot counts.
5. Retain every round, including unavailable, no-order, rejected, expired, unfilled, partially filled, and missing-state records.

The audit table should report, per field:

Area	Required checks
Coverage	rounds observed; executions; decision opportunities; unavailable/no-order/unfilled states; session and cohort coverage
Missingness	count and percentage by field, round, session, cohort, and outcome
Clocks	source, receive, forecast, decision, label, intent/state, exchange-fill, and settlement timestamps
Market data	BTC index versus prediction-contract bid/ask, depth, spread, quote age, and settlement reference
Execution	requested, supported, filled, partial, canceled, rejected; lot/notional/cost fields
Outcome	label availability, settlement time, exit quote, realized fees, slippage, and unresolved collateral

Missing orders cannot be interpreted as intentional skips unless an explicit decision record exists.

Competing explanations

Observed performance, if later found, must be decomposed into:

1. Probability miscalibration.
2. Good probability estimates but poor offered odds.
3. Fees, spread, and slippage.
4. Adverse selection after entry.
5. Missing or selective fills.
6. BTC-index/reference-price mismatch.
7. Contract settlement mismatch.
8. Exit-liquidity or forced-hold effects.
9. Cohort, session, or inventory concentration.
10. Data leakage caused by confusing source, receive, forecast, decision, intent, fill, or label clocks.

Volatility must not be treated as causal merely because it appears in the existing model. The existing model is a comparator, not a proven profitable baseline.

Three exact candidate rules

These are proposed rules, not tested findings.

Candidate 1: calibrated net-edge rule

At the decision timestamp, estimate the probability of the final contract outcome using only information available by that timestamp.

p = calibrated_probability(features_available_at_decision)
q = executable_contract_price_at_decision
cost = fee + expected_slippage + adverse_selection_buffer
edge = p - q - cost

enter only if:
    edge > 0
    expected_log_growth(p, executable_price, cost) > 0
    time_to_expiry >= 45 seconds
    time_to_cutoff > 20 seconds
    supported_lot_and_notional == true
    protected_depth_check == true
    net_inventory_limits == true

For a short-side contract, use the corresponding complement probability and executable offer.

Candidate 2: probability-versus-market control

Use the market-implied probability as the primary control and trade only statistically calibrated residuals:

market_p = executable_price adjusted for fee and side
residual = calibrated_p - market_p
trade if:
    abs(residual) >= fixed_threshold
    and net_expected_log_growth > 0
    and depth/slippage checks pass

This directly tests whether any result comes from probability information rather than simply buying favorable-looking prices.

Candidate 3: equal-risk inventory rule

Keep the edge rule, but size by supported executable risk rather than nominal bankroll:

risk_budget = min($15, session_risk_limit, cohort_limit)
unit_loss = worst_case_loss_after_fee_and_slippage
stake = min(
    quarter_kelly(stake, calibrated_p, executable_price),
    risk_budget / unit_loss,
    available_depth,
    supported_lot_limit
)

reject if:
    stake < minimum_supported_lot
    collateral is unknown
    executable depth is insufficient
    net inventory after fill exceeds limit

Old cohorts must remain separate from the current $15 cap.

Reproducible calculation skeleton

Unexecuted because the source files were unavailable:

# verify first; do not parse unverified files
for path, expected_sha256 in manifest.items():
    actual = sha256(path.read_bytes()).hexdigest()
    assert actual == expected_sha256, (path, actual, expected_sha256)

# use receive/decision clocks, never future fill or label fields
opportunities = all_rounds[
    all_rounds.decision_ts.between("2026-10-28T13:22Z",
                                   "2026-10-29T13:22Z")
]

for r in opportunities:
    state = classify_state(r)  # unavailable/no-order/unfilled/partial/filled
    features = features_as_of(r.decision_ts)
    outcome = label_as_of_settlement(r)
    # preserve outcome missingness rather than dropping the row

The primary estimand should be per-opportunity net return and expected log growth over all observed rounds, with unavailable/no-order/unfilled states retained in the denominator where appropriate. Filled-trade-only results should be reported separately as conditional execution results, never as strategy-level performance.

Baselines and stress tests

The minimum comparison set is:

• no-trade baseline;
• existing zero-drift diffusion model;
• market-implied probability;
• simple calibrated control, such as logistic calibration of market price and observable features;
• each strategy under equal dollar risk and equal worst-case loss.

Every result should be recomputed under:

• recorded costs;
• fees doubled;
• spread/slippage doubled;
• one-tick adverse execution;
• removal of unavailable depth;
• conservative treatment of all unresolved collateral;
• no-exit or forced-settlement valuation;
• current $15 cap versus each old cohort’s original limit.

No claim of profitability is justified unless it survives realistic depth and cost assumptions and is not driven by a small number of fills.

Downside, concentration, and session checks

Report maximum drawdown, worst round, worst session, loss streak, tail loss, turnover, and exposure duration. Also report concentration by:

• round;
• hour/session;
• side;
• contract;
• cohort;
• confidence bucket;
• volatility bucket;
• entry-distance bucket;
• fill-status bucket.

High-confidence losses require a separate table comparing predicted probability, market-implied probability, executable odds, depth, cost, fill delay, settlement reference, and exit liquidity. They are especially important for distinguishing calibration failure from execution or settlement failure.

Strongest falsification

The strongest falsification is a predeclared, time-ordered holdout in which:

1. probabilities are frozen before the holdout;
2. every round remains in the denominator;
3. decisions use only data available at decision time;
4. fills use executable depth and supported lots;
5. all fees, slippage, and unresolved collateral are conservatively charged;
6. Candidate 1 fails to outperform both the market-implied calibrated control and the equal-risk existing model.

A second strong falsification is that apparent gains disappear when BTC index movements are replaced with the contract’s actual executable quote and settlement reference.

Ranked missing-data requests

1. Exact manifest and all SHA-verified files, especially round-level state and decision records.
2. Exchange fill ledger with exchange timestamps, partial fills, rejects, cancellations, fees, and supported lot/notional limits.
3. Prediction-contract bid/ask/depth snapshots and quote age at every decision and attempted order.
4. Contract settlement rule, reference price, settlement timestamp, and canonical BTC index source.
5. Complete forecast/probability records with model version and feature-availability timestamps.
6. Exit quotes, exit attempts, forced settlement, and realized exit liquidity.
7. Explicit unavailable/no-order reasons, while preserving genuinely unknown reasons as unknown.
8. Cohort limits, session identifiers, inventory, collateral, and wallet/accounting fields.

Until these are available and verified, the correct conclusion is unresolved—not profitable, unprofitable, volatility-driven, or causally validated.

---

Sources offered but not confirmed by this machine:

• https://1892-gila-data.community.iamstarchild.com/r-82882c274d1d0427e27b9da3/research_brief.md — could not be read: The operation was aborted
• https://1892-gila-data.community.iamstarchild.com/r-82882c274d1d0427e27b9da3/README.md — does not contain the quoted text
• https://1892-gila-data.community.iamstarchild.com/r-82882c274d1d0427e27b9da3/known_issues.md — does not contain the quoted text
• https://1892-gila-data.community.iamstarchild.com/r-82882c274d1d0427e27b9da3/data_dictionary.md — does not contain the quoted text
• https://1892-gila-data.community.iamstarchild.com/r-82882c274d1d0427e27b9da3/manifest.json — does not contain the quoted text

I cannot establish whether Madame Gila’s losses come from probability miscalibration, execution costs, or another cause from this session. The dataset endpoint was inaccessible through the web tool; direct retrieval failed with a DNS-resolution error. Consequently, no dataset file was SHA-256 verified, and no trading analysis or simulation was executed. Reporting profitability, coverage percentages, high-confidence loss counts, or a winning rule would fabricate results.

Below is a reproducible, explicitly unexecuted investigation protocol. The external citations support its methods; they do not establish facts about Madame Gila.

Coverage and missingness audit

The requested window and counts are user-supplied, unverified:

Item	Supplied scope	Verification status
Window	2026-10-28 13:22Z–2026-10-29 13:22Z	Boundary conventions unresolved
Executions	237	Unverified; not necessarily distinct fills or positions
Observed rounds	289	Unverified; must be the round-level starting universe
Index ticks	86,710	Unverified; continuity and usable timestamps unknown
Book snapshots	52,917	Unverified; instrument, side, depth and freshness unknown
Current cap	$15 all-in	User-supplied; effective configuration boundaries unknown
Historical cap cohorts	Other limits	Must remain separate
Collateral, actual fills, settlement reconciliation	Not established	Unknown

Do not infer participation or skip rates by subtracting executions from rounds: the units differ.

After integrity verification, construct a round ledger with every observed round, including boundary-overlapping rounds. Attach events without requiring an order or forecast to exist. Report counts and denominators separately for:

• Round metadata, target, contract identifier, settlement rule and final label.
• Forecast available/unavailable; model/configuration version; valid input history.
• Book available/unavailable; correct token; bid/ask depth; source and receive age.
• Explicit no-order decision, order submitted, rejected, canceled, expired, unfilled, partially filled, filled, and unresolved.
• Verified fill quantity, price, fees, inventory, sale proceeds, settlement proceeds and collateral.
• Orphan events, duplicate identifiers, conflicting statuses, raw/CSV discrepancies and missing joins.

Absent order record → “order observation absent,” not “deliberately skipped.” Missing fill evidence remains unknown; an intent or status update is not an exchange execution.

For each field, distinguish absent, explicit null, empty, invalid, conflicting and unavailable-by-design. Report missingness by configuration cohort, hour, side, probability band and order state. Preserve raw event multiplicity while deriving round-level summaries.

Clock discipline

Use distinct columns for source event time, local receive time, forecast creation, decision, submission/acknowledgment, exchange fill, settlement event and label receipt.

At decision time (t), include only information received by (t). A historical source timestamp does not make a late-arriving record available earlier. Verify source-clock offsets before using them for age calculations. Training labels must have been received before the training cutoff.

Keep whole rounds together in chronological development splits, with a gap covering feature history and label overlap. Time-series validation is designed to avoid training on future observations and evaluating on past observations; irregular event streams require time-based boundaries rather than blindly splitting rows. TimeSeriesSplit documentation

The requested day remains exploratory regardless of internal splits. Any later holdout must remain local, fixed and unopened during rule selection.

Competing explanations and distinguishing tests — all unexecuted

Explanation	Distinguishing evidence to collect
Probability miscalibration	Reliability curves and probability residuals across all eligible observed rounds, before conditioning on fills
Poor odds despite useful predictions	Compare predicted payout probability with executable, fee-inclusive acquisition cost
Fees or slippage	Reconcile decision quote → submitted limit → actual fill → fee ledger
Adverse selection	Compare filled and unfilled attempts using only pre-order matching variables; examine subsequent contract quotes where recorded
Missing or misclassified fills	Reconcile order IDs, exchange execution IDs, cumulative quantities and inventory changes
Reference/settlement mismatch	Reconstruct the documented target and official settlement reference; check ties, rounding and boundary timing
Exit liquidity	Value liquidation from contract bid depth for the inventory size, including selling fees
Model specification, including volatility	Check residuals against distance, remaining time, volatility, stale inputs and session; do not presume volatility is causal

These explanations can coexist. Observational matching cannot, by itself, establish that filling caused worse outcomes.

For a high-confidence loss audit, predeclare selected-side probability bands ([0.90,0.95)), ([0.95,0.99)), and ([0.99,1]); these are assumed diagnostic thresholds, not discoveries. Include wins as well as losses. For each band, report unique rounds, mean probability, predicted losses (\sum(1-p_i)), actual losses, costs, and unknown labels. Then inspect every losing round’s input history, clocks, target, official resolution and actual inventory.

Compare the baseline against three probability controls on identical round/time observations:

1. Constant (p=0.5).
2. Same-time market midpoint, when both valid bid and ask exist.
3. A simple sigmoid calibration of baseline probabilities, fitted only on earlier, label-available rounds.

A midpoint is a forecast control, not an executable purchase or exit price. Do not manufacture it from a last trade or BTC index.

Use reliability diagrams to diagnose calibration: they compare average predictions with observed event frequencies. Proper scores also reflect discrimination and outcome uncertainty, so a better score alone does not establish better calibration. Probability calibration documentation

Report binary Brier score (\operatorname{mean}(p-y)^2), with round weighting so frequently sampled rounds do not dominate. Brier score documentation

Also report log loss, [ -\operatorname{mean}[y\log p+(1-y)\log(1-p)], ] with numerical clipping disclosed and exact-zero/one predictions counted separately. Log-loss documentation

Inventory and economic calculations

The following are proposed accounting identities, not measured results.

For a contract paying one dollar on a win, let (q) be supported shares and (C(q)) the total acquisition debit, including actual applicable fees. With no intermediate sale or settlement charge: [ EV(q)=pq-C(q). ]

Thus a high win probability can still have negative expected value when the all-in price is higher. Actual settlement rules and charges must replace this simplified payout assumption.

Maintain an event ledger: [ Q_s(t)=Q_s(0)+\sum \text{verified buys}_s-\sum \text{verified sells}_s, ] for each outcome token (s). Repeated states are not repeated fills. Unknown opening inventory prevents complete reconciliation.

For a fully reconciled, closed inventory segment: [ P&L=\text{sale receipts}+\text{settlement receipts} -\text{purchase debits}-\text{all charges}. ] Avoid double-counting fees already included in cash amounts. Retain unresolved inventory separately; do not label it zero or realized loss.

For a new isolated purchase with known wealth (W): [ G(q)=p\log\frac{W-C(q)+q}{W} +(1-p)\log\frac{W-C(q)}{W}. ] For existing or opposing positions, evaluate total terminal portfolio wealth under each settlement outcome, including locked collateral and obligations. Do not sum isolated Kelly calculations.

Missing wealth/collateral means Kelly fractions, portfolio log growth and some risk limits are unresolved. Dollar cash flows can still be reported where independently supported.

Enumerate actual permitted quantity increments and minimum notionals. Walk the correct token’s depth and apply its fee schedule. Never assume fractional sizing is supported. A BTC index change is neither contract liquidation proceeds nor proof that a contract sale could fill.

Two exact candidate rules — proposed, untested

Both candidates operate as wrappers around a faithfully reconstructed baseline. Preserve its recorded timing implementation, protected execution logic and existing positive-net expected-log exits. The meaning of “earliest entry 45s” must come from verified documentation/code, not an invented interpretation.

Evaluate each cap/configuration cohort separately. Apply the $15 all-in limit only to its documented current cohort.

Candidate 1: Simple probability calibration.

Fit [ p_c=\operatorname{sigmoid}{a+b,\operatorname{logit}(\operatorname{clip}(p,10^{-6},1-10^{-6}))}. ] Minimize mean log loss plus (0.01[a^2+(b-1)^2]), using one predeclared forecast per earlier round at its first baseline-eligible decision. Include eligible no-order and unfilled rounds with valid forecasts and labels. Require both outcome classes; otherwise return “calibrator unavailable.” The penalty is an assumed fixed design choice.

Replace only the baseline probability with (p_c); rerun the original edge and sizing implementation. Freeze coefficients before each evaluation block. This tests whether a small correction improves decisions; it does not assume miscalibration exists.

Candidate 2: Conservative execution-cost gate.

Retain baseline probability and sizing. For the proposed supported quantity, construct a stressed acquisition quote using 50% of each displayed ask level, then add $0.01 per share and the applicable fees. Accept only if the full quantity remains available, stressed all-in cost satisfies the cohort cap, and both incremental expected dollars and portfolio expected log wealth are positive under that stress. Otherwise produce a shadow rejection or “unresolved inputs.”

The depth haircut and one-cent penalty are assumed stress parameters, not estimated slippage.

for round in ALL_OBSERVED_ROUNDS:
    attach every recorded forecast/order/unavailable state
    retain unknown states explicitly

    for decision in chronological recorded baseline opportunities:
        inputs = records received by decision.time
        cohort = documented configuration effective at decision.time

        if baseline cannot be reconstructed:
            record UNRESOLVED_BASELINE
            continue

        base = replay_baseline(inputs, cohort)

        # Candidate 1, evaluated separately:
        if frozen_calibrator is available:
            p1 = calibrate(base.probability)
            c1 = replay_baseline(inputs, cohort, probability=p1)
        else:
            c1 = UNRESOLVED_CALIBRATOR

        # Candidate 2, evaluated separately:
        c2 = base
        if base proposes an entry:
            stressed = price_full_quantity(
                asks=inputs.correct_token_asks,
                depth_multiplier=0.50,
                extra_cost_per_share=0.01,
                fee_schedule=cohort.fees
            )
            c2 = accept_only_if(
                supported_quantity_and_notional,
                full_depth_available,
                stressed_all_in_cost <= cohort.cap,
                incremental_EV > 0,
                incremental_portfolio_expected_log > 0
            )

        record shadow decisions; never infer counterfactual fills

Neither rule is endorsed. Their exits inherit only the existing supported exit policy.

Matched baseline, equal-risk comparison and stress

No comparison results are available. The proposed comparison has three separate panels:

• Forecast panel: identical round/time samples and labels for baseline, calibrated model and controls; separately report coverage lost to unavailable inputs.
• Decision panel: identical eligible observations, cohort constraints, quantity rules and execution assumptions. Include no-trade and unavailable states.
• Accounting panel: actual reconciled baseline fills and cash flows. Counterfactual strategies remain simulations; their profitability cannot be claimed from baseline fills alone.

Compare native sizing and an equal-risk version. For equal risk, constrain every strategy to the same predeclared per-round worst-case terminal-loss budget, aggregate collateral limit and concurrent exposure limit. Use the largest supported quantity under those limits; report rounding, infeasible orders and actual risk used. Do not equalize by selectively dropping losses or scaling returns after observing outcomes.

Include zero-position cash as a control. Do not assume the recorded baseline is profitable.

Run a fixed stress grid: displayed depth fractions (100%,50%,25%); extra acquisition cost (0,1,2) cents/share; additional latency (0,250,1000) ms. These are assumptions. At delayed times use only books then available; missing books produce unresolved scenarios, not fabricated quotes.

For passive orders, book touches do not establish fills without queue/execution evidence. Show an explicit optimistic executable-depth scenario and a conservative no-fill scenario rather than inventing one fill estimate. For exits, walk contract bids for net inventory and apply selling charges; insufficient liquidity leaves residual exposure.

Report:

• Realized cash P&L and unresolved inventory separately.
• Settlement-only and executable-liquidation drawdowns where supported.
• Worst round, consecutive losses, peak concurrent exposure and collateral utilization.
• Top-one/top-five round shares of gains and losses; leave-best-round and leave-best-hour sensitivity.
• Fixed UTC four-hour sessions, side, probability band and cap/configuration cohort.
• Losses under missing-label and missing-fill bounds where identifiable.

These are descriptive robustness checks. Repeated forecasts are not independent trials; the supplied counts do not justify a significance claim.

Strongest falsification

The strongest challenge to a probability-model advantage is a fixed, later local holdout where the baseline fails to outperform the same-time market control on matched proper scores, fails reliability checks, and fails to produce positive net incremental value under supported execution costs and equal risk.

That result would undermine the proposed model advantage; it would not prove which alternative explanation caused historical losses. Conversely, improved forecast scores with negative net trading value would direct attention toward odds, costs, execution and inventory rather than treating calibration as sufficient.

Freeze the rules, coefficients, evaluation times, exclusions, costs and risk budgets before opening that holdout. No majority vote among models substitutes for this evidence.

Reproducible integrity/missingness code — explicitly unexecuted

This standard-library code reads an existing local mirror without installing packages or writing files. It intentionally stops on an unfamiliar manifest schema. It hashes every listed payload before interpreting documents or data. SHA-256 is available through Python’s hashlib. Python hashlib documentation

The manifest cannot ordinarily authenticate itself; archive its digest and compare it with an independently trusted digest if available. Hash agreement establishes consistency with that manifest, not the truth of event records.

# UNEXECUTED.
# Run: python3 audit.py /path/to/existing/local/mirror
import collections, csv, hashlib, io, json, pathlib, re, sys

root = pathlib.Path(sys.argv[1]).resolve()
manifest_bytes = (root / "manifest.json").read_bytes()
manifest = json.loads(manifest_bytes)

# Explicit accepted schemas; adapt only after inspecting the real manifest.
entries = manifest.get("files", manifest) if isinstance(manifest, dict) else manifest
if isinstance(entries, list):
    pairs = [(e["path"], e["sha256"]) for e in entries]
elif isinstance(entries, dict) and all(
    isinstance(v, str) and re.fullmatch(r"[0-9a-fA-F]{64}", v)
    for v in entries.values()
):
    pairs = list(entries.items())
else:
    raise SystemExit("Unknown manifest schema; inspect before proceeding")

verified = {}
for name, expected in pairs:
    if name in verified:
        raise SystemExit("Duplicate manifest path: " + name)
    if not re.fullmatch(r"[0-9a-fA-F]{64}", expected):
        raise SystemExit("Invalid SHA-256: " + name)
    path = (root / name).resolve()
    if not path.is_relative_to(root) or not path.is_file():
        raise SystemExit("Missing or unsafe path: " + name)
    payload = path.read_bytes()
    actual = hashlib.sha256(payload).hexdigest()
    if actual != expected.lower():
        raise SystemExit("SHA-256 MISMATCH: " + name)
    verified[name] = payload

# Reject local payloads absent from the manifest.
listed = {(root / name).resolve() for name in verified}
extra = [
    str(p.relative_to(root)) for p in root.rglob("*")
    if p.is_file() and p.name != "manifest.json"
    and p.resolve() not in listed
]
if extra:
    raise SystemExit("Unmanifested files: " + repr(extra))

required = [
    "research_brief.md", "README.md",
    "known_issues.md", "data_dictionary.md"
]
if any(name not in verified for name in required):
    raise SystemExit("Required documentation absent from manifest")

print("manifest_sha256", hashlib.sha256(manifest_bytes).hexdigest())
print("verified_payloads", len(verified))
for name in required:
    print("\nDOCUMENT", name)
    print(verified[name].decode("utf-8"))

def leaves(value, path=()):
    # Arrays remain arrays: do not turn nested fills into independent events.
    if isinstance(value, dict) and value:
        for key, child in value.items():
            yield from leaves(child, path + (str(key),))
    else:
        yield path, value

for name, payload in sorted(verified.items()):
    if not name.endswith((".jsonl", ".csv")):
        continue
    stream = io.StringIO(payload.decode("utf-8-sig"))
    if name.endswith(".jsonl"):
        records = (json.loads(line) for line in stream if line.strip())
    else:
        records = csv.DictReader(stream)

    total = 0
    present = collections.Counter()
    null = collections.Counter()
    empty = collections.Counter()
    for record in records:
        if not isinstance(record, dict):
            raise SystemExit("Non-object record: " + name)
        total += 1
        for key, value in leaves(record):
            present[key] += 1
            null[key] += value is None
            empty[key] += value == "" or value == [] or value == {}
    print("\nFILE", name, "records", total)
    for key in sorted(present):
        print(json.dumps({
            "path": list(key), "present": present[key],
            "absent": total - present[key],
            "explicit_null": null[key], "empty": empty[key]
        }))

This is an integrity and structural-missingness audit, not a completed economic replay. CSV empty strings cannot establish raw null semantics. Round joins, fee calculations, event deduplication and clock mapping must be implemented from the verified dictionary and known issues rather than guessed.

Ranked missing-data requests

1. An accessible byte-identical dataset mirror and manifest, preferably with an independently supplied manifest dig

I could not run the analysis or the hash check. My tools here can't open the gzipped csv/ and raw/ files or compute SHA-256. Every number below comes from the packet's own documentation and summary_stats.json, not from my own pass over the rows. The code in §4 has not been run.

Direct answer

The data does not show that the baseline makes money, and the current $15 configuration has too few trades to judge. Across all cohorts, settled trades lost −$76.62 on $1,502.14 deployed (−5.1%). All of that loss is in positions held to expiry: −$157.16 over 171 positions. Early exits made +$80.55 over 44, but that is guaranteed by design, because only exits that would net a profit are allowed. The current-cap cohort (cohort_10, $15) has 8 fills and −$15.52. Below about 50 fills the packet calls that "anecdotal."

The aggregates are consistent with wrong probabilities, bad entry prices plus fees, or adverse selection. They cannot tell these apart without the row-level checks in §4. My recommendation is to pause the baseline, or run it only in shadow/paper mode. Anything live should wait until candidate 1's falsification test (§3) is run on a fixed local holdout.

1. Coverage and missingness audit

Source figures (from the packet docs, not re-derived by me):

Item	Figure	Note
Rounds	289; 288 with an outcome (DOWN 147, UP 141)	1 round has no committed outcome
Execution rows	237 = 215 settled + 22 unfilled
Close reasons (settled)	87 expiry_DOWN, 84 expiry_UP, 44 early_exit
Entry-attempt rows	19	Conflicts with 22 unfilled — unresolved
Index ticks	86,710	≈1.004 per second over 86,400 s
Spot bars	1,455	vs 1,440 minutes: 15 extra rows, cause unknown
Factor snapshots	1,439	≈5 per round
Order-book snapshots	52,917	37,679 two-sided (71.2%), 14,490 one-sided (27.4%), 748 empty (1.4%); best_bid present 45,133, best_ask 44,715

Measured from documented non-null counts:

• Exit fields are filled for 51 executions, but there are only 44 early exits. The other 7 may be partial or failed exits; unresolved.
• exit_attempt is filled for 38 rows; entry_attempt for 226 of 237.
• Feature coverage: venue book features in 790 of 1,439 snapshots (54.9%), futures in 610 (42.4%), calendar in 515 (35.8%).
• futures_*_available=false means the feature was not captured. It does not mean zero.

Clocks:

• Index ticks and book snapshots have both a source ts and a local received time, so features can be filtered on received ≤ decision.
• Executions only have created, which is the strategy's record time, not the exchange fill time.
• settled_at is a close/settlement record time.
• The label clock is result_committed_at.
• Missing: the exact model-input timestamp (which index tick and σ the model used) and the time each fill happened on the exchange.

Rounds with no execution row: at least 52 (289 − 237, if one row per round) and possibly more. These cannot be split into "deliberately skipped" versus "offline/unobserved" because there is no liveness log. Free collateral was removed from the export, so counterfactual Kelly stakes cannot be rebuilt.

Fee formula (measured from the dictionary's example row; one row only):

• Entry: 5.38 shares, amount 2.3672 (price 0.44), fee 0.039769.
• 0.03 × 5.38 × 0.44 × 0.56 = 0.039769, so fee = 0.03·q·p(1−p).
• Exit amount 3.0128 (price 0.56). Net = 3.0128 − 2.3672 − 2×0.039769 = 0.566062, exactly the recorded net_usdc.
• So at p≈0.5 the fee is about 0.0075 per share: about 1.5% of notional one way, about 3% for an entry plus early exit.
• min_edge_per_share is set to 0.005, below that one-way fee. Whether the edge check already deducts fees is unresolved.

Settlement rules (secondary source): Orderly's own index settles each round, with a $1 payout per winning share and $0.50 to both sides on an exact tie. I couldn't find Orderly's primary documentation; that is missing-data item 4.

Hash check: the SHA-256 checks against manifest.json were not done. Treat every figure above as unverified until §4 step 0 passes.

2. Competing explanations (all unresolved; for each, the check that tells it apart)

1. Probability miscalibration. The diffusion model is overconfident, for example because 60s σ is too low or because of fat tails and jumps. Check: reliability of the model probability on the chosen side (p_dir) versus outcome across all 215 trades, scored hold-to-expiry, including the early exits.
2. Bad prices paid. The model is calibrated but the strategy pays c ≥ p_dir − fee. Check: mean of (win − c − fee) against mean of (p_dir − c − fee).
3. Adverse selection. IOC orders fill only when the market is about to move against them. Check: the mid-price move 5s and 30s after fill, used only as a label, and the gap between fill rate and loss rate.
4. Fees and slippage. The 0.03·p(1−p) fee plus price ticks above mid wipe out a thin edge. Check: attribute each trade's PnL to entry slippage versus the mid at decision.
5. Missing fills and selection. 22 unfilled orders and the unknown number of no-order rounds may cluster in the best opportunities. Check: outcome of unfilled-intent rounds scored at their intended limit price.
6. Settlement or reference mismatch. The model's index price differs from Orderly's settlement index (PERP_BTC_USDC), or ties are handled differently. Check: sign(s1−s0) against outcome, and the gap between the last received tick and s1.
7. Exit asymmetry. Winners are cut early while losers ride to expiry. Late books thin out (27% of snapshots are one-sided). Check: for the 44 early exits, compare actual PnL with what holding to expiry would have paid.
8. Directional skew. −$121.44 sits in expiry_UP versus −$35.72 in expiry_DOWN. If expiry_UP means the round settled UP, losses may come from net-DOWN exposure in up-moves. The label's meaning is unresolved, and with 84 vs 87 trades it is not significant. Volatility is not assumed to be the cause.

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

C1: shrink toward the market price before trading (tests explanations 1–3).

p_mkt = mid_up(last book with received<=t_dec, state==two_sided, quality==ok) else ABSTAIN
p_use = 0.5*p_model + 0.5*p_mkt            # w fixed a priori, NOT tuned
c     = executable ask for side (UP ask, or 1-UP bid for DOWN) walked to qty
edge  = p_use_side - c - 0.03*c*(1-c) - 0.01   # 1-tick slippage buffer
if edge < 0.02: ABSTAIN; size = existing half-edge quarter-Kelly on edge, cap $15 all-in

C2: book-quality gate (tests explanations 3, 4, 7). Abstain unless all of these hold:

• the book is two-sided and quality==ok;
• spread ≤ 0.03;
• top-level depth on the entry side ≥ order quantity;
• opposite-side depth ≥ order quantity (needed to exit).

C3: flat stake, so sizing effects can be separated from edge (tests sizing). Same signals, fixed $5 all-in per trade within the $15 cap. If the flat stake beats Kelly, the problem is sizing, not alpha. A smaller loss alone is not evidence of an edge.

Rejected:

• Adding a loss-cutting stop, as long as no executable exit quotes exist.
• Volatility-scaled bigger bets.
• Session or macro rules. One day of data and 35.8% calendar coverage can't support them.

4. Reproducible code (NOT run; Python standard library only; run with python -I script.py <dir>)

import sys,os,json,gzip,csv,hashlib,math,random,collections as C
R=sys.argv[1]
# 0. verify manifest (adapt key names; fail closed)
m=json.load(open(os.path.join(R,"manifest.json")))
for f in m["files"]:
    h=hashlib.sha256(open(os.path.join(R,f["path"]),"rb").read()).hexdigest()
    assert h==f["sha256"],f["path"]
rd=lambda n:list(csv.DictReader(gzip.open(os.path.join(R,"csv",n+".csv.gz"),"rt")))
X,MR,BK=rd("executions"),rd("market_rounds"),rd("prediction_books_top")
rnd={r["symbol"]:r for r in MR}
bk=C.defaultdict(list)
for b in BK: bk[b["market"]].append(b)
for v in bk.values(): v.sort(key=lambda b:int(b["received"]))
def book_at(sym,t):                        # no lookahead: received<=t
    last=None
    for b in bk[sym]:
        if int(b["received"])>t: break
        last=b
    return last
F=lambda q,p:0.03*q*p*(1-p)
rows=[]
for x in X:
    r=rnd[x["market"]]; o=r["outcome"] or None
    pd=float(x["p_up"]) if x["direction"]=="UP" else 1-float(x["p_up"])
    b=book_at(x["market"],int(x["created"]))
    mid=(float(b["best_bid"])+float(b["best_ask"]))/2 if b and b["state"]=="two_sided" else None
    md=None if mid is None else (mid if x["direction"]=="UP" else 1-mid)
    d=dict(st=x["state"],coh=x["cohort"],pd=pd,md=md,o=o,cr=x["close_reason"],t=int(x["created"]))
    if x["state"]=="settled":
        q,a=float(x["entry.quantity"]),float(x["entry.amount"]); c=a/q
        win=None if o is None else (1.0 if o==x["direction"] else 0.0)
        tie=r["s1"] and float(r["s1"])==float(r["s0"])   # tie rule: secondary source
        hold=None if win is None else q*(0.5 if tie else win)-float(x["entry_all_in"])
        d.update(c=c,q=q,win=win,net=float(x["net_usdc"]),hold=hold,
                 slip=None if md is None else c-md,stake=float(x["entry_all_in"]))
    rows.append(d)
S=[d for d in rows if d["st"]=="settled" and d["win"] is not None]
# 1. calibration: model vs market-implied vs 0.5, hold-to-expiry labels
def brier(k): z=[d for d in S if d.get(k) is not None]; return len(z),sum((d[k]-d["win"])**2 for d in z)/max(1,len(z))
print("brier model",brier("pd"),"mkt",brier("md"),"half",sum((0.5-d["win"])**2 for d in S)/len(S))
for lo in (0.5,0.6,0.7,0.8,0.9):
    z=[d for d in S if lo<=d["pd"]<lo+0.1]
    if z: print(lo,len(z),sum(d["win"] for d in z)/len(z),sum(d["pd"] for d in z)/len(z),sum(d["c"] for d in z)/len(z))
# 2. attribution per share: model edge vs paid odds vs fee vs realized
for d in S: d["e_mod"]=d["pd"]-d["c"]; d["fee"]=0.03*d["c"]*(1-d["c"]); d["e_real"]=d["win"]-d["c"]-d["fee"]
# 3. early-exit counterfactual (both columns are labels, not predictors)
E=[d for d in S if d["cr"]=="early_exit"]; print("exit realized",sum(d["net"] for d in E),"hold",sum(d["hold"] for d in E))
# 4. high-confidence losses
for d in sorted([d for d in S if d["pd"]>=0.8 and d["win"]==0],key=lambda d:d["net"]): print(d)
# 5. hour-block bootstrap of net/$ per cohort (never pool cohorts)
def boot(z,B=5000):
    blk=C.defaultdict(list)
    for d in z: blk[d["t"]//3600000].append(d)
    K=list(blk); out=[]
    for _ in range(B):
        s=[d for k in random.choices(K,k=len(K)) for d in blk[k]]
        out.append(sum(d["net"] for d in s)/sum(d["stake"] for d in s))
    out.sort(); return out[int(.025*B)],out[int(.975*B)]
for c in sorted({d["coh"] for d in S}): print(c,boot([d for d in S if d["coh"]==c]))
# 6. stress: fee x1.5, +1 tick entry, exits capped by best_bid_size at exit time-1 tick
# 7. equal-risk: scale each pnl by 5/stake (flat $5) -- flagged: ignores depth beyond observed top size
# 8. concentration: share of loss from worst 5 trades, by UTC hour, by session_bucket
# 9. reference: count rounds where sign(s1-s0) disagrees with outcome; last tick received<=expire_at vs s1
# 10. universe: per round label {settled, unfilled, attempt-only, no-record}; book coverage at start+45s

The bootstrap uses roughly 24 hourly blocks. Six search families means 6 or more comparisons, so Holm-adjust any p-values. No significance is claimed here.

5. Baseline, equal-risk and stress checks

• Not computed. The matched comparisons are (a) baseline, (b) market-implied only, (c) C1/C2, and (d) flat $5. All must use the same eligible round set and the same hold-to-expiry labels.
• Stress tests specified, not computed:
  • fee coefficient 0.045;
  • +1 tick on entry and exit;
  • exit fills capped at the best-bid size observed at or before the exit record time.
• Simulated exits use the prediction book only, never the BTC index.

6. Downside, concentration and session

• Measured (from summary): cohort net results, each separate and none pooled:

Cohort	Fills	Net
cohort_9	95	−$29.08
cohort_8	81	+$15.87
cohort_7	22	−$21.26
cohort_5	8	−$27.43
cohort_10	8	−$15.52
cohort_6	1	+$0.80

• Only cohorts 8 and 9 reach about 50 fills. Cohorts 8 and 9 both require exit depth at entry, yet their results have opposite signs. That points to noise or regime rather than the depth rule, which is unresolved.
• Average stake was $6.99. Average result was −$0.36 per fill overall and −$0.92 per expiry-held trade.
• Worst-trade share, hourly and session splits: not computed (§4 step 8).

7. Strongest falsification

Of "miscalibration": suppose that, scored hold-to-expiry across all settled trades, the model's reliability falls within the bootstrap band. Then the loss comes from c + fee ≥ p_dir, meaning poor prices and fees, not the model.

Of C1: C1 is falsified if either of these happens:

• on a fixed, purged local holdout, market-implied probability alone has an equal or better Brier/log score than the blend;
• C1-gated trades are ≤ 0 net per dollar after the stress fees.

If the market-implied probability beats the model: the diffusion has no information beyond the market price, and pausing is correct.

8. Missing data requests, ranked

1. Exchange fill timestamps and prices, partial fills, and the state of each IOC order. Intent records are not fills.
2. The exact model inputs at each decision: the index tick and σ used, and the identifier of the book snapshot consulted.
3. Liveness and heartbeat logs, to tell "skipped" rounds from "offline" ones, and to explain the 19 vs 22 unfilled-count conflict.
4. Primary Orderly Predict documentation: fees, the settlement index, ties, and net-position rules.
5. Book snapshots at each exit attempt, and records of rejected exits.
6. Free collateral and stake inputs (both redacted).
7. Seven or more additional days as a fixed local holdout, plus a definition of the expiry_UP/DOWN labels.

Labels:

• Sourced: packet figures, the venue settlement rules.
• Measured: the fee formula and the arithmetic derived from the packet docs and summary.
• Assumed: C1's weight w = 0.5 and C1's thresholds.
• Simulated: none.
• Unresolved: everything else.

Other sources: KuCoin 5-minute market rules, used only for comparison.

---

Sources offered but not confirmed by this machine:

• https://ourcryptotalk.com/news/orderly-predict-5-minute-btc-prediction-market — did not return a page