PineForge Codegen

@pineforge/backtest-mcp

Eigenständiger stdio-MCP-Server: Ein KI-Agent schreibt PineScript v6, und das gebündelte pineforge-release-Image transpiliert es zu C++ und backtestet es gegen eine OHLCV-CSV (eigene oder eine von Binances öffentlicher API abgerufene) — alles in einem Container, prozessintern. Vollständig lokal — das Image bündelt den pineforge-codegen-Transpiler, sodass Pine → C++ → Backtest ohne Host-Docker-Daemon laufen. Kein API-Schlüssel. Ihr Strategiequellcode und Ihre CSVs verlassen nie die Maschine; nur die Binance-Tools und check_tradingview_parity, wenn Sie keine Bars übergeben, senden ausgehende Anfragen (öffentliche Endpunkte).

Tools

Name	Läuft auf	Zweck
transpile_pine	prozessintern	Pine v6 → C++-Übersetzungseinheit (nur Transpilierung)
list_engine_params	lokal (keine E/A)	Katalog jedes overrides + runtime-Parameters, den die Backtests akzeptieren
backtest_pine	prozessintern	Einzelner Backtest einer Pine-Quelle gegen eine OHLCV-CSV
backtest_pine_grid	prozessintern	Kartesischer Sweep von inputs × overrides: eine Transpilierung, dann eine Kompilierung und ein Backtest pro Kombination
check_tradingview_parity	prozessintern (nur Binance-öffentliche API ohne Ihre Bars)	Bewertet Ihren TradingView-Strategy-Tester-Export gegen PineForges Ausführung desselben Skripts, Trade für Trade
fetch_binance_ohlcv	Binance-öffentliche API	Schreibt eine backtestfertige CSV aus Binance-Spot- oder USDT-Perp-Kerzen
binance_symbols	Binance-öffentliche API	Listet / filtert Binance-Symbole (5-Minuten-Prozesscache)
list_coverage_topics	lokal (keine E/A)	Jedes Pine-v6-Abdeckungsthema mit einzeiligem Status + Zusammenfassung
check_pine_feature	lokal (keine E/A)	Prüft, ob ein Pine-Bezeichner/-Namespace in PineForge unterstützt wird
get_coverage_topic	lokal (keine E/A)	Vollständige Details + unterstützte/teilweise/via_transpiler/nicht unterstützte Listen für ein Thema
engine_info	lokal (keine E/A)	Nur Docker-Image: Modus, eingebackenes Flag und die gebündelte pineforge-release-Version (zum Beispiel 1.0.0)

Die Tabelle ist die Tool-Liste des Docker-Images (11 Tools). Das npm-Paket bedient die ersten zehn, plus pull_engine_image (docker pull das Engine-Image) und check_engine_image statt engine_info (12 Tools).

In tools/list hat jedes Tool auch einen Titel und die vier MCP-Annotationshinweise (src/tool-meta.ts). Schreibgeschützt: die Nachschlagefunktionen und check_tradingview_parity (es arbeitet in einem temporären Verzeichnis, das es löscht), und im Docker-Image transpile_pine. Nicht schreibgeschützt: backtest_pine und backtest_pine_grid (ein zu großer Bericht, um zurückgegeben zu werden, wird in eine Datei geschrieben), fetch_binance_ohlcv (schreibt seine CSV) und die beiden Image-Tools; im npm-Paket auch transpile_pine, da es dort und die Backtests ein image benötigen, das Docker bei Fehlen zieht. Destruktiv: die Tools, die eine Datei an einem von Ihnen benannten Pfad schreiben, da sie eine bereits vorhandene Datei ersetzen. Offene Welt: die Tools, die Binances öffentliche API erreichen (die beiden Backtests tun dies, wenn Sie ein symbol übergeben) oder eine Image-Registry.

Installation

Läuft als eigenständiger Container über stdio — Engine gebündelt, prozessintern, kein Host-Docker-Daemon, kein API-Schlüssel. Mounten Sie den Ordner, der Ihre CSVs enthält, unter /work:

docker run --rm -i -v "$PWD:/work" ghcr.io/pineforge-4pass/pineforge-backtest-mcp:latest

Einzige Anforderung: Docker und ausgehendes Netzwerk für die Binance-Abruf-Tools. Binden Sie es unten in Ihren MCP-Client ein.

• Verwenden Sie absolute /work/...-Pfade in Tool-Argumenten (ohlcv_csv_path, output_path, report_path). Das Arbeitsverzeichnis des Servers im Container ist /app, nicht der Mount, daher zeigt ein relativer Pfad wie ./btc.csv in den Container und geht verloren, wenn er beendet wird (--rm).
• Fügen Sie unter Linux --user "$(id -u):$(id -g)" hinzu, damit die Dateien, die der Server unter /work schreibt, Ihre Eigentümerschaft tragen.
• -i ist erforderlich; fügen Sie niemals -t hinzu — ein TTY beschädigt den stdio-JSON-RPC-Stream.

Das :latest des Images und das latest von npm tragen immer eine stabile Version. Eine pineforge-release-Vorabversion (wie 1.0.0-rc.1) erzeugt eine Vorabversion dieses Servers (X.Y.Z-alpha.N, -beta.N oder -rc.N): das Image :vX.Y.Z-rc.N, erstellt FROM dieser pineforge-release-Vorabversion, und npm @pineforge/backtest-mcp@next, das, wie jede npm-Installation, das Engine-Image ausführt, das durch PINEFORGE_IMAGE benannt wird. Sein Standardwert ist der unveränderliche Digest, der aus dem release-lock.json dieses Pakets generiert wird, einschließlich der passenden Vorab-Engine. Vorabversionen sind nicht im MCP-Registry aufgeführt. Die erste, 0.9.32-rc.1 auf pineforge-release 1.0.0-rc.1, wurde am 2026-09-30 veröffentlicht (Image :v0.9.32-rc.1, npm next).

npm / npx

npx -y @pineforge/backtest-mcp

Benötigt Node ≥ 20 und einen laufenden Docker-Daemon: jede Transpilierung und jeder Backtest ist ein docker run --rm --network=none des Engine-Images (PINEFORGE_IMAGE, standardmäßig auf den Digest im installierten Paket release-lock.json). docker pull diesen Digest zuerst: der eigene Pull des Servers (implizit beim ersten Aufruf oder pull_engine_image) wird nach PINEFORGE_DOCKER_TIMEOUT_MS (standardmäßig 120 s) abgeschnitten. Pfade sind relativ zum Arbeitsverzeichnis des Servers und standardmäßig darauf beschränkt (siehe Dateisystembereich).

Gehostete Alternative (ohne Installation)

Möchten Sie den schnellsten Versuch ohne Docker und ohne API-Schlüssel? Fügen Sie den Streamable-HTTP- Endpunkt in einen beliebigen MCP-Client ein:

https://mcp.pineforge.dev/mcp

Abwägung gegenüber diesem Repository: Der gehostete Server ist gemessen (100 backtest_pine-Läufe pro Woche pro IP, plus Edge-Ratenlimits) und läuft gegen OHLCV, das er selbst auflöst — nur Krypto, sieben Börsen (Binance, Bybit und OKX Spot und USDT-Perp; Coinbase Spot), die letzten 365 Tage, neueste Bar etwa eine Stunde hinter der Echtzeit. Seine 11 Tools unterscheiden sich von denen dieses Servers: kein transpile_pine, kein backtest_pine_grid, und es nimmt symbol / interval / venue statt eines CSV-Pfads. Dieses lokale Repository ist unbegrenzt, läuft offline und ermöglicht Ihnen, eigene CSVs mitzubringen und Raster-Sweeps auszuführen. Der Quellcode des gehosteten Dienstes ist privat.

