No defensible trading-rule recommendation can be made from this run. I could not retrieve the dataset or manifest, so I could not verify SHA-256 hashes, audit coverage, reconstruct inventory, or compare exit policies. Profitability, the cause of losses, and whether any alternative improves on holding remain unresolved.

The browser failed to retrieve the research brief, README, known issues, data dictionary, and manifest. A separate Python retrieval failed with Temporary failure in name resolution. These links identify attempted sources; they are not citations to inspected content. I cannot honestly supply five supporting citations or verbatim source quotations.

The following is an unexecuted research specification, not dataset findings or an endorsement.

Coverage and missingness audit

The counts below are user-supplied, unverified. They describe different units and must not be divided into one another to infer participation or fill rates.

Item	Supplied count	Verified here	Required audit
Executions	237	None	Unique IDs; duplicates; side; quantity; price; exchange fill time; fee; receipt linkage
Rounds	289	None	Complete round registry; targets; deadlines; outcomes; cancellation/void states
Index ticks	86,710	None	Source/receive clocks; gaps; stale/out-of-order observations
Book snapshots	52,917	None	Token mapping; both sides; depth; source/receive clocks; coverage around decisions
Dataset files	Unknown	None	Manifest completeness; byte-level SHA-256 verification
Collateral, receipts, settlements	Unknown	None	Balance chronology; reservations; realized cash; settlement reconciliation

After verification, construct a ledger containing every observed round, including unavailable, no-order, rejected, cancelled, unfilled, partially filled, and unknown states. Report missingness by cohort, session segment, outcome, and eventual trading status.

Keep distinct fields for:

• Market and data unavailable.
• Decision recorded but no order recorded.
• Order submitted without an exchange acknowledgment.
• Acknowledged order without a recorded fill.
• Recorded fill without a reconciled receipt.
• Unknown decision or execution state.

An absent order is not evidence of an intentional skip. Missing collateral makes sizing and expected-log comparisons unidentified; report affected observations separately.

Preserve source time, local receive time, forecast creation time, decision time, exchange fill time, receipt time, and label availability time. A replay may use an observation only when it would have been available to that process. Intent timestamps cannot substitute for fills.

Competing explanations to test

These are hypotheses, not findings, and should not be ranked by a vote:

Hypothesis	Discriminating evidence
Forecast probabilities are miscalibrated	Calibration and proper scoring across all forecastable rounds, including rounds without bets
Volatility estimate is inadequate	Residual forecast errors conditional on distance, time, volatility and data freshness
Spread, fees or shallow depth consume apparent edge	Forecast edge versus quantity-specific executable net proceeds/cost
Latency changes the opportunity	Source-to-receive and decision-to-fill changes in probability and executable price
Selected executions give a misleading picture	Full round funnel and comparisons conditional on recorded availability
Historical limits or session conditions drive results	Separate configuration cohorts and contiguous session analysis
Accounting creates apparent profits/losses	Fill-to-receipt-to-settlement cash and inventory reconciliation

Do not make volatility the default explanation. Forecast accuracy alone would not establish tradable profitability.

Accounting and comparison design

Proposed accounting: maintain signed inventory separately for each outcome token:

[ q_k(t)=\sum_{\text{exchange-confirmed fills through }t}s_jn_j,\qquad s_j=+1\text{ for buys},;-1\text{ for sells}. ]

Keep actual cash debits, credits, fees and settlement receipts alongside inventory. Do not create a short position unless the recorded venue/account supports it. Buying the opposite outcome is a separate transaction; it must not be treated as a sale or automatic redemption without supported mechanics.

For a proposed sale, walk actual bids for the requested quantity, apply lot/minimum-order constraints, fees and slippage, and reject unsupported quantities. For purchases, walk asks and include all acquisition costs. Partial closes must leave a supported residual lot. The BTC index supplies model information, not executable contract proceeds.

For simulation, terminal marked wealth is:

[ W_T=C_T+\sum_kq_k(T)\operatorname{payoff}_k. ]

Label that separately from received cash until settlement receipts reconcile. Model voids and delayed settlements according to verified venue/data definitions.

Use these matched comparisons:

