# FOSSATI AI TRADING BOT — AGENT BRIEFING
> Documento de continuidade para agente Claude (Sonnet/Opus) via Claude Code CLI  
> Versão: 1.0 | Criado em: 2026-05-11 | Idioma de trabalho: PT-BR

---

## 1. IDENTIDADE DO PROJETO

**Nome:** Fossati AI Trading Bot  
**Metodologia base:** Método Inteligente Fossati — SMC PRO Elite  
**Objetivo:** Sistema de trading 100% automatizado por IA para futuros perpétuos na Binance  
**Proprietário:** Carlos (trader brasileiro, especialista em SMC/ICT, desenvolvedor Pine Script avançado)  
**Stack principal:** Python 3.11 + Binance Futures API + Claude API (Anthropic) + Telegram

---

## 2. CONTEXTO DO TRADER

Carlos opera com foco em **Smart Money Concepts (SMC)** e **ICT Methodology**, especializando-se nos pares BTCUSDT e ICPUSDT no TradingView. Ele tem uma suíte de frameworks próprios:

- **Framework A — SMC PRO 200:** Framework original, denso em confluências, CVD e fluxo cross-exchange
- **Framework B:** Versão simplificada em checklist de 11 etapas para uso diário
- **Método Inteligente Fossati — SMC PRO Elite:** Projeto principal atual — metodologia híbrida inspirada em traders brasileiros (Silveira, Ramon Tiburcio, Tatiana Gonçalves, Kakau Lima, Rodrigo Brito), com janela de trading 09h–12h, checklist de 12 confluências (mín. 9/12) e forte ênfase em disciplina emocional
- **Setup LONG/SHORT Pro — Fossati Style:** Indicador TradingView customizado (Pine Script) com S/R, EMAs, RSI, volume e painel de estatísticas
- **Integração TradingView → Make.com → Telegram:** Sistema de alertas em construção

**Preferências de trabalho:**
- Sempre responder em português PT-BR
- Tom prático, direto e colaborativo
- Refinamento colaborativo passo a passo
- Qualidade sobre quantidade — setups de alta confluência

---

## 3. PARÂMETROS OPERACIONAIS DEFINIDOS

| Parâmetro | Valor configurado |
|---|---|
| Saldo inicial | $1.000 USDT |
| Meta diária | 50% do saldo atual (compounding diário) |
| Risco por operação | até 10% do saldo |
| Drawdown máximo diário | 20% |
| Posições simultâneas | máx. 3 |
| Compounding | ativado (ganhos reinvestidos) |
| Ambiente | Binance Futures Perpétuos (conta real) |
| Modo conservador | disponível (`CONSERVATIVE_MODE = True` → 2% risco, 5%/dia) |

**Tokens monitorados (14):**
`BTCUSDT, ETHUSDT, SOLUSDT, BNBUSDT, AVAXUSDT, DOGEUSDT, DOTUSDT, ETCUSDT, BCHUSDT, TRXUSDT, RENDERUSDT, 1000SHIBUSDT, XMRUSDT, HYPERUSDT`

**Alavancagem por score de confluências:**
| Score | Alavancagem |
|---|---|
| 9/12 | 8x |
| 10/12 | 10x |
| 11/12 | 15x |
| 12/12 | 20x |

---

## 4. ARQUITETURA DO SISTEMA (estado atual)

```
fossati_bot/
├── config.py             ✅ Configuração central (todos os parâmetros)
├── main.py               ✅ Loop principal — varre tokens a cada 60s
├── smc_analyzer.py       ✅ Motor SMC: OB, BOS, CHoCH, FVG, Liquidez, score Fossati
├── ai_engine.py          ✅ Claude API: analisa contexto SMC → gera sinal JSON
├── risk_manager.py       ✅ Capital: meta diária, drawdown, sizing, compounding
├── executor.py           ✅ Binance Futures: market order + SL + TP parciais + trailing
├── notifier.py           ✅ Telegram: alertas formatados de trade, P&L, status
├── dashboard_server.py   ✅ Flask API: endpoints REST para o dashboard
├── dashboard.html        ✅ Dashboard web tempo real (atualiza a cada 5s)
├── requirements.txt      ✅ Dependências Python
├── .env.example          ✅ Template de variáveis de ambiente
└── README.md             ✅ Instalação e uso
```

