PineForge backtestet dein Pine Script in der CI: Weichen Trades ab, schlägt der Build fehl.
Warum Parität in CI
Strategien driften wie jeder Code. Ein umbenannter Parameter, ein Refactoring einer Hilfsfunktion, eine Änderung an der Pine-v6-API, die du nicht mitbekommen hast: Jede dieser Änderungen kann Signale unbemerkt verschieben, ohne dass ein einziger bestehender Test fehlschlägt. Ohne Paritäts-Gate in der CI kann ein Commit von vor zwei Monaten die Trade-Liste der letzten Woche verändern, und du merkst es erst, wenn die Live-P&L falsch aussieht.
Die Disziplin, deine Referenz-Trade-Liste zusammen mit dem Quellcode der Strategie zu committen, ist dieselbe Disziplin, die Software zuverlässig macht: Du beschreibst den erwarteten Output, und dein Build schlägt fehl, wenn der tatsächliche Output abweicht. Bei einem Backtest ist der erwartete Output die Trade-Liste (Entry-Bar, Exit-Bar, Richtung, Positionsgröße, Fill-Preis) auf einem gepinnten historischen Datensatz.
Wenn dieser Vergleich auf jedem Commit läuft, bekommst du eine Sperrklinke: Das historische Verhalten deiner Strategie kann nur besser werden, nie versehentlich regredieren. Du weißt exakt Bescheid, welcher Commit den Output verändert hat, weil der Build auf diesem Commit gebrochen ist. Du hast einen git blame für deine Equity-Kurve.
Das zählt mehr, als die meisten Quants anfangs wahrhaben wollen. Die Lücke zwischen „Ich habe diese Strategie getestet“ und „Ich habe einen reproduzierbaren, versionierten Record jedes historischen Signals, das diese Strategie je erzeugt hat“ ist riesig. Das Erste ist ein Screenshot. Das Zweite ist ein Audit-Trail. CI ist die Art, wie du das Zweite ohne manuellen Aufwand auf jedem Push pflegst.
PineForge passt hier, weil die Runtime ein Docker-Image ist: Sie läuft überall, wo Docker läuft, liefert bei gleichen Eingaben dieselben Trades und schreibt einen JSON-Report, den du mit jq parsen kannst. Es gibt keinen Browser, keinen Login und kein Rate-Limit für den Backtest selbst.
GitHub-Actions-Beispiel
Der komplette Workflow: Strategie auschecken, mit dem Image pineforge-release nach C++ transpilieren, Backtest gegen deine gepinnte OHLCV-CSV laufen lassen, JSON-Report parsen mit jq, gegen deine committete Baseline vergleichen, Build brechen, wenn ein Trade Richtung oder Bar wechselt oder das Netto-P&L-Delta deinen Schwellenwert überschreitet.
Die Runtime ist ein Container-Image, es gibt also keinen API-Key zu verwalten. Im Job reicht ein docker run. Lege .github/workflows/backtest.yml an:
name: Backtest parity
on:
push:
branches: [main, "feat/**"]
pull_request:
jobs:
backtest:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
# Pin the image version so results only change when you change it.
- name: Transpile strategy to C++
run: |
docker run --rm --network=none \
-e PINEFORGE_TRANSPILE_ONLY=1 \
-v "$PWD/strategy.pine":/in/strategy.pine:ro \
ghcr.io/pineforge-4pass/pineforge-release:1.12.0 > strategy.cpp
- name: Run backtest
run: |
docker run --rm --network=none \
-v "$PWD/strategy.cpp":/in/strategy.cpp:ro \
-v "$PWD/data/ohlcv.csv":/in/ohlcv.csv:ro \
ghcr.io/pineforge-4pass/pineforge-release:1.12.0 \
> report.json
- name: Assert parity
run: |
# Every trade keeps its side and its entry and exit bars,
# and net P&L moves by at most THRESHOLD.
BARS='[.trades[] | [.side, .entry_bar_index, .exit_bar_index]]'
ACTUAL=$(jq '.summary.net_pnl' report.json)
BASELINE=$(jq '.summary.net_pnl' baseline/report.json)
DELTA=$(echo "$ACTUAL $BASELINE" | awk '{d=$1-$2; print (d<0)?-d:d}')
THRESHOLD="0.01"
if [ "$(jq -c "$BARS" report.json)" != "$(jq -c "$BARS" baseline/report.json)" ]; then
echo "Parity drift: a trade changed side, entry bar or exit bar"
elif awk "BEGIN{exit !($DELTA > $THRESHOLD)}"; then
echo "Parity drift: net_pnl delta $DELTA exceeds threshold $THRESHOLD"
else
echo "Parity OK - same sides and bars, net_pnl delta $DELTA (threshold $THRESHOLD)"
exit 0
fi
# One trade per line, so diff's line numbers are trade numbers.
TRADE='.trades[] | {side, entry_bar_index, exit_bar_index, entry_price, exit_price, qty, pnl}'
diff <(jq -c "$TRADE" baseline/report.json) <(jq -c "$TRADE" report.json)
exit 1Lege deinen Baseline-Report unter baseline/report.json ab und committe ihn zusammen mit dem Quellcode der Strategie. Wenn ein PR das Strategie-Verhalten beabsichtigt verändert, aktualisiert der Autor die Baseline als Teil des PRs. Dieser Diff dokumentiert dauerhaft, was sich geändert hat und warum.
Derselbe Workflow läuft identisch auf GitLab CI, Bitbucket Pipelines oder jedem anderen Runner mit Docker-Support. Du passt nur die YAML-Syntax an, die Shell-Befehle bleiben gleich.
Exit-Codes und Paritätsprüfung
Die PineForge-Runtime beendet sich mit Code 0 bei einem sauberen Lauf und bei einem Fehler mit einem Code ungleich null: 2 bei fehlender Eingabedatei, 3 bei einem Kompilierfehler, 4 bei einem Backtest-Fehler und 5 bei einem Transpilierfehler (nicht unterstütztes Pine oder ein Syntaxfehler). Die CI erkennt diese Codes ohne Sonderbehandlung.
Wie du das Ergebnis prüfst, entscheidet dein Workflow. Der Report sieht so aus (gekürzt):
{
"engine": "pineforge",
...
"summary": {
"total_trades": 3483,
"wins": 1288,
"losses": 2194,
"win_rate_pct": 36.9796,
"net_pnl": 2518.39,
"max_drawdown": -1382.76,
...
},
"trades": [
{
"n": 1,
"side": "long",
"entry_time": 1729402200000,
"exit_time": 1729422000000,
"entry_price": 2640.96,
"exit_price": 2645.15,
"qty": 1.0,
"pnl": 4.19,
"entry_bar_index": 34,
"exit_bar_index": 56,
...
}
],
"metrics": { "all": { "profit_factor": 1.06, ... }, "equity": { "sharpe_tv": ..., ... } },
"equity_curve": [ ... ],
"fingerprint": { "digest": "sha256:...", ... }
}Für einen einfachen numerischen Parity-Check vergleiche summary.net_pnl und summary.total_trades gegen die Baseline. Der Workflow oben wertet außerdem das trades-Array aus: Jeder Trade muss seine Richtung sowie seine Ein- und Ausstiegs-Bar behalten. Schlägt eine Prüfung fehl, vergleicht der Workflow die beiden Trade-Listen per diff, mit einer Zeile pro Trade. So entsprechen die Zeilennummern von diff den Trade-Nummern, und jede Zeile zeigt Richtung, Bars, Preise, Menge und P&L eines Trades, vorher und nachher.
Praktischer Schwellenwert für numerische Felder: Floating-Point-Deltas bis 0.01 akzeptieren (ein Cent Netto-P&L) und bei allem Größeren fehlschlagen. Für Trades gibt es keine Toleranz: Der Workflow oben schlägt bei jeder Änderung an Richtung, entry_bar_index oder exit_bar_index fehl, unabhängig von der P&L. Ein Trade auf einer anderen Bar bedeutet, dass sich deine Signallogik geändert hat.
Ein praktisches Muster: Aktualisiere die Baseline in einem separaten Workflow-Schritt, der an ein PR-Label gekoppelt ist, damit eine beabsichtigte Änderung im Code-Review neben der Pine-Änderung auftaucht, die sie verursacht hat.