disprove 0.1.0__tar.gz

disprove-0.1.0/.github/workflows/verify.yml

@@ -0,0 +1,20 @@
+name: verify
+
+on:
+  push:
+    branches: ["**"]
+  pull_request:
+
+jobs:
+  verify:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+      - run: uv python install 3.12
+      - run: uv sync
+      - run: uv run ruff check .
+      - run: uv run pytest -q

disprove-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+.venv/
+dist/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+reports/

disprove-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vadims
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

disprove-0.1.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: disprove
+Version: 0.1.0
+Summary: The strategy evidence engine: honest PASS/WARN/BLOCK verdicts on trading strategies. Its credential: it blocked its own flagship strategy.
+Project-URL: Homepage, https://github.com/866y4tb8hc-coder/disprove
+Author: Vadims
+License: MIT
+License-File: LICENSE
+Keywords: audit,backtesting,evidence,quant,trading,validation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.26
+Requires-Dist: polars>=1.0
+Requires-Dist: scipy>=1.11
+Description-Content-Type: text/markdown
+
+# Disprove
+
+**The strategy evidence engine.** Disprove decides whether a trading strategy
+has earned the right to risk money — and refuses when it hasn't.
+
+```
+pip install disprove
+```
+
+## Its credential: it blocked its own flagship strategy
+
+Disprove was extracted from a private trading-research system whose best
+strategy — delta-neutral funding-rate carry, 6.7 years of real Binance data,
+**+11.8%/yr average** — looked fundable by every conventional measure. The
+fixed-horizon audit returned **BLOCK**: only ~1 month in 3 was actually clean;
+the average was carried by two hot regimes. Thresholds were anchored to
+observables and committed in writing *before* the run. The verdict was
+accepted and the strategy was never funded.
+
+A validation tool that has never rejected its owner's favorite idea is a
+rubber stamp. Read the full story: [docs/case-study.md](docs/case-study.md).
+
+## 60-second demo (no keys, no data, no network)
+
+```bash
+python examples/run_synthetic_audit.py
+```
+
+```text
+consistent   -> PASS  (4P/0W/0B of 4, pass_ratio=1.00, reasons=clean)
+inconsistent -> WARN  (1P/3W/0B of 4, pass_ratio=0.25, reasons=['pass_ratio_below_threshold'])
+gapped       -> BLOCK (3P/0W/2B of 5, pass_ratio=0.60, reasons=['blocked_chunks_present'])
+```
+
+The third line is the point: a **profitable-looking history with missing data
+is blocked on integrity** — before performance is even considered.
+
+## What it does
+
+1. **Fixed-horizon chunks.** Your strategy's history is split into fixed
+   calendar windows (default 30 days). Every window between first and last
+   observation is emitted — missing history cannot disappear from the count.
+2. **Integrity blocks.** Partial windows, data gaps, and thin chunks BLOCK.
+   Untrustworthy evidence is not neutral; it is disqualifying.
+3. **Per-chunk verdicts.** PASS needs positive fee-adjusted PnL and bounded
+   drawdown *inside each window* — a pretty average cannot hide bad months.
+4. **An overall verdict you committed to in advance.** Anchor your thresholds
+   to observables (your max drawdown, your monthly expectancy), write them
+   down, then run. `evaluate_overall_verdict` does the rest.
+
+```python
+from disprove import (
+    CostModel, CarryAuditPolicy, FixedHorizonChunkPolicy,
+    audit_funding_carry_chunks,
+)
+
+audit = audit_funding_carry_chunks(
+    funding_frame,                      # polars: funding_time (ms), funding_rate
+    cost_model=CostModel(spot_fee_bps=10, perp_fee_bps=5, half_spread_bps=1, slippage_bps=2),
+    policy=CarryAuditPolicy(window=6, notional_usdt=10_000),
+    chunk_policy=FixedHorizonChunkPolicy(
+        catastrophic_net_loss_usdt=-150.0,  # anchor: your full-history maxDD
+        max_pass_drawdown_usdt=40.0,        # anchor: one month's expected profit
+    ),
+    horizon_ms=30 * 24 * 3600 * 1000,
+)
+print(audit.overall.verdict)            # PASS | WARN | BLOCK — with receipts
+```
+
+Also included: cost-charged vectorized carry backtests (`run_backtest`,
+basis-aware `run_backtest_v2`), deflated Sharpe and walk-forward splits
+(`disprove.metrics`, `disprove.walkforward`), and a CLI (`disprove --help`)
+that writes auditable Markdown + CSV verdict artifacts.
+
+## What this is not
+
+- Not a signal service. Not a profit bot. **No profitability claims** — the
+  flagship case study documents a rejection; that is the product.
+- Not a full backtesting framework: it is the *judgment layer* you put on top
+  of whichever one you use.
+
+## Provenance
+
+Extracted from a private research system with 1,000+ tests; this public core
+ships with its own test suite and CI. The private system also rejected, with
+receipts: orderbook scalping for non-colocated operators (fees + adverse
+selection) and cross-sectional funding rotation (turnover costs).
+
+## Paid: independent audits
+
+The author runs this gate against client strategies under pre-committed
+thresholds — your rules, your data window, an honest verdict with receipts.
+Contact via GitHub issues or the email in the commit log.
+
+MIT licensed.