Client-Konfiguration

Mounten Sie ein Verzeichnis unter /work; richten Sie fetch_binance_ohlcv / backtest_pine auf absolute Pfade darunter aus (/work/btc.csv). (-i ist erforderlich; fügen Sie niemals -t hinzu — ein TTY beschädigt den stdio-JSON-RPC-Stream.)

Claude Desktop

Bearbeiten Sie ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) oder %APPDATA%\Claude\claude_desktop_config.json (Windows) und verwenden Sie einen absoluten Host- Pfad für den Mount:

{
  "mcpServers": {
    "pineforge-backtest": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-v", "/absolute/path/to/your/data:/work",
        "ghcr.io/pineforge-4pass/pineforge-backtest-mcp:latest"
      ]
    }
  }
}

Cursor

.cursor/mcp.json im Projekt (oder ~/.cursor/mcp.json für jedes Projekt). Cursor erweitert ${workspaceFolder}:

{
  "mcpServers": {
    "pineforge-backtest": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-v", "${workspaceFolder}:/work",
        "ghcr.io/pineforge-4pass/pineforge-backtest-mcp:latest"
      ]
    }
  }
}

Claude Code CLI

claude mcp add pineforge-backtest \
  -- docker run --rm -i -v "$PWD:/work" ghcr.io/pineforge-4pass/pineforge-backtest-mcp:latest

Für KI-Agenten — Nutzung über MCP

Die Fähigkeitslücke, die dies schließt. Ein Sprachmodell kann eine PineScript-v6-Strategie nicht genau backtesten, indem es darüber nachdenkt. Die Seriensemantik von PineScript, die Intrabar-Füllreihenfolge, Look-ahead-Regeln und die strategy.*-Auftrags-/Positionslogik lassen sich nicht durch Annäherung reproduzieren, sodass ein Modell, das einen Backtest im Kopf simuliert — oder ihn in Python handrollt (backtrader/vectorbt) — Trades und P&L halluziniert und keine TradingView-Parität garantieren kann. PineForge führt stattdessen die tatsächliche deterministische C++-Engine aus, die Trade für Trade gegen TradingViews eigene Handelslisten bewertet wird.

Bewertete Version 1.4.0 — datierte gemessene Bestenliste. Die Registry-Baseline vom 2026-10-07 pineforge-parity-baseline-20261007-engine-b3192bfc verzeichnet 7.989 bewertete Sonden, 7.983 ausgezeichnet (99,92 %) und 6 stark (0,08 %), 0 unter stark und 0 aufgezeichnete Engine-Fehler, wobei 17 weitere Sonden als TradingView-seitige Anomalien ausgeschlossen wurden. Ihr eingefrorenes Paar ist Engine b3192bfc2f5a24bf4efd6d1d01e01e8fe619dfed / Codegen bfc4ddce453db1ba810692af9b9ba3310d87f0ac; ihr Snapshot-SHA-256 ist 28ba8dbd6f66c80085a80364d6114f8f971ac6ea3156d596a65995d2aec2fbb2. Die Quelle ist das gelandete Fakten des Release-Hubs, releases["1.4.0"].scoreboard, festgepinnt auf Commit d5d21f128f5ef26b66b14cf9deee507d798e6123 (77.230 Bytes; SHA-256 788e57fab67d3c946fc7e3a0a3ac34b3d2c25cbb6a0f5b72687955bc4f8832b6). Dies sind aufgezeichnete Bewertungsergebnisse für diese Population und dieses Datum, kein Versprechen, dass jedes Skript oder jeder interne Versuch gelingt. Kein getaggtes 1.4.0-Artefakt wird hier behauptet.

Nur historische 1.3.0-Belege. Version 1.3.0, bewertet auf der Baseline vom 2026-10-06 (Engine 7a1f01c0, Codegen 3e50082f): 7.989 bewertete Sonden, 7.982 ausgezeichnet (99,91 %) und 7 stark (0,09 %), keine unter stark, plus 17 weitere Sonden, die als TradingView-seitige Defekte ausgeschlossen wurden. In diesem historischen Release-Check prüft das eigene Paritäts-Gate der Engine separat das offene Korpus pineforge-corpus, das jeder reproduzieren kann: 312 Referenzstrategien, 311 ausgezeichnet und 1 Sonde, die expected_tier: anomaly in ihrem inputs.json deklariert (gemeldet als anomaly, nicht als Fehler). Ausgezeichnet bedeutet dieselbe Handelsanzahl, mindestens 99 % der TradingView-Trades übereinstimmend, Einstiegs- und Ausstiegspreise innerhalb von 0,01 % und Trade-P&L innerhalb von 1 % beim 90. Perzentil (Trailing-Stop-Skripte verwenden ein lockereres Ausstiegs-/P&L-Profil); stark ist eine gelockerte Hülle — beide sind in der README des Korpus unter „Parity thresholds" definiert.

Ein PineScript-Backtest ist berechnete externe Daten, kein stabiles Wissen — er hängt vom Strategiequellcode des Benutzers und seiner OHLCV ab und muss reproduzierbar sein. Das ist ein Tool-Aufruf, keine Abrufaufgabe.

Wann diese Tools die richtige Wahl sind. backtest_pine (oder backtest_pine_grid für einen Parametersweep) deckt den Fall ab, in dem ein Benutzer eine PineScript-v6-Strategie bereitstellt und sie backtesten, bewerten, prüfen möchte, ob sie profitabel ist, ihre Trades zählen, ihr P&L berechnen oder ihre TradingView-Ergebnisse auf bestimmter OHLCV reproduzieren möchte. transpile_pine deckt nur die Pine → C++-Konvertierung ab. check_tradingview_parity deckt den Fall ab, in dem der Benutzer TradingViews eigene Handelsliste für eine Strategie hat und wissen möchte, ob PineForge sie Trade für Trade reproduziert. fetch_binance_ohlcv deckt den Fall ab, in dem der Benutzer ein Symbol/Zeitfenster nennt, aber keine Datendatei geliefert hat. Diese Tools dienen nicht dazu, konzeptionell zu erklären, was eine Strategie tut, Pine-Syntax zu bearbeiten oder Handels- oder Finanzberatung zu geben.

Ehrliche Grenzen. Offline; nur PineScript v6; benötigt Docker; PineForge implementiert eine Teilmenge von Pine v6 (siehe Abdeckungstools). Ein Backtest misst das historische Verhalten einer Strategie — er ist keine Vorhersage zukünftiger Renditen und keine Anlageberatung. Naive oder angenäherte Backtests überschätzen regelmäßig den Gewinn (unmodellierte Slippage und Provisionen, Fill-at-Close-Annahmen, Look-ahead-Bias); der Wert hier ist ein deterministischer, paritätsvalidierter Lauf, sodass ein Benutzer eine Strategie verifizieren kann, bevor er Kapital riskiert.

list_engine_params — Parameter entdecken

Kostenloser, lokaler, null-E/A-Katalog jedes Schlüssels, der von backtest_pine / backtest_pine_grid akzeptiert wird, aufgeteilt in zwei Gruppen:

