Pular para o conteúdo

CI do engine: 311/312 scripts Pine excelentes

A estratégia restante, em âmbar, é uma anomalia declarada.

Estratégias compostasIndicadoresOrdens e riscoTempos gráficos e sessõesExecuções intrabarraLinguagem PineVerificações do analisador
Estratégias compostasIndicadoresOrdens e riscoTempos gráficos e sessõesExecuções intrabarraLinguagem PineVerificações do analisador

Toque ou arraste no gráfico para ver os valores de qualquer ponto.

Fonte: verificação de paridade do corpus aberto na branch main do engine, 2026-09-29.

O gráfico em forma de tabela

Verificação de paridade do corpus aberto na main do engine, 2026-09-29: 311 de 312 estratégias no nível excelente; a restante é uma anomalia declarada.

GrupoEstratégiasExcelenteAnomalia declarada
Estratégias compostas53530
Indicadores79790
Ordens e risco77770
Tempos gráficos e sessões28280
Execuções intrabarra880
Linguagem Pine56560
Verificações do analisador11101

PineForge roda backtests de Pine Script no CI: se algum trade mudar, o build quebra.

Por que paridade no CI

Estratégias driftam como qualquer código. Um rename de parâmetro, uma refatoração de função helper, uma mudança na API do Pine v6 que você não percebeu: qualquer um deles pode mexer silenciosamente nos sinais sem quebrar nenhum teste existente. Sem um gate de paridade no CI, um commit que você fez dois meses atrás pode mudar a lista de trades da semana passada e você só vai descobrir quando o P&L ao vivo ficar errado.

A disciplina de commitar sua lista de trades de referência junto com o source da estratégia é a mesma disciplina que faz software ser confiável: você descreve o output esperado e seu build quebra se o output real divergir. Pra um backtest, o output esperado é a lista de trades (barra de entrada, barra de saída, direção, tamanho, preço de execução) contra um dataset histórico fixado.

Quando essa comparação roda em todo commit, você ganha uma catraca: o comportamento histórico da sua estratégia só pode melhorar, nunca regredir por acidente. Você sabe exatamente qual commit mudou o output, porque o build quebrou nesse commit. Você tem um git blame pra sua curva de equity.

Isso importa mais do que a maioria dos quants percebe no começo. O abismo entre "testei essa estratégia" e "tenho um registro reproduzível, versionado, de cada sinal histórico que essa estratégia já produziu" é enorme. O primeiro é um print. O segundo é um audit trail. CI é como você mantém o segundo sem esforço manual em cada push.

O PineForge se encaixa aqui porque o runtime é uma imagem Docker: roda onde o Docker rodar, gera os mesmos trades para os mesmos dados de entrada e escreve um relatório JSON que você pode processar com jq. Não há navegador, login nem limite de requisições no backtest em si.

Exemplo em GitHub Actions

O fluxo completo: faz o checkout da sua estratégia, transpila para C++ com a imagem pineforge-release, roda o backtest no seu CSV de OHLCV fixado, lê o relatório JSON com jq, compara com sua baseline commitada e quebra o build se algum trade mudar de direção ou de barra, ou se o delta de PnL líquido passar do seu threshold.

O runtime é uma imagem de container, então não tem chave de API pra gerenciar. É só dar docker run no job. Crie .github/workflows/backtest.yml:

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 1

Guarde seu relatório baseline em baseline/report.json no repo, commitado junto com o source da estratégia. Quando um PR muda o comportamento da estratégia de propósito, o autor atualiza a baseline como parte do PR. Esse diff vira um registro permanente do que mudou e por quê.

O mesmo fluxo de trabalho roda igual no GitLab CI, Bitbucket Pipelines ou qualquer runner que suporte Docker. Troque a sintaxe YAML, mantenha os comandos shell.

Exit codes e asserção de paridade

O runtime do PineForge sai com código 0 numa execução sem erros e com um código diferente de zero em caso de falha: 2 para arquivo de entrada ausente, 3 para falha de compilação, 4 para falha no backtest e 5 para falha de transpilação (Pine não suportado ou erro de sintaxe). O CI reconhece esses códigos sem nenhum tratamento especial.

A verificação do resultado fica por conta do seu fluxo de trabalho. O relatório tem este formato (resumido):

{
  "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:...", ... }
}

Pra um check numérico simples de paridade, compare summary.net_pnl e summary.total_trades contra a baseline. O fluxo de trabalho acima também lê o array trades: cada trade precisa manter a mesma direção e as mesmas barras de entrada e de saída. Quando uma verificação falha, o fluxo de trabalho faz o diff das duas listas de trades com um trade por linha; assim, os números de linha do diff são os números dos trades, e cada linha mostra a direção, as barras, os preços, a quantidade e o P&L de um trade, antes e depois.

Threshold prático pra campos numéricos: aceite deltas de ponto flutuante até 0.01 (um centavo de P&L líquido) e quebre em qualquer coisa maior. Para os trades, a tolerância é zero: o fluxo de trabalho acima falha com qualquer mudança de direção, de entry_bar_index ou exit_bar_index, seja qual for o P&L. Um trade que cai numa barra diferente significa que a sua lógica de sinal mudou.

Um padrão prático: atualize a baseline num passo separado do fluxo de trabalho, condicionado a um rótulo no PR, para que uma mudança intencional apareça na revisão de código ao lado da alteração no Pine que a causou.

Próximos passos