disprove-0.1.0/README.md

@@ -0,0 +1,95 @@
+# Disprove
+
+**The strategy evidence engine.** Disprove decides whether a trading strategy
+has earned the right to risk money — and refuses when it hasn't.
+
+```
+pip install disprove
+```
+
+## Its credential: it blocked its own flagship strategy
+
+Disprove was extracted from a private trading-research system whose best
+strategy — delta-neutral funding-rate carry, 6.7 years of real Binance data,
+**+11.8%/yr average** — looked fundable by every conventional measure. The
+fixed-horizon audit returned **BLOCK**: only ~1 month in 3 was actually clean;
+the average was carried by two hot regimes. Thresholds were anchored to
+observables and committed in writing *before* the run. The verdict was
+accepted and the strategy was never funded.
+
+A validation tool that has never rejected its owner's favorite idea is a
+rubber stamp. Read the full story: [docs/case-study.md](docs/case-study.md).
+
+## 60-second demo (no keys, no data, no network)
+
+```bash
+python examples/run_synthetic_audit.py
+```
+
+```text
+consistent   -> PASS  (4P/0W/0B of 4, pass_ratio=1.00, reasons=clean)
+inconsistent -> WARN  (1P/3W/0B of 4, pass_ratio=0.25, reasons=['pass_ratio_below_threshold'])
+gapped       -> BLOCK (3P/0W/2B of 5, pass_ratio=0.60, reasons=['blocked_chunks_present'])
+```
+
+The third line is the point: a **profitable-looking history with missing data
+is blocked on integrity** — before performance is even considered.
+
+## What it does
+
+1. **Fixed-horizon chunks.** Your strategy's history is split into fixed
+   calendar windows (default 30 days). Every window between first and last
+   observation is emitted — missing history cannot disappear from the count.
+2. **Integrity blocks.** Partial windows, data gaps, and thin chunks BLOCK.
+   Untrustworthy evidence is not neutral; it is disqualifying.
+3. **Per-chunk verdicts.** PASS needs positive fee-adjusted PnL and bounded
+   drawdown *inside each window* — a pretty average cannot hide bad months.
+4. **An overall verdict you committed to in advance.** Anchor your thresholds
+   to observables (your max drawdown, your monthly expectancy), write them
+   down, then run. `evaluate_overall_verdict` does the rest.
+
+```python
+from disprove import (
+    CostModel, CarryAuditPolicy, FixedHorizonChunkPolicy,
+    audit_funding_carry_chunks,
+)
+
+audit = audit_funding_carry_chunks(
+    funding_frame,                      # polars: funding_time (ms), funding_rate
+    cost_model=CostModel(spot_fee_bps=10, perp_fee_bps=5, half_spread_bps=1, slippage_bps=2),
+    policy=CarryAuditPolicy(window=6, notional_usdt=10_000),
+    chunk_policy=FixedHorizonChunkPolicy(
+        catastrophic_net_loss_usdt=-150.0,  # anchor: your full-history maxDD
+        max_pass_drawdown_usdt=40.0,        # anchor: one month's expected profit
+    ),
+    horizon_ms=30 * 24 * 3600 * 1000,
+)
+print(audit.overall.verdict)            # PASS | WARN | BLOCK — with receipts
+```
+
+Also included: cost-charged vectorized carry backtests (`run_backtest`,
+basis-aware `run_backtest_v2`), deflated Sharpe and walk-forward splits
+(`disprove.metrics`, `disprove.walkforward`), and a CLI (`disprove --help`)
+that writes auditable Markdown + CSV verdict artifacts.
+
+## What this is not
+
+- Not a signal service. Not a profit bot. **No profitability claims** — the
+  flagship case study documents a rejection; that is the product.
+- Not a full backtesting framework: it is the *judgment layer* you put on top
+  of whichever one you use.
+
+## Provenance
+
+Extracted from a private research system with 1,000+ tests; this public core
+ships with its own test suite and CI. The private system also rejected, with
+receipts: orderbook scalping for non-colocated operators (fees + adverse
+selection) and cross-sectional funding rotation (turnover costs).
+
+## Paid: independent audits
+
+The author runs this gate against client strategies under pre-committed
+thresholds — your rules, your data window, an honest verdict with receipts.
+Contact via GitHub issues or the email in the commit log.
+
+MIT licensed.