1. Hold baseline: replay the same supported entry fills and hold through settlement.
2. Existing-policy baseline: replay the recorded positive-net expected-log early-exit logic, if its exact implementation and inputs are available.
3. Alternative exit policies: initially preserve those entry fills, sizes and cohort limits. This isolates exit changes.
4. Full-policy comparison: subsequently include all rounds and explicit availability states, with matched initial collateral, maximum committed capital, cumulative purchases, and exposure.

Report both paired dollar differences and equal-risk results. Cash released by an exit must not silently give one policy additional trading capacity. Keep the current $15 all-in cohort separate from older limits.

Three exact candidate rules

All three are assumed specifications for testing, with no claimed empirical advantage. Freeze them before any future local holdout. Let:

• (p_k(t)): probability of token (k) paying one unit, computed from receive-time-available inputs.
• (L_t(n)): executable net sale proceeds for (n) shares, after costs.
• (\Delta_t(n)): conditional expected terminal-log-wealth difference between selling (n) now and holding those shares, retaining all other positions.

If collateral, model inputs, executable depth, costs, or permissible inventory are unknown, mark the action unevaluable.

1. Full profit exit. At the first recorded decision event where selling the entire remaining lot is executable, net proceeds exceed its allocated acquisition cost, and (\Delta_t(q)>0), close the lot. Otherwise hold.

2. One partial model-edge reduction. At the first decision event where both halves satisfy minimum-order/residual constraints, round half the inventory down to the permitted lot increment. Sell that quantity only if (\Delta_t(n)>0). Permit at most one partial close; settle the residual. This permits a downside reduction even when the lot is below acquisition cost.

3. Time exit. At the first recorded decision event with remaining time at most 20 seconds, sell the entire remaining lot if executable. If unsupported, hold through settlement. This deliberately tests a mechanical time exit against model-driven exits; it need not have positive expected-log advantage.

Common pseudocode:

for event in receive-time order:
    update only information available by this event
    reconcile exchange-confirmed fills and known cash receipts
    select the position's original configuration cohort

    if required state is missing:
        record UNEVALUABLE; continue

    action = frozen_rule(position, current_information)

    if action exists:
        enforce signed inventory, lot size and minimum notional
        walk recorded executable depth for that exact quantity
        apply fees, latency and slippage scenario
        if fill support is insufficient:
            record UNSUPPORTED_OR_UNFILLED
        else:
            simulate supported fills and update cash/inventory

at settlement:
    retain pending claims until receipt reconciliation
    report simulated wealth separately from received cash

Staged adds and re-entry: defer rule selection until the ledger and full round funnel are reconstructable. Evaluate them against the same collateral and cumulative purchase budget, with every new purchase independently passing executable-cost and model-edge checks. Track cumulative purchases, peak capital committed, and repeated exposure to the same round. No add/re-entry recommendation is justified here.

Reproducibility, stress and falsification

No analysis code was executed successfully against this dataset. The following byte-hashing helper is unexecuted and intentionally does not guess the manifest schema:

import hashlib
import urllib.request

BASE = (
    "https://1892-gila-data.community.iamstarchild.com/"
    "r-82882c274d1d0427e27b9da3/"
)

def verified_bytes(relative_path, expected_sha256):
    with urllib.request.urlopen(BASE + relative_path, timeout=30) as r:
        payload = r.read()
    actual = hashlib.sha256(payload).hexdigest()
    if actual.lower() != expected_sha256.lower():
        raise ValueError(f"SHA-256 mismatch: {relative_path}")
    return payload

Inspect the manifest structure first, then verify every listed payload before parsing or analysis. Preserve original bytes: hashing parsed or reformatted JSON is not equivalent. Record the manifest’s own digest; without an independently supplied trusted digest, it is an integrity reference rather than independent proof of authenticity. Reconcile flattened CSV rows to nested raw records rather than counting both representations as separate observations.

Proposed stress grid: run the verified recorded fee schedule and displayed depth first, then independently test twice the fees, 50% displayed depth, one additional price tick of adverse slippage, and one additional recorded book-update interval of latency. Also report a combined adverse scenario. These are assumed stresses, not observed execution conditions. Missing depth must produce an unsupported result, not a fabricated fill.