### Módulos pendentes (próxima fase):
```
├── backtest.py           ❌ NÃO CRIADO — motor de backtesting histórico
├── backtest_runner.py    ❌ NÃO CRIADO — CLI para rodar backtests
├── webhook_handler.py    ❌ NÃO CRIADO — receptor de alertas do TradingView
├── config_panel.html     ❌ NÃO CRIADO — UI browser para reconfigurar o bot
└── backtest_report.html  ❌ NÃO CRIADO — visualização dos resultados de backtest
```

---

## 5. FLUXO DE OPERAÇÃO COMPLETO

```
LOOP PRINCIPAL (a cada 60s):
│
├─ 1. Verifica horário de trading (09h–22h BRT)
├─ 2. Checa risk manager: meta atingida? drawdown limite? posições máx?
├─ 3. Para cada token em SYMBOLS:
│   ├─ Coleta candles: 15m + 1h + 4h (200 candles cada)
│   ├─ SMCAnalyzer.analyze() → detecta OB, BOS, CHoCH, FVG, Liquidez
│   ├─ Calcula RSI-14, volume ratio
│   ├─ Determina direção: BULLISH ou BEARISH (trend + OB + premium/discount)
│   ├─ SMCAnalyzer.score_setup() → checklist 12 confluências Fossati
│   ├─ Se score >= 9/12:
│   │   ├─ AIEngine.generate_signal() → Claude API analisa e aprova/rejeita
│   │   ├─ RiskManager.calculate_position_size() → sizing pelo risco %
│   │   ├─ BinanceExecutor.execute_signal() → alavancagem + market order
│   │   ├─ Coloca SL (stop market) + TP1/TP2/TP3 (50/30/20%) + trailing stop
│   │   └─ TelegramNotifier.send_signal() → alerta formatado
│   └─ Aguarda 1s entre tokens (rate limit)
├─ 4. monitor_positions() → detecta posições fechadas, registra P&L
├─ 5. Verifica meta diária → trava se atingida
└─ 6. Aguarda 60s → próximo ciclo
```

---

## 6. CHECKLIST FOSSATI (12 CONFLUÊNCIAS)

Implementado em `smc_analyzer.py → score_setup()`:

| # | Confluência | Como detecta |
|---|---|---|
| 1 | HTF trend alinhado | trend 4h == direção do sinal |
| 2 | BOS ou CHoCH confirmado | `structure.last_bos` ou `last_choch` |
| 3 | Order Block de qualidade | `ob.strength > 0.5` |
| 4 | FVG presente | `bullish_fvg` ou `bearish_fvg` não vazio |
| 5 | Zona de liquidez (BSL/SSL) | EQH acima (LONG) ou EQL abaixo (SHORT) |
| 6 | Estrutura de mercado favorável | trend 15m == direção |
| 7 | Volume acima da média | `volume_ratio > 1.3` |
| 8 | RSI em zona favorável | LONG: RSI < 55 / SHORT: RSI > 45 |
| 9 | Posição no range P/D | discount (LONG) ou premium (SHORT) |
| 10 | Fase de mercado adequada | expansion ou retracement |
| 11 | R:R mínimo 2:1 | calculado via OB vs próxima liquidez |
| 12 | Price action confirma | score >= 9 nos anteriores |

**Mínimo para entrar: 9/12**

---

## 7. MODELO DE SINAL DA IA (Claude API)

### Input (contexto enviado ao Claude):
```json
{
  "symbol": "BTCUSDT",
  "sinal_proposto": "bullish",
  "preco_atual": 70405.21,
  "saldo_atual_usdt": 1247.38,
  "score_confluencias": "10/12",
  "confluencias": ["✅ HTF trend alinhado", "✅ BOS confirmado", ...],
  "timeframe_15m": {
    "tendencia": "bullish",
    "fase": "retracement",
    "bos": {"direction": "bullish", "level": 69800},
    "in_discount": true,
    "ob_mais_proximo": {"high": 70200, "low": 69900, "forca": 0.82},
    "rsi_14": 48.3,
    "volume_ratio": 1.64
  },
  "timeframe_1h": {"tendencia": "bullish", "fase": "expansion"},
  "timeframe_4h": {"tendencia": "bullish", "fase": "expansion"}
}
```