disprove-0.1.0/docs/case-study.md

@@ -0,0 +1,86 @@
+# Case Study: The Gate That Blocked Its Own Strategy
+
+*Buyer-facing artifact. Every number below comes from committed, reproducible
+runs; nothing is adjusted for presentation. Reproduction commands included.*
+
+## The setup
+
+the engine's flagship strategy candidate was delta-neutral funding-rate carry on
+BTCUSDT — a documented structural premium, tested against 6.72 years of real
+Binance funding history (7,363 settlement intervals, 2019-2026).
+
+The aggregate evidence looked good:
+
+- Always-in harvest, full history: **+11.8%/yr**, max drawdown **-1.5%**
+- Walk-forward out-of-sample (config chosen on train folds only): **+5.9%/yr**
+- Survived a basis-drift audit (v2 engine: basis mark-to-market ≈ neutral)
+- Survived a look-ahead audit (strict one-period signal lagging moved OOS
+  returns by only -0.16pp/yr — measured, not argued)
+
+Most validation systems would fund this. Disprove blocked it.
+
+## The gate
+
+The fixed-horizon chunk audit splits the entire history into 30-day windows
+and demands that the strategy's core claim — "the edge is in continuously
+being in the position" — hold *month by month*, not just on average:
+
+- any chunk with missing data, a partial window, or too few observations
+  **blocks** (untrustworthy evidence is not neutral; it is disqualifying);
+- a chunk losing more than the strategy's entire historical max drawdown
+  **blocks** (catastrophic);
+- a clean PASS requires positive net PnL with drawdown bounded by one month's
+  expected profit;
+- at least 70% of chunks must PASS.
+
+Thresholds were anchored to observables outside the gate (full-history maxDD,
+lean-regime monthly expectancy) and **committed in writing before the run**
+(the calibration record (committed before the run)) — they cannot be tuned after seeing
+the verdict.
+
+## The verdict
+
+| Setup | Verdict | PASS/WARN/BLOCK | Pass ratio (need ≥ 0.70) |
+|---|---|---|---|
+| BTCUSDT, 6-period signal | **BLOCK** | 22 / 50 / 10 of 82 | 0.268 |
+| BTCUSDT, 12-period signal | **BLOCK** | 29 / 52 / 1 of 82 | 0.354 |
+| ETHUSDT, 6-period signal | **BLOCK** | 23 / 45 / 12 of 80 | 0.287 |
+
+The diagnosis is precise: catastrophic months are rare (1 of 82 in the best
+configuration), but **roughly two out of three months earn nothing**. The
+attractive average is carried by a few hot regimes (2020-2021). A strategy
+whose monthly consistency fails does not get promoted — it stays in research,
+unfunded.
+
+## Why this matters to you
+
+1. **The gate is adversarial to its owner.** It was pointed at the project's
+   own best work, with pre-committed thresholds, and the BLOCK was accepted.
+   That is the behavior you need from a validation layer — and the behavior
+   retail backtest tooling structurally cannot offer you.
+2. **Integrity outranks PnL.** A profitable-looking history with data gaps
+   blocks on integrity before performance is even considered. (60-second
+   demo: `uv run python examples/run_synthetic_audit.py`.)
+3. **Everything is reproducible.** Each verdict ships as a Markdown + CSV
+   artifact recording the data range, method, policy, and per-chunk numbers
+   (the private evidence archive (verdict tables reproduced below)); the audit reruns deterministically from one
+   command.
+
+## The same gate, on your strategy
+
+This pipeline is what the **Strategy Evidence Audit** runs against client
+strategies (see the paid audit offer): your rules, your data window, an
+anchored policy agreed *before* the run, and an honest PASS/WARN/BLOCK with
+the receipts.
+
+## Reproduce it
+
+```bash
+# with your own funding-rate parquet (funding_time ms, funding_rate):
+disprove --funding funding_BTCUSDT.parquet --symbol BTCUSDT \
+  --setup-id carry:BTCUSDT:w12 --window 12 \
+  --catastrophic-net-loss-usdt -150 --max-pass-drawdown-usdt 40
+```
+
+*Disclosure: Disprove makes no profitability claims. This document describes a
+rejection. That is the product.*