For each baseline/candidate/cohort, report:

• Net cash and settlement-adjusted P&L, paired difference, and expected-log results only where collateral is known.
• Maximum drawdown, worst round, worst contiguous hour, and consecutive-loss runs.
• Peak committed capital, turnover, fees, unsupported fills and residual inventory.
• Share of profit attributable to the largest one and five rounds; results excluding those rounds.
• Contiguous session segments, data-gap segments and time-to-expiry bands.
• Outstanding orders, partial fills and unsettled claims at window boundaries.

No significance claim is supported here. This exploratory window must not be relabeled as a holdout.

Strongest proposed falsification: replay each exit against holding the identical supported entry inventory, using only information available at the decision, executable quantity-specific proceeds, complete costs, and reconciled settlement. If the apparent advantage disappears under that reconstruction—or depends on impossible fills, unavailable information, or a few exceptional rounds—the candidate has failed this exploratory test. Only a subsequently frozen local holdout could assess persistence.

Ranked missing-data requests:

1. Accessible manifest and all payloads, plus an independently recorded manifest digest if available.
2. Exchange fills, receipts, balances, reservations and settlements, including opening inventory and boundary positions.
3. Timestamped executable books and venue constraints: tick/lot sizes, minimums, fees, order types, cancellation and redemption mechanics.
4. Complete round/decision/order funnel, explicit unavailable states, clock definitions and configuration history.
5. Forecast inputs and outputs as actually available, followed by an untouched, fixed local holdout.

Until those are available, hold, profit exits, downside reductions, partial closes, time exits, and staged adds/re-entry remain unranked. No orders or live changes were made.

I cannot determine whether Madame Gila should hold, exit earlier, reduce positions, or add/re-enter from verified evidence in this session. The dataset was inaccessible, so no file passed SHA-256 verification and no empirical trading comparison was performed. Neither baseline profitability nor volatility as the cause is established.

The browser could not retrieve the research brief, README, known issues, data dictionary, or manifest. A separate Python retrieval failed with a DNS-resolution error. These links identify attempted sources, not verified citations. I cannot honestly supply five supporting quotations; the final citation array is therefore empty.

What follows is an unexecuted research specification, not a finding or trading recommendation.

Coverage and missingness

The window and counts below come exclusively from your prompt and remain unverified.

Item	Prompt-reported coverage	What remains unresolved
Window	2026-10-28 13:22Z–2026-10-29 13:22Z	Boundary inclusion; positions opened before or settled after it
Rounds	289	Complete round roster, outcomes, targets, cancellation/settlement states
Executions	237	Meaning of “execution”; unique fills; partial fills; reversals; receipts
Index ticks	86,710	Gaps, duplicate/corrected ticks, source-to-receive delay
Book snapshots	52,917	Contract/side coverage, depth completeness, actionable age
Current limit	$15 all-in	Effective configuration timestamps; definition of all-in
Other cohorts	Different historical limits	Membership and configuration changes
Verified files / analyzed records	0 / 0	Entire dataset

Do not calculate a participation or fill rate as 237/289: the numerator may include multiple events per round and has not been defined. Missingness rates also remain unknown.

After byte verification, the audit should:

• Build the denominator from every observed round, including unavailable, no-order, rejected, unfilled, cancelled and unresolved states. Preserve “no recorded reason”; do not translate it into “deliberate skip.”
• Join rounds → forecasts → decisions → intents → orders → fills → settlements/receipts. Report unmatched records and duplicate identifiers at each join.
• Separate observed absence from absent telemetry. Missing book data is not zero liquidity; missing collateral is not zero collateral.
• Report gaps and missing fields by round, session, contract, state and configuration cohort. Keep raw JSONL and flattened CSV reconciliation explicit: nested arrays may expand into multiple rows.
• Identify left-censored inventory and right-censored settlement/receipts. Do not count unsettled or unreceived claims as received cash.

The manifest must be retrieved first and every referenced file hashed over its original downloaded bytes before parsing or analysis. Reject missing files, mismatches, ambiguous paths and undeclared analysis inputs. Record the manifest’s own digest as provenance; a self-calculated digest alone does not independently authenticate it.