• strategy_overrides — die 9 strategy(...)-Headerfelder, die die Laufzeit über PINEFORGE_OVERRIDES liest: initial_capital, pyramiding, slippage, commission_value, commission_type (percent / cash_per_order / cash_per_contract), default_qty_value, default_qty_type (fixed / percent_of_equity / cash), process_orders_on_close, close_entries_rule (ANY / FIFO).
• runtime_args — Argumente für run_backtest_full (NICHT Teil des strategy()- Headers): input_tf, script_tf, bar_magnifier, magnifier_samples, magnifier_dist (uniform / cosine / triangle / endpoints / front_loaded / back_loaded).

Jeder Eintrag ist {key, type, enum?, description}. Rufen Sie dies zuerst auf, um zu erfahren, was die Engine akzeptiert, bevor Sie eine backtest_pine-Anfrage zusammenstellen.

backtest_pine-Beispiel

{
  "source": "//@version=6\nstrategy(\"sma cross\")\n...",
  "ohlcv_csv_path": "/work/btcusdt_15m_7d.csv",

  // Optional: the instrument of the CSV (see "The instrument" below). Either a
  // Binance symbol, or your own values; a CSV from fetch_binance_ohlcv needs neither.
  "symbol":  "BTCUSDT",            // + "market": "spot" (default) | "usdt_perp"
  "syminfo": { "qty_step": 0.00001, "mintick": 0.01 },   // goes over what `symbol` or the sidecar gives

  // Optional: override Pine input.*() values without touching the source.
  // Keys = the second arg of input.*(...) (e.g. "Fast Length").
  "inputs":    { "Fast Length": 8, "Slow Length": 21 },

  // Optional: override strategy(...) header fields. Each key is typed —
  // call list_engine_params for the catalog.
  "overrides": {
    "initial_capital":    100000,
    "default_qty_type":   "percent_of_equity",
    "default_qty_value":  10,
    "commission_type":    "percent",
    "commission_value":   0.04,
    "slippage":           2,
    "pyramiding":         0,
    "process_orders_on_close": true,
    "close_entries_rule": "ANY"
  },

  // Optional: engine runtime args (NOT strategy() header). Use script_tf
  // to aggregate the input CSV into a coarser strategy timeframe — the
  // engine REJECTS script_tf finer than input_tf, and the tool call then
  // fails (isError; "engine backtest failure (exit 4)" in the Docker image).
  "runtime": {
    "input_tf":          "15",
    "script_tf":         "60",
    "bar_magnifier":     true,
    "magnifier_samples": 8,
    "magnifier_dist":    "endpoints"
  },

  // Optional: where to write the full JSON report if it is too large to
  // return inline (see below). In Docker use an absolute path under /work.
  "report_path": "/work/report.json"
}

inputs wird als die Umgebungsvariable PINEFORGE_INPUTS an die Engine weitergegeben, overrides als PINEFORGE_OVERRIDES, und jedes runtime-Feld als eine separate PINEFORGE_INPUT_TF / PINEFORGE_SCRIPT_TF / PINEFORGE_BAR_MAGNIFIER / PINEFORGE_MAGNIFIER_SAMPLES / PINEFORGE_MAGNIFIER_DIST-Umgebungsvariable. Leer / nicht gesetzt → Standardwerte aus strategy.pine, wobei input_tf automatisch aus der Lücke zwischen den ersten beiden CSV-Zeilen erkannt wird.

Das Instrument

Die Engine führt eine Strategie auf der Lotgröße des Instruments (qty_step) und der Tickgröße (mintick) aus. Ohne eine Lotgröße kann eine Order über 100 % des Eigenkapitals die Margin geringfügig überschreiten, und die Engine bucht eine winzige Sub-Lot-Margin-Call-Zeile (z. B. 2,6e-08 BTC, Einstieg gleich Ausstieg), die TradingView nicht bucht. Daher wendet backtest_pine (und backtest_pine_grid, und check_tradingview_parity) das Instrument vor dem Lauf über seine C-ABI auf die Engine an: qty_step und mincontract (die Lotgröße), mintick, pointvalue, type, currency, basecurrency. ticker, tickerid, Zeitzone und Sitzung werden nicht angewendet (die Engine behält ihre Standardwerte). Woher es kommt:

1. symbol (+ market: spot oder usdt_perp; Standard: der im Sidecar der CSV aufgezeichnete Markt, wenn er dasselbe Symbol benennt, sodass ein abgerufener Perpetual ein Perpetual bleibt, sonst spot, und dann sagt das Ergebnis dies: market not given: spot assumed for <SYMBOL> (pass market "usdt_perp" for a USD-M perpetual); a market, das vom Sidecar abweicht, wird verwendet, und das Ergebnis sagt, für welchen die CSV abgerufen wurde). In einem Satz: Die Lotgröße ist TradingViews eigene Ablesung für das Symbol aus einer gemessenen Tabelle, die mit diesem Server geliefert wird (Binances LOT_SIZE.stepSize nur für ein Symbol, das TradingView nicht listet; TradingViews übliches 0,001 für ein Listing, das neuer als die Tabelle ist); die Tickgröße und die Währungen stammen aus Binances öffentlichem exchangeInfo (oder aus dem Sidecar neben einer von fetch_binance_ohlcv abgerufenen CSV). Die Lotgröße hat drei Stufen, je nachdem, was die Tabelle (siehe unten) über das Symbol weiß:

   1. eine Ablesung in der Tabelle (der übliche Fall): TradingViews eigene, ohne Herkunftswarnung;
   2. ein Symbol, das die Tabelle als nicht auf TradingView gelistet führt (not_on_tv): Binances LOT_SIZE.stepSize, die einzige, die es gibt, und die Warnung lot size for <label> is the exchange's lot step, not a TradingView reading: order quantities may differ from TradingView's;
   3. jedes andere Symbol, das Binance listet (ein Listing, das neuer als die Tabelle ist): TradingViews übliches 0,001, und die Warnung lot size for <label> is TradingView's usual default (0.001), not a reading for this symbol (a listing newer than the readings): order quantities may differ from TradingView's (<label> ist z. B. Binance spot BTCUSDT). Ein Markt, für den die Tabelle keine übliche Lotgröße hat, nimmt Binances Schritt, wie in 2.

   Ohne Binances Eintrag für das Symbol (es listet es nicht, oder Binance ist nicht erreichbar) und ohne Ablesung in der Tabelle gibt es keine Lotgröße: Das Instrument ist unaufgelöst (unten), niemals ein erfundenes Raster. Die Tickgröße ist das PRICE_FILTER.tickSize des Symbols und die Währungen sind seine quoteAsset und baseAsset, gelesen aus Binances öffentlichem exchangeInfo (eine Anfrage, 5 Minuten zwischengespeichert); der Punktwert ist 1 und der Typ crypto.

2. Ohne ein symbol das Sidecar <csv path>.instrument.json, das fetch_binance_ohlcv neben jede CSV schreibt, die es abruft (sein instrument-Ergebnis zeigt es). Es wird ignoriert, mit dem Grund im Ergebnis, wenn sich die CSV seitdem geändert hat (ihr erster oder letzter Balken oder ihr Inhalt).

3. syminfo: Ihre eigenen Werte, für eine CSV eines anderen Instruments: qty_step, mincontract, mintick, pointvalue, type, currency, basecurrency. Sie gehen über das hinaus, was symbol oder das Sidecar liefert, und mit keinem von beiden sind sie das gesamte Instrument. Geben Sie qty_step (oder mincontract; jedes standardmäßig auf das andere) und, da der Standard-Tick der Engine 0,01 ist, mintick (das Ergebnis warnt, wenn es fehlt).