### Output esperado (JSON do Claude):
```json
{
  "aprovar": true,
  "motivo_rejeicao": null,
  "entry": 70350.00,
  "stop_loss": 69870.00,
  "take_profit_1": 71310.00,
  "take_profit_2": 71790.00,
  "take_profit_3": 72750.00,
  "confidence": 0.84,
  "reasoning": "OB forte em zona de desconto com BOS bullish confirmado no 15m e alinhamento HTF 1h/4h. CVD positivo e volume 1.64x suportam a entrada. R:R de 2:1 conservador para TP1."
}
```

**Modelo usado:** `claude-sonnet-4-20250514`

---

## 8. ENDPOINTS DO DASHBOARD (Flask — porta 5000)

| Método | Rota | Descrição |
|---|---|---|
| GET | `/` | Serve `dashboard.html` |
| GET | `/api/stats` | Estatísticas do dia (P&L, meta, win rate, DD) |
| GET | `/api/balance` | Saldo real da Binance ou fallback do arquivo |
| GET | `/api/positions` | Posições abertas com P&L em tempo real |
| GET | `/api/trades` | Últimos 50 trades do log |
| GET | `/api/equity` | Pontos da curva de equity do dia |
| GET | `/api/symbols` | Performance agregada por token |
| GET | `/api/status` | Status do bot (running/halted/target_reached) |

---

## 9. ARQUIVOS DE ESTADO GERADOS EM RUNTIME

| Arquivo | Conteúdo |
|---|---|
| `daily_stats.json` | Saldo, P&L, trades do dia, meta, drawdown |
| `trades.json` | Histórico completo de trades (append) |
| `fossati_bot.log` | Log detalhado de todas as operações |
| `bot.pid` | PID do processo (dashboard verifica se bot está rodando) |

---

## 10. MÓDULOS A CONSTRUIR (próxima sessão)

### 10.1 BACKTESTING ENGINE (`backtest.py`) ✅ CONCLUÍDO (2026-05-11)
**Arquivos entregues:** `backtest.py`, `backtest_runner.py`, `backtest.html` + rotas Flask em `dashboard_server.py` (`/backtest`, `/api/backtest/run`, `/api/backtest/last`, `/api/backtest/state`).
**Notas:**
- Engine reusa `SMCAnalyzer` e o checklist Fossati (`score_setup`)
- Sizing via risco fixo (`MAX_RISK_PER_TRADE`) calibrado pelo stop %
- Saída: `backtest_results.json` com métricas (WR, P&L, MaxDD, Sharpe, SQN, Profit Factor, by_symbol)
- CLI: `python backtest_runner.py --symbols BTCUSDT --days 90 --interval 15m`
- UI: http://localhost:5000/backtest (formulário + curva de equity + tabela de trades)

### 10.2 CONFIG PANEL (`config_panel.html` + rotas Flask)
**O que deve fazer:**
- Interface web em `/config` com formulário de todos os parâmetros do `config.py`
- Sliders para risco %, meta diária %, drawdown máximo
- Toggles para conservative mode, trailing stop, trading hours
- Checklist de tokens ativos/inativos
- `POST /api/config` salva em `user_config.json` e recarrega o bot sem reiniciar
- `GET /api/config` retorna configuração atual

**Rota Flask a adicionar em `dashboard_server.py`:**
```python
@app.route("/config")
def config_page(): return send_file("config_panel.html")

@app.route("/api/config", methods=["GET", "POST"])
def api_config(): ...
```

### 10.3 TRADINGVIEW WEBHOOK (`webhook_handler.py`)
**O que deve fazer:**
- Receber `POST /webhook/tradingview` com payload JSON do Pine Script
- Validar `secret` no payload para segurança
- Parsear: symbol, direction (LONG/SHORT/CLOSE), price, score, sl, tp
- Chamar `BinanceExecutor.execute_signal()` diretamente (bypass da IA para override manual)
- Retornar `{"status": "executed"}` ou `{"status": "rejected", "reason": "..."}`
- Notificar Telegram com o sinal recebido