Competing explanations to test

These are hypotheses, with no ranking supported by the inaccessible data.

Hypothesis	Distinguishing check
Forecast probabilities are miscalibrated	Evaluate out-of-sample calibration and proper scores on all rounds with available causal forecasts, by horizon and target distance
Volatility estimate is poorly specified	Compare frozen alternative volatility estimators on identical forecast opportunities; require probability improvement before attributing P&L changes to volatility
Fees/spread consume apparent edge	Decompose gross forecast edge, executable spread, entry/exit fees and realized net receipts
Decision or quote latency matters	Stratify by observed receive age and order-to-fill delay; replay only information available at each decision
Depth, minimum order or rounding prevents execution	Compare intended versus supported quantity and recorded fill outcomes
Trading-state selection distorts conclusions	Compare all-round opportunity states with selected orders; preserve unknown reasons
Inventory/collateral accounting creates apparent performance	Reconcile signed fills, costs, locks, settlement and receipts
Results reflect a few rounds or one session	Remove top contributors, examine contiguous time blocks and report cohort-specific drawdowns

Required accounting and replay semantics

Use separate source, receive, forecast, decision, fill, label and receipt clocks. A feature is eligible only after its recorded receipt and computation availability. Source time alone is insufficient. Labels are unavailable until their recorded publication/receipt. Intent and state timestamps must never substitute for exchange fill timestamps.

For each contract, reconstruct:

inventory = opening_inventory
            + Σ confirmed_buy_quantity
            - Σ confirmed_sell_quantity

cash = opening_cash
       - Σ buy_notional + Σ sell_notional
       - Σ actual_fees
       + Σ settlement_cash_receipts
       - Σ other_supported_cash_charges

Track locked collateral, receivables and unknown balances separately. Positions in complementary contracts remain separate instruments until actual netting or redemption mechanics are documented. An opposite-side purchase is not automatically a close.

For an action, walk the correct contract’s bid or ask depth, respecting price/quantity increments, minimum size/notional, fee rounding, available inventory and collateral. Unsupported residual inventory remains open. Do not create short inventory or assume borrowing permissions. A BTC index mark is never a contract liquidation quote.

A snapshot establishes displayed liquidity at its observation time, not a guaranteed future fill. Counterfactual fills must therefore be labelled simulated and include latency/depth stress. If required data are missing, return UNRESOLVED, not an invented fill.

Three exact candidate rules

All thresholds below are assumed research parameters, chosen without inspecting outcomes. Freeze them before a future local holdout. First reproduce the actual baseline: its entry logic, historical configuration and existing positive-net expected-log exits. Also compare a settlement-hold reference that changes exits only.

For the rules below:

• τ is seconds to the documented trading expiry.
• V(a) is expected log terminal wealth after action a, using the causal forecast, supported settlement payoffs, fees, collateral and executable quantity.
• V(hold) includes all existing inventory and joint settlement exposure. Do not sum independent per-position log utilities where outcomes are dependent.
• If wealth/collateral or required joint exposure is unknown, V is unresolved.
• q_full is the maximum valid executable reduction up to current inventory; it may leave a residual.
• q_half is half the current inventory rounded down to the lot increment, executable in full and meeting all minimums.
• No action may cross through zero inventory.

1. Profit-only exit. Close q_full only when it equals the entire position, conservative net sale proceeds exceed the remaining actual acquisition basis including entry costs, and V(close) > V(hold). Otherwise hold. This may duplicate existing behavior; if so, record it as a replication check rather than a new policy.

2. Model-edge reduction with partial closes. At each causal decision, compare hold, close q_half, and close q_full. Execute the action with greatest V only if it strictly exceeds V(hold); ties choose hold, then the smaller reduction. No realized-profit prerequisite. This allows downside reduction without an arbitrary BTC-price stop.

3. Time-gated reduction with one staged add/re-entry. Before the 20-second cutoff, preserve baseline exits and permit at most one additional buy event per round, including re-entry from flat. Its quantity is at most the original entry quantity, at most the amount needed to reach a fresh baseline half-edge quarter-Kelly target, and within the applicable cohort’s documented all-in cap. Require positive incremental V, known collateral and full protected-depth/fee feasibility. At the first executable decision with τ ≤ 20, attempt q_full; retry only for the residual and only before trading closes. No subsequent additions.