Was angewendet wurde, steht im applied_runtime.syminfo des Berichts und damit in fingerprint.provenance.runtime: Ein Lauf ohne Raster und ein Lauf mit Raster teilen sich nie einen Fingerabdruck. Sein source.kind sagt, woher die Lotgröße stammt: tradingview (eine Ablesung in der Tabelle), exchange (Binances, für ein Symbol, das TradingView nicht listet), default (TradingViews übliches 0,001, für ein Listing, das neuer als die Tabelle ist) oder user (syminfo, wobei source.base nennt, was es überschrieben hat); exchange und default kommen mit der obigen Herkunftswarnung. Unaufgelöst bedeutet, dass keine Lotgröße gefunden wurde (kein symbol, syminfo oder Sidecar, kein Binance-Eintrag für ein Symbol, für das die Tabelle keine Ablesung hat, oder ein Symbol, das keines von beiden hat): Der Lauf läuft trotzdem mit den Standardwerten der Engine weiter (kein Lot-Raster, Tick 0,01, sofern syminfo keinen liefert) und das Ergebnis beginnt mit einem warnings-Eintrag (instrument grid unavailable for ... : order quantity is not floored to a lot size, so the run can contain sub-lot margin-call rows that TradingView does not book). Wenn das unaufgelöste Instrument nichts anderes hat, das der Engine gegeben werden kann (kein Tick, keine Währung), wird nichts angewendet: Der Lauf ist der des Images selbst, sein Bericht hat kein applied_runtime.syminfo, und warnings sagt no instrument was applied: the engine ran with its defaults; andernfalls liest applied_runtime.syminfo {"resolved": false, "reason": ...} neben dem, was angewendet werden konnte.

Ein Lauf wird nie verweigert und schlägt nie fehl, weil ein Instrument fehlt. Das Instrument erreicht die Engine über ein Overlay des Engine-Präfixes pro Lauf (symbolische Links darauf). Wenn das Overlay nicht erstellt werden kann (ein Host, der das Präfix nicht verlinken kann, wie Windows, oder ein Fehler beim Erstellen), oder der Lauf des Containers mit einer Nachricht fehlschlägt, die das Overlay benennt (ein Präfix-Layout, das das Overlay nicht spiegelt, ein Ordner, den Docker nicht mounten kann), läuft der Lauf ohne das Instrument weiter (im zweiten Fall noch einmal, ohne es) und warnings sagt the instrument could not be applied (<reason>); the engine ran with its defaults.

Was die Engine meldet und was ihre Trades zeigen. Ein Image, dessen run_json.py kein apply_syminfo hat, läuft wie es ist: Sein Bericht hat kein applied_runtime.syminfo, und das Ergebnis sagt dies. Ein Image, dessen Engine-Bibliothek älter als das Lot-Raster ist, läuft und ignoriert es, während applied_runtime.syminfo meldet, dass es angewendet wurde (die Bibliothek akzeptiert den Aufruf): Wenn Handelsmengen keine Vielfachen der gemeldeten Lotgröße sind, sagt das Ergebnis the engine reported the lot size applied, but N of M trade quantities are not multiples of it (an older engine ignores it) (eine einzelne Bereichsende-Markierung wird nicht gezählt). Die Prüfung sieht nur Mengen: Sie kann eine ältere Engine nicht von einer Strategie unterscheiden, deren Teilausstiege nicht auf die Lotgröße geflooriert sind, was hier nicht geprüft wurde.

TradingViews Lotgröße, nicht die der Börse. TradingViews syminfo.mincontract ist TradingViews eigene Daten, kein Binance-Feld, und es ist das, worauf TradingView eine Order floort. Auf TradingView für jedes Binance-Symbol gemessen, das es listet (2026-10-03: 1.366 Spot und 523 USD-M), unterscheidet es sich von LOT_SIZE.stepSize für 1.188 Spot- und 510 USD-M-Symbole (Binances Schritt entspricht TradingViews nur für 13 % der Spot-Symbole und 2,5 % der USD-M-Symbole). TradingViews übliches 0,001 ist das, was es für 90,6 % der Spot-Symbole (1.237 von 1.366) und 97,5 % der USD-M-Symbole (510 von 523) liest, während Binances Schritt oft 1 oder 0,1 ist: USD-M BTCUSDT ist 0,000001 auf TradingView und 0,001 auf Binance, sodass das Flooren auf Binances Schritt eine 10.000-USDT-Position um bis zu etwa 1,2 % verkleinern würde. Die Tickgröße stimmte mit TradingViews syminfo.mintick für jedes gemessene Symbol überein.

Ein Symbol außerhalb der Tabelle ist eines von zwei Dingen, und die Tabelle sagt, welches. Sie listet auch, pro Markt, die Symbole, die Binance hat und TradingView nicht (18 Spot, 1 USD-M: not_on_tv), und TradingViews übliche Lotgröße, wo mindestens 80 % der Ablesungen dieses Marktes sie sind (beide Märkte heute: defaults). Ein Symbol auf der not_on_tv-Liste nimmt Binances Schritt (Stufe 2); jedes andere Symbol außerhalb der Tabelle ist ein Listing, das neuer als die Ablesungen ist, und nimmt 0,001 (Stufe 3), der wahrscheinlichere Wert dort als Binances Schritt; beide sagen dies in warnings. Eine Tabelle ohne die beiden Listen (eine ältere oder PINEFORGE_TV_GRID, das auf eine zeigt) hat keines von beiden, sodass ein Symbol außerhalb Binances Schritt mit der exchange-Warnung nimmt. In jedem Fall übergeben Sie syminfo.qty_step (lesen Sie syminfo.mincontract von seinem Chart ab), um die Lotgröße selbst festzulegen: Eine Lotgröße, die Sie angeben, ist Ihre, auch wenn sie dem Standard oder Binances Schritt entspricht, und die Warnung verschwindet.

Gibt das Berichts-JSON des eigenständigen pineforge-release-Images zurück (engine, input, summary, trades, metrics, equity_curve, fingerprint, applied_inputs, applied_overrides, applied_runtime, diagnostics, elapsed_seconds) plus einen _meta-Block, inline, wenn er auf höchstens 200.000 Bytes serialisiert:

{
  "engine": "pineforge",
  "summary": { "total_trades": 49, "net_pnl": -190.85, ... },
  "applied_inputs":    { "Fast Length": "8", "Slow Length": "21" },
  "applied_overrides": { "default_qty_value": "5" },
  "applied_runtime":   { "input_tf": "15", ..., "syminfo": { "resolved": true, "qty_step": 0.00001, ... } },
  "trades": [ ... ],
  "equity_curve": [ ... ],
  "elapsed_seconds": 0.0042,
  "_meta": { "strategy_cpp_bytes": 5079, "image": "local" }   // npm/npx: the engine image name
}

Ein langer Lauf (3.000 Stundenbalken reichen) passt nicht in ein MCP-Tool-Ergebnis. Dann wird der vollständige Bericht in report_path geschrieben — Standard pineforge-backtest-<timestamp>.json im Arbeitsverzeichnis des Servers — und das Tool gibt stattdessen ein kompaktes Ergebnis zurück:

{
  "summary": { ... }, "applied_inputs": { ... }, "applied_overrides": { ... }, "applied_runtime": { ... },
  "elapsed_seconds": 0.0008, "total_trades": 73,
  "report_path": "...", "report_path_in_container": "/work/report.json",
  "truncated": true, "note": "...", "_meta": { ... }
}