**Formato do alerta Pine Script (JSON):**
```json
{
  "secret": "fossati_secret_2026",
  "symbol": "BTCUSDT",
  "action": "LONG",
  "price": 70350,
  "sl": 69870,
  "tp1": 71310,
  "tp2": 71790,
  "score": 11,
  "source": "tradingview_manual"
}
```

**Pine Script alert message template:**
```
{"secret":"fossati_secret_2026","symbol":"{{ticker}}","action":"{{strategy.order.action}}","price":{{close}},"sl":0,"tp1":0,"score":0,"source":"tv_auto"}
```

---

## 11. DEPENDÊNCIAS (requirements.txt atual)

```
python-binance==1.0.19
anthropic>=0.30.0
pandas>=2.0.0
numpy>=1.24.0
python-telegram-bot>=20.0
pytz>=2024.1
aiohttp>=3.9.0
websockets>=12.0
ta>=0.11.0
requests>=2.31.0
python-dotenv>=1.0.0
flask               # dashboard
flask-cors          # dashboard
```

---

## 12. VARIÁVEIS DE AMBIENTE NECESSÁRIAS

```bash
BINANCE_API_KEY=...       # Binance → Gerenciamento de API → Futuros + Leitura
BINANCE_API_SECRET=...    # NÃO habilitar saque
ANTHROPIC_API_KEY=...     # console.anthropic.com → modelo: claude-sonnet-4-20250514
TELEGRAM_BOT_TOKEN=...    # @BotFather no Telegram
TELEGRAM_CHAT_ID=...      # ID do chat para receber alertas
```

---

## 13. COMANDOS PARA RODAR O PROJETO

```bash
# Instalar dependências
pip install -r requirements.txt
pip install flask flask-cors

# Configurar ambiente
cp .env.example .env
# → Editar .env com as chaves reais

# Rodar o bot principal
python main.py

# Rodar o dashboard (terminal separado)
python dashboard_server.py
# → Acessar: http://localhost:5000

# Rodar backtest (quando criado)
python backtest_runner.py --symbols BTCUSDT SOLUSDT --days 90

# Para expor o webhook externamente (ngrok ou VPS)
ngrok http 5000
# → Usar a URL pública no TradingView: https://xxxx.ngrok.io/webhook/tradingview
```

---

## 14. CONVENÇÕES DE CÓDIGO

- **Idioma dos comentários e logs:** português PT-BR
- **Type hints:** usar em todas as funções públicas
- **Dataclasses:** preferir para estruturas de dados
- **Logging:** usar `logging.getLogger("fossati.<modulo>")` sempre
- **Erros Binance:** sempre capturar `BinanceAPIException` separado de `Exception`
- **Respostas da IA:** sempre validar JSON antes de usar, com fallback seguro
- **Config:** nunca hardcodar parâmetros — sempre referenciar `config.<PARAM>`
- **Arquivos de estado:** sempre usar `Path()` do `pathlib`, nunca string pura

---

## 15. INSTRUÇÃO PARA O AGENTE

Você está dando continuidade ao **Fossati AI Trading Bot**, um sistema de trading automatizado por IA para Binance Futures.

**Seu papel:**
1. Ler este briefing completamente antes de qualquer ação
2. Verificar os arquivos existentes no diretório `fossati_bot/` antes de criar novos
3. Construir os módulos pendentes listados na seção 10, na ordem: Backtesting → Config Panel → TradingView Webhook
4. Manter consistência com os padrões de código da seção 14
5. Sempre testar imports e sintaxe antes de declarar um módulo pronto
6. Comunicar em PT-BR com Carlos
7. Ao finalizar cada módulo, atualizar este briefing com o status ✅

**Prioridade imediata:**
Construir `backtest.py` + `backtest_runner.py` com visualização de resultados integrada ao dashboard existente (`dashboard_server.py` → nova rota `/api/backtest` e `/backtest`).

**Contexto técnico importante:**
- O `SMCAnalyzer` já está pronto e pode ser importado diretamente para o backtest
- O `BinanceExecutor.get_candles()` busca dados históricos e pode ser usado no backtest
- O dashboard Flask já está em `dashboard_server.py` — adicionar rotas lá, não criar novo servidor
- Todos os módulos devem ser independentes (podem rodar sem o bot principal ativo)

---

*Briefing gerado em sessão Claude Sonnet 4.6 · Fossati AI Bot v1.0*