Rule 3 bundles two changes, so report ablations with adds disabled and with the time exit disabled to identify their contributions. Those are attribution checks, not extra independently tuned candidates.

Shared pseudocode, not executed:

for cohort in documented_configuration_cohorts:
    for event in events_ordered_by_recorded_availability:
        update_received_information(event)
        reconcile_confirmed_fills_and_receipts(event)

        if not event.is_decision:
            continue

        # Preserve unavailable/no-order/unfilled states in the output.
        if required_clocks_or_inventory_are_unknown():
            record("UNRESOLVED")
            continue

        actions = policy_actions(causal_state, frozen_parameters)
        actions = enforce_signed_inventory_and_cohort_limits(actions)
        actions = enforce_lots_minimums_collateral_and_costs(actions)

        for action in actions:
            assess_causal_contract_depth(action)
            simulate_submission_latency_and_fill_bounds(action)
            # Never treat an intent, snapshot or index tick as a fill.

        choose_using_policy_rule_or_record_unresolved()
        settle_only_from_supported_contract_outcomes()
        recognize_cash_only_on_supported_receipts()

Matched comparisons and stress

No values for these comparisons were calculated.

Run two analyses separately:

1. Conditional exit comparison: clone each reconstructed confirmed entry and opening state into baseline, hold and the three candidates. This isolates management after entry but does not establish performance over the opportunity population.
2. All-round policy replay: use all 289 prompt-reported rounds and all recorded states, including rounds with no confirmed position. Keep original entry eligibility fixed for exit comparisons; apply the staged-add exception only in Rule 3. Report unresolved rounds rather than excluding them silently.

Use paired per-round differences within each configuration cohort. Do not pool old limits with the $15 cohort. Report both total economic P&L and cash receipts, remaining inventory, turnover, capital-time usage, fill coverage and unresolved exposure.

For equal-risk comparisons, retain identical initial entries where possible and cap candidates at the same documented maximum loss/collateral budget. Also report realized peak exposure. Where additions or earlier release of collateral alter risk, resimulate sizing under a common budget; do not linearly scale P&L through minimum-order and depth constraints. Without collateral, expected-log and equal-risk conclusions remain unresolved.

Suggested frozen stress grid—assumptions, not measured market conditions:

Dimension	Scenarios
Visible executable depth	100%, 50%, 25% of recorded depth
Adverse execution price	Recorded ladder; one tick worse; two ticks worse
Submission delay	Observed causal latency where available; additional 250 ms and 1 s
Fees	Documented schedule; 1.25× and 1.5× cash fee
Missing execution evidence	No-fill bound and supported partial-fill bound; never automatic full fill

Record how many decisions lose evaluability under each stress. Keep costs represented once: depth-walk impact, adverse-price stress and fees must not be double counted.

Downside checks should include worst round, consecutive losses, peak-to-trough drawdown, worst contiguous hour, maximum collateral use, residual-at-expiry inventory, and cash-receipt delays. Report the contribution of the largest one and five profitable rounds; recompute after removing them. Use fixed UTC session blocks and leave-one-block-out sensitivity within cohorts. With a single exploratory day, these are descriptive robustness checks, not independent replications or evidence of significance.

Strongest falsification and missing-data priorities

The strongest attempted falsification is a frozen, future local holdout using the same opportunities, configuration and risk budget, with causal contract execution and full receipts. A candidate has not earned adoption if its paired net improvement disappears under conservative executable-depth/cost assumptions, depends on unresolved balances, or is driven by a few rounds. These are proposed rejection criteria, not test results.

Ranked requests:

1. Accessible immutable archive and manifest, including the four introductory documents and all referenced files. This is the immediate blocker.
2. Fill and financial ledger: exchange fill IDs/times, side, quantity, price, fees, opening inventory, collateral/locks, settlements and receipt reconciliation.
3. Contract execution data: both sides’ timestamped depth, sequence/gap indicators, receive times, fee schedule, tick/lot/minimums, settlement/redemption mechanics.
4. All-round decision lineage: forecasts, inputs and availability clocks; explicit unavailable/no-order/rejection/unfilled states; order lifecycle joins.
5. Configuration history and fixed holdout specification: precise entry-time semantics, cap changes, sizing/exit versions, and precommitted local evaluation windows.