disprove-0.1.0/examples/run_synthetic_audit.py

@@ -0,0 +1,86 @@
+"""Quickstart: run the fixed-horizon evidence gate on synthetic data.
+
+No exchange account, no API keys, no real market data, no network — this is
+the fastest way to see what Disprove delivers: an auditable PASS/WARN/BLOCK verdict
+over strategy evidence.
+
+Run:
+    python examples/run_synthetic_audit.py
+
+It builds three synthetic funding-rate histories (a consistent earner, an
+inconsistent one, and one with a data gap), runs the same audit pipeline used
+on real evidence, and prints the three verdicts. Expected output ends with:
+    consistent  -> PASS
+    inconsistent-> WARN or BLOCK
+    gapped      -> BLOCK (data integrity, not performance)
+"""
+
+from __future__ import annotations
+
+
+import polars as pl
+
+
+
+from disprove.costs import CostModel
+from disprove.chunks import FixedHorizonChunkPolicy
+from disprove.audit import audit_funding_carry_chunks
+from disprove.audit import CarryAuditPolicy
+
+EIGHT_H_MS = 8 * 3600 * 1000
+ZERO_COST = CostModel(spot_fee_bps=0, perp_fee_bps=0, half_spread_bps=0, slippage_bps=0)
+
+
+def _frame(rates: list[float], times: list[int] | None = None) -> pl.DataFrame:
+    times = times if times is not None else [i * EIGHT_H_MS for i in range(len(rates))]
+    return pl.DataFrame({"funding_time": times, "funding_rate": rates})
+
+
+def _audit(frame: pl.DataFrame):
+    return audit_funding_carry_chunks(
+        frame,
+        cost_model=ZERO_COST,
+        policy=CarryAuditPolicy(
+            window=2, expected_holding_periods=30, notional_usdt=10_000
+        ),
+        chunk_policy=FixedHorizonChunkPolicy(
+            min_observations=30,
+            catastrophic_net_loss_usdt=-150.0,
+            max_pass_drawdown_usdt=40.0,
+            min_pass_ratio=0.70,
+        ),
+        horizon_ms=30 * EIGHT_H_MS,  # 10-day chunks for a small demo
+    )
+
+
+def main() -> None:
+    # 1. A consistent earner: small positive funding every period.
+    consistent = _frame([0.0005] * 120)
+
+    # 2. An inconsistent earner: one hot stretch, then nothing — the average
+    #    looks fine, the chunk gate sees the truth.
+    inconsistent = _frame([0.002] * 30 + [-0.0001] * 90)
+
+    # 3. A gapped history: looks profitable, but evidence is missing — the
+    #    gate refuses to bless it regardless of PnL.
+    times = [i * EIGHT_H_MS for i in range(50)] + [
+        i * EIGHT_H_MS for i in range(55, 125)
+    ]
+    gapped = _frame([0.0005] * 120, times)
+
+    for label, frame in (
+        ("consistent", consistent),
+        ("inconsistent", inconsistent),
+        ("gapped", gapped),
+    ):
+        audit = _audit(frame)
+        o = audit.overall
+        print(
+            f"{label:<12} -> {o.verdict:<5} "
+            f"({o.chunks_pass}P/{o.chunks_warn}W/{o.chunks_block}B of {o.chunks_total}, "
+            f"pass_ratio={o.pass_ratio:.2f}, reasons={list(o.reasons) or 'clean'})"
+        )
+
+
+if __name__ == "__main__":
+    main()