Im Docker-Image übergeben Sie immer einen absoluten report_path unter /work: Die Datei landet dann in Ihrem gemounteten Ordner. Ohne ihn wird der Bericht unter /app geschrieben, innerhalb des Containers, und verschwindet mit ihm. (report_path und der note-Text werden relativ zum Arbeitsverzeichnis des Containers berechnet, vertrauen Sie also der Datei, die Sie in Ihrem gemounteten Ordner finden, nicht diesen Zeichenfolgen.) Das Inline-Limit ist PINEFORGE_MAX_INLINE_BYTES.

Um einen korrekten absoluten Host-Pfad in report_path zurückzubekommen, führen Sie den Server mit /work als Arbeitsverzeichnis aus und geben Sie ihm die Host-Seite des Mounts in PINEFORGE_HOST_WORKDIR. Der Entrypoint des Images ist ein Pfad relativ zu /app, daher erfordert dies ein explizites --entrypoint; relative Tool-Pfade lösen dann auch innerhalb des Mounts auf:

docker run --rm -i -v "$PWD:/work" -w /work -e PINEFORGE_HOST_WORKDIR="$PWD" \
  --entrypoint node ghcr.io/pineforge-4pass/pineforge-backtest-mcp:latest /app/dist/index.local.js

Mit dem einfachen docker run von Install (Arbeitsverzeichnis /app), macht PINEFORGE_HOST_WORKDIR report_path immer noch absolut, aber falsch: Es wird mit dem Pfad des Berichts relativ zu /app verbunden.

backtest_pine_grid — Parametersweep

Transpiliert den Pine-Quellcode einmal (lokal, im Container), kompiliert und führt dieses C++ dann für jede Kombination im kartesischen Produkt von inputs × overrides aus: Jede Kombination ist ein frischer g++-Build derselben Übersetzungseinheit, gefolgt von seinem Backtest. Gibt eine Rangliste plus den obersten Eintrag unter best zurück.

{
  "source": "//@version=6\nstrategy(\"macd\")\n...",
  "ohlcv_csv_path": "/work/btcusdt_15m_7d.csv",

  // Each axis is {key: list-of-values}. All combinations are tried.
  "inputs": {
    "Fast Length": [8, 12, 19],
    "Slow Length": [21, 26, 39]
  },
  "overrides": {
    "default_qty_value": [1, 5],
    "commission_value":  [0.04]
  },

  // Optional knobs:
  "fixed_inputs":     { "Source": "close" },   // applied to every combo
  "fixed_overrides":  {},                      // typed strategy() overrides
  "runtime":          { "input_tf": "15",      // engine runtime args, fixed
                        "script_tf": "60" },   // across the sweep
  "max_combinations": 64,                      // default 64, at most 1024; a bigger grid is an error
  "concurrency":      2,                       // parallel runs: default 1, at most 8
  "include_trades":   false,                   // default false: omit per-trade lists
  "sort_by":          "net_pnl",               // net_pnl (default) | win_rate_pct | max_drawdown | total_trades
  "report_path":      "/work/grid.json"        // where an oversized sweep is written
}

Das Ergebnis hat total_combinations, succeeded, failed, sort_by, best und results (erfolgreiche Läufe, sortiert nach sort_by, absteigend, dann Fehlschläge). Ein Sweep, der zu groß für eine Inline-Rückgabe ist, wird in report_path geschrieben und das Tool gibt best zurück, die Top 10 in top_results, results_truncated und report_path.

check_tradingview_parity — Bewerten Sie Ihre TradingView-Ergebnisse

Geben Sie ihm ein Pine-v6-Skript und TradingViews eigenen Strategy-Tester-Export dafür. Es führt das Skript auf demselben Markt und Fenster aus und bewertet die beiden Handelslisten Trade für Trade mit scripts/verify_corpus.py von pineforge-engine v1.2.0 (sha256 431452ecddc8184937951ddf9a4c5f29029731237301967b5b480800be6fd1a6), byte-identisch in v1.3.0 und dem eingefrorenen 1.4.0-Kandidaten. Der Bewertungs-Pin und die Bewertung sind unverändert. Der separat gebündelte scripts/run_strategy.py-Ausführungsharness wird nun byte-für-byte aus dem eingefrorenen 1.4.0-Engine-Kandidaten (SHA-256 36f7cf77e0b6355ce03f5d251c7c414f22be7da81ae4743a769f0527f06904d0) kopiert. Im Vergleich zum alten v1.2.0/v1.3.0-Vendor fügt er stabile Fehlercode-/Argument- Behandlung, Erkennung fehlgeschlagener Status bei leerem Fehlertext und Docker-Override- String-Serialisierung hinzu. Die Grader- und Feed-Ableitungs-Bytes bleiben unverändert in den Vendor-Hashes. Exakte Dateiidentität und fokussierte Stand-in-Regressionszeugen sind kein frischer Nachweis der Parität zum nativen Engine-Korpus.

Die Harness-CLI gibt den Engine-Fehlercode aus, aber das Paritätswerkzeug gibt diesen Code noch nicht zurück; dies ist eine bekannte Einschränkung in 1.4.0.

Historischer Schnittstellennachweis, keine erneute 1.4.0-Korpus-Ausführung: geprüft gegen das offene pineforge-corpus bei a35c7c4, auf Engine v1.1.0 und Codegen c5d97ee5: der Bewertungskern gibt die veröffentlichte Stufe für alle 309 Sonden zurück, die das Korpus-Gate bewertet, und das Werkzeug selbst, über stdio mit nur den untenstehenden Eingaben aufgerufen, gibt sie für eine stratifizierte Stichprobe von 30 zurück.

{
  "pine": "//@version=6\nstrategy(\"my strategy\")\n...",
  // The "List of trades" CSV as TradingView exports it, or the Strategy Tester
  // XLSX report base64-encoded (it starts with UEsDB).
  "tradingview_trades": "Trade number,Type,Date and time,Signal,Price USDT,...",
  "symbol": "BINANCE:ETHUSDT.P",          // TradingView ticker
  "timeframe": "15",                      // TradingView resolution: 1, 5, 15, 60, 240, 1D, ...
  "range_start": "2025-04-01T00:00:00Z",  // first bar TradingView computed (UTC unless an offset is given)
  "chart_timezone": "Asia/Taipei",        // the timezone TradingView printed the trade times in

  // Optional:
  "range_end": "2025-10-01T00:00:00Z",    // default: the export's last row
  "inputs": { "Fast Length": 8 },         // TradingView's Inputs tab, as in backtest_pine
  "strategy_overrides": { "commission_value": 0.04 },  // TradingView's Properties tab (list_engine_params)
  "runtime": { "bar_magnifier": true },   // list_engine_params runtime args
  "max_mismatches": 10,                   // mismatching trades to list: default 10, at most 50
  "ohlcv_csv_path": "/work/eth_15m.csv",  // or "ohlcv_csv": "<CSV text>": your own bars
  "syminfo": { "qty_step": 0.001 }        // the instrument's own values, as in backtest_pine
}