Current conclusion: there is no verified basis here to favor profit-taking, downside reductions, partial exits, timed exits or staged additions over the existing policy or settlement hold. The defensible next step is the hash-verified reconstruction and matched replay above; no orders or live changes were made.

I cannot establish whether profit exits, downside reductions, partial closes, time exits, or staged adds/re-entry improve this strategy from this run. The dataset was inaccessible: the browser returned access errors, direct retrieval failed with a DNS-resolution error, and no local dataset files were available. Consequently, no hashes were verified, no dataset analysis was performed, and no profitability or comparative-performance results are reported.

The useful next step is an inventory-and-execution audit followed by matched policy replay. Volatility misspecification is only one competing explanation; neither it nor baseline profitability should be presumed.

The following is an explicitly unexecuted research specification, not findings from the dataset.

Evidence and coverage audit

I attempted the required research brief, README, known issues, data dictionary, manifest, and dataset root. These links identify attempted sources; they do not substantiate unread contents.

Item	Status
Window: 2026-10-28 13:22Z through 2026-10-29 13:22Z	User-reported; unverified
289 rounds; 237 executions; 86,710 index ticks; 52,917 book snapshots	User-reported; unverified
Existing diffusion model, entry window, sizing and exit logic	User-reported; unverified against records
Current $15 all-in cap and separate historical limits	User-reported; cohort membership unresolved
Manifest file inventory and SHA-256 matches	Unresolved; zero verified files
Unique execution IDs, fill quantities and duplicate events	Unresolved
Round-level no-order, unavailable, unfilled and censored states	Unresolved
Executable contract quotes, receipt latency and book gaps	Unresolved
Opening inventory, collateral, fees, settlement receipts	Unresolved
Net returns, drawdown, policy comparisons or significance	Not calculated

Do not divide 237 executions by 289 rounds and call the result participation: executions may include multiple fills or actions within a round.

Before analysis, fetch the manifest and every listed file as bytes, verify all SHA-256 values, and stop on any missing file or mismatch. Preserve the manifest itself and its retrieval metadata. Matching a downloaded manifest establishes consistency with that manifest; independent authenticity requires an independently trusted digest or signature.

After verification, build one row for every observed round, with associated opportunities and events:

• Record explicit unavailable, no-order, rejected, canceled, unfilled, partially filled, filled and unknown states. An absent order is unknown, unless evidence identifies a deliberate skip.
• Separate source event, local receive, forecast creation, decision, order submission, exchange fill, settlement-label availability and receipt timestamps.
• At decision time (t), use only information received by (t). A forecast also needs a creation timestamp no later than (t). Labels belong only in subsequent scoring.
• Identify the entry-time and remaining-time conventions from the documentation before interpreting “45s” and “20s.”
• Report missingness by field, round, policy cohort and session block—not just globally.
• Reconcile raw nested events against flattened CSVs by stable identifiers; do not count both representations as separate observations.

Competing explanations

These are hypotheses, with no ranking supported by measurements:

Explanation	Discriminating check
Probability model is miscalibrated	Score forecasts across all eligible observed rounds, by horizon and target distance; investigate volatility only alongside other model inputs.
Apparent edge disappears after costs	Compare forecast value with side-specific executable depth, fees, slippage and settlement costs at supported sizes.
Stale or misaligned information creates apparent edge	Reconstruct what had arrived before each decision; compare forecast age, book age and actual execution delay.
Execution selection distorts results	Compare submitted, filled, unfilled, unavailable and unknown opportunities; account for cancellation races and adverse selection.
Inventory or receipts are miscounted	Rebuild balances from confirmed fills and receipts; reconcile against snapshots and terminal balances.
Different caps or concentrated sessions explain performance	Keep cohorts separate; examine contributions by round and contiguous session block.
Early exits sacrifice subsequent recovery or avoid reversals	Compare executable close proceeds with subsequent settlement value on identical entry inventory.