disprove-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "disprove"
+version = "0.1.0"
+description = "The strategy evidence engine: honest PASS/WARN/BLOCK verdicts on trading strategies. Its credential: it blocked its own flagship strategy."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Vadims" }]
+keywords = ["trading", "backtesting", "validation", "evidence", "quant", "audit"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Financial and Insurance Industry",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Office/Business :: Financial :: Investment",
+]
+dependencies = [
+    "polars>=1.0",
+    "numpy>=1.26",
+    "scipy>=1.11",
+]
+
+[project.scripts]
+disprove = "disprove.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/866y4tb8hc-coder/disprove"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/disprove"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+
+[dependency-groups]
+dev = ["pytest>=8.0", "ruff>=0.4"]

disprove-0.1.0/src/disprove/__init__.py

@@ -0,0 +1,45 @@
+"""Disprove — the strategy evidence engine.
+
+Honest PASS/WARN/BLOCK verdicts on trading strategies: cost-charged
+accounting, fixed-horizon consistency chunks, data-integrity blocks, and
+thresholds you commit to before seeing the result.
+
+Its credential: it blocked its own flagship strategy.
+"""
+
+from disprove.audit import CarryAuditPolicy, FundingCarryChunkAudit, audit_funding_carry_chunks
+from disprove.chunks import (
+    FixedHorizonChunk,
+    FixedHorizonChunkMetrics,
+    FixedHorizonChunkPolicy,
+    FixedHorizonChunkVerdict,
+    FixedHorizonOverallVerdict,
+    compute_chunk_metrics,
+    evaluate_chunk_verdict,
+    evaluate_overall_verdict,
+    split_fixed_horizon_chunks,
+)
+from disprove.costs import CostModel
+from disprove.engine import BacktestResult, run_backtest, run_backtest_v2
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "CarryAuditPolicy",
+    "FundingCarryChunkAudit",
+    "audit_funding_carry_chunks",
+    "FixedHorizonChunk",
+    "FixedHorizonChunkMetrics",
+    "FixedHorizonChunkPolicy",
+    "FixedHorizonChunkVerdict",
+    "FixedHorizonOverallVerdict",
+    "compute_chunk_metrics",
+    "evaluate_chunk_verdict",
+    "evaluate_overall_verdict",
+    "split_fixed_horizon_chunks",
+    "CostModel",
+    "BacktestResult",
+    "run_backtest",
+    "run_backtest_v2",
+    "__version__",
+]

disprove-0.1.0/src/disprove/audit.py