Eingabe	Hinweise
pine	Pine-v6-Quellcode, höchstens 256 KiB
tradingview_trades	„Liste der Trades“-CSV-Text (Spalten Trade number, Type, Date and time, eine Price-Spalte) oder der XLSX-Bericht als base64
symbol	TradingView-Ticker; erforderlich, außer das XLSX gibt ihn an oder Sie übergeben Bars
timeframe	TradingView-Auflösung; erforderlich, außer das XLSX gibt sie an
range_start	ISO-8601-Datum oder -Datumszeit der ersten Bar des Backtests; erforderlich, außer das XLSX gibt sie an
range_end	optional; Standard: die letzte Zeile des Exports (das Ergebnis sagt dies)
chart_timezone	IANA-Name der Zeitzone, in der die Handelszeiten gedruckt werden (UTC+8-Stil-Offsets werden akzeptiert); erforderlich, außer der Export gibt sie an; TradingViews „Exchange“-Einstellung wird nicht erraten
inputs, strategy_overrides, runtime	optional, dieselben Schlüssel wie backtest_pine
max_mismatches	optional, Standard 10, höchstens 50
syminfo	optional: die eigenen Werte des Instruments (qty_step, mintick, ...), wie in backtest_pine; sie gehen über das hinaus, was der Ticker auflöst, und sind das gesamte Instrument für einen anderen Markt als Binance
ohlcv_csv / ohlcv_csv_path	Ihre Bars, sodass jeder Markt funktioniert: timestamp,open,high,low,close,volume (Epoche in ms) oder TradingViews Diagramm-Export time,open,high,low,close,Volume (Epoche in Sekunden oder ISO 8601); Pfade folgen den backtest_pine-Regeln
magnifier_ohlcv_csv / magnifier_ohlcv_csv_path	optionale 1-Minuten-Bars für einen deklarierten Bar-Vergrößerer, die das Öffnen der ersten Diagramm-Bar bis zum Schluss der letzten Diagramm-Bar abdecken; gleiche Formate, Grenzen und Pfadregeln wie ohlcv_csv / ohlcv_csv_path

Grenzen (bei Überschreitung mit einem einfachen Fehler abgelehnt):

Was	Grenze
pine	262.144 Bytes (256 KiB) UTF-8
tradingview_trades	33.554.432 Zeichen (32 × 1024²) wie übergeben; die Handelsliste, die der Grader liest (die CSV oder die aus dem XLSX neu aufgebaute), höchstens 32 MiB UTF-8 und 400.000 Zeilen
XLSX-Bericht	jeder dekomprimierte Teil höchstens 64 MiB, alle Teile zusammen höchstens 128 MiB; ein Blatt höchstens 400.000 Zeilen und 256 Spalten; die gelesenen Blätter (Liste der Trades und Eigenschaften) zusammen höchstens 8.000.000 Zellen, einschließlich der leeren Zellen innerhalb jeder Zeile; höchstens 2.000.000 gemeinsame Strings
ohlcv_csv	67.108.864 Zeichen (64 × 1024²)
ohlcv_csv_path	keine Größenbegrenzung (ein TradingView-Diagramm-Export wird im Speicher konvertiert)
Binance-Abruf	100.000 Diagramm- und Vergrößerer-Bars zusammen
Laufzeit	PINEFORGE_PARITY_TIMEOUT_MS, Standard 600.000 ms für Transpilierung, Kompilierung, Backtest und Bewertung zusammen

Es gibt kein Kontingent und kein Verlaufsfenster hier: Der Bereich ist nur durch die Bars begrenzt, die Sie übergeben, oder durch den 100.000-Bar-Binance-Abruf.

Bars. Ihre ohlcv_csv / ohlcv_csv_path, wenn angegeben. Andernfalls wird BINANCE:<SYMBOL> als Binance-Spot-Klines abgerufen und BINANCE:<SYMBOL>.P als USDT-M-Perpetual-Klines, von der öffentlichen API, höchstens 100.000 Bars. Jedes andere Symbol ohne Bars ist ein Fehler, der danach fragt. Skripte, die use_bar_magnifier = true deklarieren, rufen auch 1-Minuten- Bars bis zum Schluss der letzten Diagramm-Bar ab, gezählt in derselben Grenze, wenn das Diagramm eines ist, das der Harness vergrößert (gröber als 1 Minute, höchstens 1 Tag) und runtime.bar_magnifier nicht false ist. Mit Ihren eigenen Bars übergeben Sie optional magnifier_ohlcv_csv / magnifier_ohlcv_csv_path; wenn das Skript den Vergrößerer deklariert, aber ohne einen läuft, warnt das Ergebnis, dass Fills innerhalb von Bars von TradingViews abweichen können.

Instrument. Die Ausführung wendet die Losgröße und Tick-Größe des Instruments an, wie backtest_pine es tut: für BINANCE:<SYMBOL> und BINANCE:<SYMBOL>.P, TradingViews eigene Losgröße aus der mitgelieferten Tabelle (Binances LOT_SIZE.stepSize für ein Symbol, das TradingView nicht auflistet, TradingViews übliches 0,001 für eine Auflistung neuer als die Tabelle, jeweils mit einer Warnung) und die Tick-Größe aus Binances exchangeInfo; mit Ihren eigenen Bars und ohne Ticker, der Sidecar neben Ihrer Bars-Datei; jede andere Börse benötigt syminfo. Ohne eine Los- größe rundet die Engine keine Order, kann Unter-Los-Margin-Call-Zeilen buchen, die TradingView nicht tut, und die Handelslisten passen dann schlechter zusammen: Das Ergebnis warnt. Das Ergebnis zeigt, was angewendet wurde unter applied_instrument (und in einer Textzeile, Instrument: ...); dasselbe Instrument geht an den Bewertungskern als Anforderungsschlüssel instrument.

XLSX-Bericht. Das Blatt „Liste der Trades“ wird wie die CSV gelesen (Excel-Daten werden zu YYYY-MM-DD HH:MM). Das Blatt „Eigenschaften“ liefert das Symbol, den Zeitrahmen, den Datumsbereich, das Anfangskapital, die Ordergröße, das Pyramiding, die Provision, den Slippage und die Fill- Optionen, die es angibt; Sie können dieselben Einstellungen explizit übergeben, aber ein Wert, der mit dem Export nicht übereinstimmt, ist ein Fehler, der beide benennt. Im Export aufgeführte Strategieeingaben werden gemeldet, nicht angewendet: Übergeben Sie inputs für jede, die Sie geändert haben. TradingView dokumentiert dieses Layout nicht, daher werden Blatt- und Schlüsselnamen locker abgeglichen und unbekannte Schlüssel ignoriert.

Ergebnis. Ein Klartextblock und dieselben Daten als JSON (structuredContent): die Stufe und was sie bedeutet, jede Prüfung mit ihrem Wert und Schwellenwerten, wie viele Trades übereinstimmten und wie viele nur TradingView- oder nur PineForge-spezifisch sind, die ersten Abweichungen Seite an Seite mit einem Hinweis, wo die Daten einen zeigen (Fensterrand, eine Position, die am Bereichsende offen ist, Größe, Provision oder Slippage, Zeitzone), eine Zeitzonenprüfung, das Fenster und die Engine-, Codegen- und Grader-Versionen. Trades paaren sich, wenn sie dieselbe Richtung haben, einen Einstieg innerhalb einer Stunde und einen Einstiegspreis innerhalb von 3 $. Wenn die meisten übereinstimmenden Trades bei demselben Nicht-Null-Offset liegen oder eine andere Zeitzone deutlich mehr Trades abgleicht, sagt das Ergebnis dies; die Stufe bleibt die unter der von Ihnen angegebenen Zeitzone.

Stufen, wie verify_corpus.py v1.2.0 sie bewertet. Zähler-Δ ist |TradingView − PineForge| / max(TradingView, PineForge) Trades; die p90-Werte sind 90. Perzentile der relativen Unterschiede pro Trade über übereinstimmende Trades; Abdeckung ist übereinstimmende Trades über alle geschlossenen TradingView-Trades.