A volatility explanation should survive these competing explanations before receiving priority.

Inventory and accounting requirements

Maintain signed net units per contract. For an Up contract and a Down contract:

[ I_{c,t}=I_{c,0}+\sum_{\text{confirmed fills }j\le t}s_jq_j, \qquad s_j=+1\text{ for buys},\ -1\text{ for sells}. ]

Keep both contracts separately. Selling Up reduces Up inventory; buying Down creates a different holding unless venue rules and actual conversion receipts establish otherwise. Canceling an order does not reverse a fill. Unknown opening inventory prevents a complete balance reconstruction.

Cash changes are:

[ \Delta C_{\rm buy}=-qp-f,\qquad \Delta C_{\rm sell}=qp-f,\qquad \Delta C_{\rm settlement}=\text{confirmed net receipt}. ]

Use actual supported lots and minimum notionals. A partial close may leave dust; do not erase it. Separate estimated terminal entitlement from received settlement cash, and never credit both as independent proceeds. Missing collateral stays missing: dollar cash-flow differences may be identifiable even when returns on capital and expected-log utility are not.

A BTC index price cannot value a contract exit. A hypothetical sale needs bids for that exact contract and enough executable depth for the proposed quantity, with fees and execution uncertainty applied.

Three candidate rules for later testing

These are assumed research choices, not optimized or recommended settings. Compare them with both the recorded existing policy and hold-to-settlement using matched entry inventory.

For every rule, freeze all entry forecasts and sizing inputs. Use only confirmed available holdings after reserving outstanding sell commitments. Proposed execution uses the first valid book received at least one second after the decision; reject a quote whose source age exceeds one second. Those one-second thresholds are assumptions, to stress explicitly.

A snapshot supplies a conditional execution simulation, not proof of a fill. If required depth, clock mapping, costs, collateral or order constraints are missing, mark the action unidentifiable, rather than assigning a zero-cost fill.

Define:

• (U_{\rm hold}): expected terminal log wealth holding the current portfolio.
• (U_{\rm close}(q)): expected terminal log wealth after selling (q), using executable depth and all supported costs.
• Both evaluate the same joint settlement outcomes, cash, inventory and liabilities.
• Compute neither utility when collateral or relevant liabilities are unknown, or terminal wealth is nonpositive in a possible state.

1. Model-edge reduction. At each new forecast, consider every feasible sell quantity on the venue lot grid. Execute the quantity maximizing (U_{\rm close}(q)) only if it strictly exceeds (U_{\rm hold}). This permits a realized loss when retaining the position has worse modeled utility.

2. Partial profit exit. At each new forecast, consider selling half of currently available inventory, rounded down to the lot grid. Require a legal sell and either a legal residual holding or documented permissible dust. Execute only if proceeds less exit costs exceed the allocated acquisition cost and expected log wealth improves. Permit at most one such partial close per contract per round. Use FIFO solely as a declared lot-accounting convention.

3. Time exit. At the first decision event with (0<T\le10) seconds remaining, attempt to sell all available inventory, subject to executable depth and legal quantities. Keep any unfilled remainder through settlement. Do not infer a fill from the trigger or from an intent timestamp.

UNEXECUTED POLICY PSEUDOCODE

for each independently identified cap/configuration cohort:
    for each observed round:
        initialize inventory, cash, reservations and unknown-state flags
        process received events in causal order
        apply confirmed fills and actual receipts exactly once

        at each policy decision:
            use only forecasts and market data already received
            q_available = confirmed holdings - outstanding sell commitments
            if q_available <= 0: continue

            if candidate is MODEL_EDGE:
                require identifiable wealth and outcome probabilities
                q = legal lot-grid quantity maximizing expected_log_after_close
                submit only if utility(q) > utility(hold)

            if candidate is PARTIAL_PROFIT and no prior partial close:
                q = floor_to_lot(q_available / 2)
                require legal order, supported residual and identifiable wealth
                submit only if net_profit(q) > 0 and utility(q) > utility(hold)

            if candidate is TIME_EXIT and first event with 0 < T <= 10:
                q = q_available
                submit legal executable portion

            simulate execution only with post-latency contract book and depth
            apply fill quantity and costs; preserve remainder and unknowns

        reconcile settlement entitlement, receipt and remaining inventory