@@ -0,0 +1,121 @@
+"""Fixed-horizon chunk audit for the funding-carry strategy.
+
+Wires the (previously orphaned) fixed-horizon chunk verdict engine to real
+funding-carry accounting: per-funding-period net PnL computed with the SAME
+signal derivation as the paper-forward journal builder and the SAME engine
+arithmetic as the backtester. The output is the promotion-grade
+PASS/WARN/BLOCK gate artifact source.
+
+Method (deterministic, no I/O):
+  1. positions  = regime_funding_carry_signal(features, cost-derived hurdle)
+  2. pnl_series = run_backtest(funding_rate, positions, cost_model, notional)
+  3. observations = (funding_time, per-period net PnL) on the funding grid —
+     flat periods contribute 0.0 (breakeven, never a win), so calendar gaps in
+     the DATA (not in activity) are what the chunk integrity checks flag.
+  4. split -> per-chunk metrics -> per-chunk verdicts -> overall verdict.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import polars as pl
+
+from disprove.costs import CostModel
+from disprove.engine import run_backtest
+from disprove.features import compute_funding_features
+from disprove.chunks import (
+    FixedHorizonChunk,
+    FixedHorizonChunkMetrics,
+    FixedHorizonChunkPolicy,
+    FixedHorizonChunkVerdict,
+    FixedHorizonOverallVerdict,
+    compute_chunk_metrics,
+    evaluate_chunk_verdict,
+    evaluate_overall_verdict,
+    split_fixed_horizon_chunks,
+)
+from disprove.signals import regime_funding_carry_signal
+
+@dataclass(frozen=True)
+class CarryAuditPolicy:
+    """Signal/accounting parameters for the carry audit.
+
+    window: trailing funding-rate mean window (periods).
+    expected_holding_periods: amortization horizon for the cost-derived hurdle.
+    notional_usdt: audited notional.
+    """
+
+    window: int = 6
+    expected_holding_periods: float = 30.0
+    notional_usdt: float = 10_000.0
+
+    def __post_init__(self) -> None:
+        if self.window <= 0:
+            raise ValueError("window must be positive")
+        if self.expected_holding_periods <= 0:
+            raise ValueError("expected_holding_periods must be positive")
+        if self.notional_usdt <= 0:
+            raise ValueError("notional_usdt must be positive")
+
+
+DEFAULT_FUNDING_INTERVAL_MS = 8 * 3600 * 1000
+
+# Binance funding timestamps jitter by tens of milliseconds around the exact
+# 8h grid (observed: ±47ms over 7,362 BTCUSDT intervals). The gap detector
+# compares strictly against expected_interval_ms, so without tolerance ~30% of
+# perfectly normal intervals read as data gaps. One minute is far above any
+# observed jitter and far below a genuinely missed funding interval.
+DEFAULT_JITTER_TOLERANCE_MS = 60 * 1000
+
+
+@dataclass(frozen=True)
+class FundingCarryChunkAudit:
+    """Full audit result: every layer retained for the report writers."""
+
+    chunks: tuple[FixedHorizonChunk, ...]
+    metrics: tuple[FixedHorizonChunkMetrics, ...]
+    verdicts: tuple[FixedHorizonChunkVerdict, ...]
+    overall: FixedHorizonOverallVerdict
+
+
+def audit_funding_carry_chunks(
+    funding: pl.DataFrame,
+    *,
+    cost_model: CostModel,
+    policy: CarryAuditPolicy,
+    chunk_policy: FixedHorizonChunkPolicy | None = None,
+    horizon_ms: int,
+    expected_interval_ms: int = DEFAULT_FUNDING_INTERVAL_MS,
+) -> FundingCarryChunkAudit:
+    """Run the fixed-horizon chunk audit over a funding-rate history.
+
+    ``funding`` needs ``funding_time`` (ms) and ``funding_rate`` columns.
+    Signal and accounting mirror the internal journal builder:
+    cost-derived hurdle, regime signal, engine PnL net of position-change
+    costs. Unsorted/duplicate timestamps raise (data-integrity failure).
+    """
+    times = funding["funding_time"].to_list()
+    features = compute_funding_features(funding, window=policy.window)
+    hurdle = cost_model.position_change_bps() / policy.expected_holding_periods
+    positions = regime_funding_carry_signal(
+        features, window=policy.window, hurdle_bps_per_period=hurdle
+    )
+    pnl_series = run_backtest(
+        funding["funding_rate"], positions, cost_model, policy.notional_usdt
+    ).pnl_series
+
+    observations = list(zip(times, (float(v) for v in pnl_series)))
+    chunks = split_fixed_horizon_chunks(
+        observations,
+        horizon_ms=horizon_ms,
+        expected_interval_ms=expected_interval_ms + DEFAULT_JITTER_TOLERANCE_MS,
+    )
+    metrics = tuple(compute_chunk_metrics(chunk) for chunk in chunks)
+    verdicts = tuple(
+        evaluate_chunk_verdict(chunk, metric, policy=chunk_policy)
+        for chunk, metric in zip(chunks, metrics)
+    )
+    overall = evaluate_overall_verdict(verdicts, policy=chunk_policy)
+    return FundingCarryChunkAudit(
+        chunks=chunks, metrics=metrics, verdicts=verdicts, overall=overall
+    )