Stufe	Regel
ausgezeichnet	gleiche Handelszahlen; Abdeckung ≥ 99 % oder höchstens 1 nicht übereinstimmender Trade; Einstiegspreis-p90 < 0,01 %; Ausstiegspreis-p90 < 0,01 % (Produktionsprofil: < 0,05 %); P&L-p90 < 1 % (Produktionsprofil: < 100 %); wo TradingView mehrere Einstiege zu einer Zeit und einem Preis zeigt, hat PineForge genauso viele
stark	Abdeckung ≥ 95 % oder höchstens 1 nicht übereinstimmender Trade; Zähler-Δ < 6 %; Einstiegspreis-p90 < 0,1 %; Ausstiegspreis-p90 < 0,5 %; P&L-p90 < 100 %
moderat	Abdeckung ≥ 75 % und mindestens 90 % der TradingView-Trades übereinstimmend
schwach	mindestens ein Trade übereinstimmend
minimal	kein Trade übereinstimmend

Das Produktionsprofil gilt, wenn das Skript trail_points, trail_offset oder trail_price auf strategy.exit setzt; jedes andere Skript wird mit dem strengen Profil bewertet. Methode: https://pineforge.dev/en/methodology/.

Aufbewahrung. Alles läuft auf Ihrem Rechner; Marktdaten werden nur von Binance abgerufen, wenn Sie keine Bars übergeben. Das Skript und die Handelsliste sowie Bars, die konvertiert oder abgerufen werden mussten, gehen in temporäre Ordner, die gelöscht werden, wenn die Prüfung endet. Mit npm/npx läuft die Prüfung in dem Engine-Image (docker run --network=none, der Bewertungskern und Ihre Bars schreibgeschützt gemountet).

fetch_binance_ohlcv — Marktdaten abrufen

Schreibt eine backtestbereite CSV (Kopfzeile timestamp,open,high,low,close,volume, Zeitstempel = Öffnungszeit in UNIX ms UTC) von Binances öffentlichen Endpunkten. Keine Authentifizierung erforderlich. Anfragen > 1000 Bars werden automatisch paginiert. output_path folgt denselben Regeln wie ohlcv_csv_path: in Docker einen absoluten Pfad unter /work verwenden; mit npx muss es innerhalb des Arbeitsverzeichnisses bleiben, außer PINEFORGE_ALLOW_ANYWHERE=1.

{
  "symbol":      "BTCUSDT",
  "interval":    "15m",          // 1s (spot only), 1m, 3m, 5m, 15m, 30m, 1h, 2h, 4h, 6h, 8h, 12h, 1d, 3d, 1w, 1M
  "market":      "spot",         // default; or "usdt_perp" for USDT-margined perpetual futures
  "limit":       672,            // total bars: default 1000, at most 100000; > 1000 paginates
  "output_path": "/work/btcusdt_15m_7d.csv"
  // Optional: "start_time" / "end_time" in UNIX ms UTC.
}

Es schreibt auch <output_path>.instrument.json: das Instrument des Symbols (TradingViews Los- größe aus der mitgelieferten Tabelle, Binances für ein Symbol, das TradingView nicht auflistet, TradingViews übliches 0,001 für eine Auflistung neuer als die Tabelle; die Tick-Größe und Währungen aus Binances öffentlichem exchangeInfo), das backtest_pine und check_tradingview_parity aufnehmen (siehe Das Instrument); die instrument und instrument_path des Ergebnisses zeigen es. Wenn exchangeInfo nicht gelesen werden kann, wird die CSV trotzdem geschrieben, instrument sagt warum und ein warnings-Eintrag sagt, was an backtest_pine zu übergeben ist.

binance_symbols — Symbole entdecken / validieren

Gibt die Liste der Symbole zurück, die auf der öffentlichen Binance-API für den OHLCV- Abruf verfügbar sind. 5 Minuten im Prozess zwischengespeichert. Verwenden Sie dies, um ein Symbol zu validieren, bevor Sie fetch_binance_ohlcv aufrufen.

{
  "market":        "usdt_perp",   // required: "spot" or "usdt_perp"
  "query":         "BTC",         // case-insensitive substring match
  "quote_asset":   "USDT",
  "base_asset":    "BTC",
  "status":        "TRADING",
  "contract_type": "PERPETUAL",   // futures-only filter
  "limit":         50             // default 200, at most 2000
}

Abdeckungswerkzeuge

PineForge implementiert eine Teilmenge von Pine v6, also prüfen Sie, bevor Sie eine Strategie schreiben oder portieren:

• list_coverage_topics — jedes Abdeckungsthema mit einem Status (supported, partial, unsupported, via_transpiler) und einer Zusammenfassung, plus die Legende.
• get_coverage_topic { "topic": "ta" } — die vollständigen supported / partial / via_transpiler / unsupported-Listen für eine Themen-ID (zum Beispiel ta, strategy_orders, request_security).
• check_pine_feature { "feature": "ta.supertrend" } — ein Bezeichner oder Namespace: supported / partial / unsupported / via_transpiler / not_found, mit einem Hinweis, der den Katalogeintrag zitiert. Plots, Tabellen und Alerts (plot, bgcolor, table, alert) werden akzeptiert und haben keine Wirkung; line, box und label-Objekte sind Daten, die die Strategie zurücklesen kann.

Jeder Status beschreibt, was ein Backtest über diesen Server tun kann. Der Server installiert keine Bars anderer Symbole, keine aufgezeichneten Anforderungsdaten und keine Pine-Bibliotheks- quellen, also wo die Engine mehr unterstützt, sagt der Eintrag dies: request.security auf einem anderen Symbol zum Beispiel wird von der Engine unterstützt, aber hier stoppt eine Anforderung, deren Wert einen Trade erreichen kann, die Ausführung.

Der eingebettete Katalog ist engine v1.4.0 + codegen 1.4.0 (2026-10-08) in coverage_version gestempelt. Dies ist eine begrenzte, veröffentlichungsorientierte Prüfung des eingefrorenen Paares, kein neuer Test jedes Katalogeintrags. Historisches Inventar und ungelöste Einschränkungen bleiben bestehen; Bars anderer Symbole, aufgezeichnete Anforderungen und Bibliotheksquellen werden von diesem Server weiterhin nicht bereitgestellt.

Die direkt betroffenen Assertionen zitieren Kandidaten-Quellzeugen:

• Numerische Float-matrix.sum-Matrix/Matrix- und Matrix/Skalar-Formen, Methoden und id1/id2-Schlüsselwörter werden durch Matrix-Overload-Zeugen abgedeckt; dies beansprucht keine Arithmetik für Bool-/String-/Farb-/UDT-Matrizen.
• Getestete lokale Verlaufs-Array- und Float/Int-Matrix-Bindungen bewahren na; Verlaufs-Zeugen und begrenzte Schlüsselwort-/Callable-Zeugen halten die leere Kopie des Callables, den Funktionslokalen/Parameterverlauf und die Kartenverlaufsgrenzen explizit.
• pineforge.h hat 81 PF_API-Deklarationen: 64 Laufzeitimplementierungen und 17 generierte Deklarationen, plus vier generierte Beleg-Exporte außerhalb dieses Headers. Die zwei hinzugefügten Laufzeit-Getter legen Fehlercode/-argumente offen; PF_ABI_VERSION bleibt 4.
• Das Eingabemanifest veröffentlicht supported und deskriptorgestützte Standardwerte, Auswahlmöglichkeiten und Grenzen (Manifest-Zeugen, Belegübereinstimmung und bekannte Grenzen). Eine leere Optionsliste ist kein nicht unterstütztes Flag, und berechnete Ausdrücke, Farbkodierungen und zeitzonenabhängige Standardwerte sind nicht garantiert gleich nativen Belegwerten. Der Release-Image-Backtest verwendet geprüfte Setter, wenn die Bibliothek das vollständige Protokoll bereitstellt; der Legacy-Paritäts-Harness und der Legacy-Bibliotheks-Fallback etablieren nicht die gleiche Durchsetzung. UI-Layout-Metadaten sind weiterhin inert.