For specialty coverage:

Policy	Treatment
Hold to settlement	Essential matched benchmark; use settlement entitlement and receipts correctly.
Existing positive-net expected-log exit	Essential operational baseline; reconstruct its exact recorded version.
Downside/model-edge reduction	Candidate 1; trigger is utility deterioration, not an arbitrary BTC price stop.
Partial profit close	Candidate 2; test recovery sacrificed, execution costs and residual dust.
Time exit	Candidate 3; test late liquidity and forced-sale losses.
Staged adds/re-entry	Not nominated among the three candidates. Requires additional risk allocation and executable asks; do not treat an exit as automatically funding another trade.

Staged adds and re-entry would need joint portfolio sizing, confirmed available collateral, outstanding-order reservations and a precise interpretation of the applicable all-in cap. They should not be compared with exit-only policies at a larger risk budget.

Matched comparisons, stress and downside checks

Run two distinct analyses:

1. Exit attribution: replay identical confirmed entry lots through hold, existing exits and each candidate. This isolates management of acquired inventory, but remains conditional on actual entry selection.
2. All-round policy coverage: include every observed round and every recorded opportunity state. An unfilled submission contributes no acquired inventory; an unexplained missing order remains unknown. Report identifiable and unidentifiable opportunities separately.

For equal risk, preserve initial inventory and capital in the exit-only comparison. For any later adds/re-entry study, impose the same initial collateral, applicable cap and maximum loss budget. Keep the current $15 cohort separate from older caps; merely scaling historical P&L does not reproduce lot-size and depth effects.

Report paired dollar cash-flow differences and, where collateral is known, changes in expected/realized log wealth and returns on capital. Publish both total-policy coverage and pairwise common-support coverage. Excluding hard-to-execute cases can otherwise make an exit policy appear better.

Assumed stress grid, not executed:

• Depth available: 100%, 50%, 25% of displayed eligible depth.
• Additional adverse execution: 0, 1, 2 venue ticks.
• Execution latency: 1, 2, 5 seconds.
• Recorded fees; then incremental fee burden of 25% and 50%, with explicit treatment of rebates and minimum fees.
• Uncertain fills: show separate filled/unfilled scenarios where justified; do not label either a universal worst case.
• Settlement delays and unreconciled receipts: retain tied-up collateral and distinguish receivable from cash.

Include maximum drawdown where equity is identifiable, worst round, worst contiguous hour, loss streaks, inventory-time exposure, dust, turnover and total costs. Show results by UTC hour, fixed contiguous four-hour block, side, holding duration and cap cohort. Report the share of gains attributable to the best round and best hour, and results after removing each. One day cannot establish robustness across sessions or regimes.

Strongest falsification and missing-data priorities

Strongest falsification test: keep the exact entry inventory fixed and ask whether a candidate’s apparent benefit survives causal receive-time replay, realistic execution, complete receipts and equal capital. If the benefit reverses after those corrections, or exists only after excluding unavailable quotes or one profitable session block, reject the claimed improvement for this sample. Passing remains exploratory; it does not establish future profitability.

Freeze the candidate definitions, cohort rules, costs, execution assumptions and evaluation criteria before using a local, fixed future holdout. No holdout was accessed, created or tested here.

Ranked requests:

1. An accessible complete archive plus manifest, ideally with an independently published manifest digest. This is the immediate blocker.
2. Exchange-confirmed fills and order lifecycle events: IDs, contract, side, quantity, price, fees, exchange timestamps, receive timestamps and cancel/fill races.
3. Opening balances and collateral, outstanding liabilities, settlement/conversion receipts and closing balances.
4. Contract-specific depth with source/receive clocks, tick/lot/minimum-order rules, fee schedules and valid book-state reconstruction.
5. Versioned decision and forecast records, exact cap cohort, feature cutoffs, unavailable/no-order reasons and historical configuration.
6. Settlement definitions and label availability, plus the fixed local future-holdout specification.

I could not meet the requested five verified source quotations because no source contents were retrievable. The links above document attempted access, not verified evidence. The required citation block is therefore empty rather than fabricated.