Der historische Laufzeitkatalog bleibt die allgemeine Referenz; keine historischen Inventarsummen werden neu geschrieben.

Dateisystembereich

Mit npx müssen OHLCV-, Ausgabe- und Berichtspfade standardmäßig innerhalb des aktuellen Arbeitsverzeichnisses des MCP-Serverprozesses liegen. Die Prüfung läuft auf dem aufgelösten Pfad: ..-Segmente und symbolische Links werden zuerst aufgelöst, sodass keiner darauf außerhalb zeigen kann, und ein symbolischer Link, dessen Ziel nicht existiert, wird abgelehnt. Eine Daten- datei oder ein Ordner, der von außerhalb in das Arbeitsverzeichnis verlinkt ist, wird daher ebenfalls abgelehnt. Überschreiben mit:

export PINEFORGE_ALLOW_ANYWHERE=1

Das Docker-Image setzt PINEFORGE_ALLOW_ANYWHERE=1 selbst (der Container ist die Sandbox), sodass dort jeder Pfad akzeptiert wird — verwenden Sie absolute /work/...-Pfade.

Andere Umgebungsvariablen

var	Standard	Zweck
PINEFORGE_IMAGE	Unveränderlicher Digest aus dem installierten release-lock.json	npm/npx nur: Engine-Image (Laufzeit + gebündelter Codegen), verwendet für Transpilierung + Backtest
PINEFORGE_ALLOW_ANYWHERE	0 (1 im Docker-Image)	OHLCV-/Ausgabe-/Berichtspfade außerhalb des cwd erlauben
PINEFORGE_DOCKER_TIMEOUT_MS	120000	Harte Beendigung für jeden Engine-Lauf und für docker pull
PINEFORGE_MAX_INLINE_BYTES	200000	Größter inline zurückgegebener Bericht; größere werden in report_path geschrieben
PINEFORGE_PARITY_TIMEOUT_MS	600000	Zeitlimit eines check_tradingview_parity-Laufs (Transpilierung, Kompilierung, Backtest, Bewertung)
PINEFORGE_BINANCE_TIMEOUT_MS	20000	Zeitlimit jeder Anfrage an Binance (Klines-Seite, exchangeInfo); ein Backtest mit einem symbol, das Binance nicht erreichen kann, läuft trotzdem, ohne Losgrößenraster, und sagt dies
PINEFORGE_BINANCE_SPOT_URL / PINEFORGE_BINANCE_FAPI_URL	https://api.binance.com / https://fapi.binance.com	Basis-URLs der Spot- und USD-M-Public-APIs von Binance (klines, exchangeInfo): ein Spiegel oder Proxy, wenn api.binance.com nicht erreichbar ist
PINEFORGE_TV_GRID	nicht gesetzt	Pfad zu einer Losgrößentabelle, erstellt von scripts/sync-tv-grid.mjs, verwendet anstelle der mitgelieferten (src/tv-grid.generated.json)
PINEFORGE_HOST_WORKDIR	nicht gesetzt	Docker: der Host-Ordner, gemountet bei /work; wenn gesetzt, ist report_path ein absoluter Host-Pfad — korrekt nur, wenn der Server mit /work als Arbeitsverzeichnis läuft (siehe Ende des backtest_pine-Beispiels)

Mit Docker übergeben Sie diese als -e NAME=value.

Entwickeln

npm ci
npm run build     # tsc; also writes the gitignored src/version.ts
npm test

Die TradingView-Losgrößentabelle (src/tv-grid.generated.json) wird generiert, nicht bearbeitet. Wenn TradingViews Messungen aktualisiert werden (eine Tabelle mit Schema pineforge-tv-syminfo-receipts/v1 mit TradingViews eigenem mincontract pro Symbol), regenerieren Sie sie mit einem Befehl und committen Sie das Ergebnis:

node scripts/sync-tv-grid.mjs <path to tv-grid-table.json>

Sie behält nur die beiden Binance-Venues: das mincontract jedes Symbols, die not_on_tv-Liste des Venues und pro Markt TradingViews übliche Losgröße (0,001, mit dem Anteil der Messwerte, die es sind, und deren Anzahl, nur wenn dieser Anteil mindestens 0,80 beträgt). Sie schreibt sortierte Symbole eine pro Zeile, zeichnet die generated_utc der Tabelle und sha256 sowie ihren eigenen Inhalts-Hash auf (der die Messwerte, die Listen und die Standardwerte abdeckt) und lehnt eine Tabelle ab, die nicht vollständig ist, keine not_on_tv-Liste für eines der beiden Binance-Venues hat (eine leere ist in Ordnung) oder einen Wert außerhalb 1e-12..1e12 hat. Dieselbe Tabelle ergibt dieselben Bytes; PF_TV_GRID_SOURCE=<path to the table> npm test prüft auch, dass die committete Datei daraus erstellt wurde.

Um das Image zu bauen, verwenden Sie den committeten Image-Digest und die Version zusammen:

docker build -f docker/Dockerfile \
  --build-arg "PINEFORGE_RELEASE_IMAGE=$(node -p "const l=require('./release-lock.json'); l.image.repository+'@'+l.image.digest")" \
  --build-arg "PINEFORGE_RELEASE_VERSION=$(node -p "require('./release-lock.json').release_version")" \
  --build-arg "PINEFORGE_SOURCE_SHA=$(git rev-parse HEAD)" \
  -t pineforge-backtest-mcp .

Automatische Verteilung verwendet manifestgestützte Update-PRs und die erforderliche release/ready-Prüfung. Siehe das Offline-Release-Ketten-Runbook für CI-Fixtures, Repository-Einstellungen, Belege und Kanalwiederherstellung.

Lizenz

Dieser Server ist MIT-lizenziert (LICENSE). Das Image bündelt auch pineforge-engine (Apache-2.0) und den pineforge-codegen-Transpiler (Quellcode verfügbar unter der PineForge Source License 1.2 ab Codegen 1.3.0: kostenlos für nichtkommerzielle Nutzung und für persönlichen Handel; Investmentmanagement außer persönlichem Handel und andere kommerzielle Nutzung erfordern eine kommerzielle Lizenz. Der Handel mit einem Konto, das eine Proprietary-Trading-Firma oder ein Funded-Trader-Programm bereitstellt oder zuweist, einschließlich eines Challenge-, Evaluierungs- oder simulierten Kontos, ist kein persönlicher Handel, und das Kapital darin, real oder simuliert, ist Investitionskapital). Frühere Versionen behalten die Lizenz, unter der sie veröffentlicht wurden: Codegen 1.2.0 die PineForge Source License 1.1 und 1.1.0 und früher die PolyForm-Noncommercial-Bedingungen, mit denen sie ausgeliefert wurden. Der Codegen LICENSE ist der maßgebliche Text. Siehe LEGAL.md.