🤖 Hyper-Gemma AI Trader

Production-ready Autonomous Quantitative Trading System (Trinity v2) Menggunakan Bitget Futures, Pure Math Quant Engine (Hurst/Z-Score), MongoDB, Node.js, dan TypeScript. AI (Gemma 4) kini menjadi opsional untuk eksekusi ultra-cepat.

📈 Live Trading Results

Total ROI: +4,175.89% (Desember 2025 — Juni 2026) | 1-Month ROI: +1,752.07% | Win Rate: 62.06%

Contoh Trade Profit

Contoh Trade Loss

⚠️ Disclaimer: Hasil masa lalu tidak menjamin performa di masa depan. Trading memiliki risiko — tidak semua trade profit. Gambar di atas adalah hasil trading riil di Bitget.

---

📖 Deskripsi Project

Hyper-Gemma AI Trader (kini berevolusi menjadi Trinity v2 Quant Engine) adalah sistem trading cryptocurrency otonom sepenuhnya (fully autonomous) yang difokuskan pada kedisiplinan Quantitative Mathematics Engine untuk trading futures di Bitget Exchange secara real-time.

Sistem ini menggunakan arsitektur Pure Quant Tactical — mengutamakan kecepatan kalkulasi matematika murni (Quant Trinity: Z-Score + Hurst Exponent + VWAP + Kalman Filter) sebagai pengambil keputusan absolut. Kecerdasan AI (Gemma) disetel pada mode pasif (MOCK_AI=true) untuk mencegah keragu-raguan dan mematikan emosi/halusinasi LLM, sehingga bot 100% patuh pada matematika probabilitas.

🎯 Filosofi Inti

Prinsip	Penjelasan
Pure Math Discipline	100% didorong oleh angka, tanpa intervensi bias LLM (MOCK_AI=true)
Capital Multiplication	Agresif mencari pertumbuhan modal melalui leverage optimal & Moon Bag TP
Risk Over Everything	Hard blocker untuk Trailing Stop dan Liquidation Guard
No Emotion	Tidak FOMO, tidak revenge trade (15-min cooldown)
Regime-Aware	Otomatis menyesuaikan gaya (Trend vs Mean Reversion)

---

🏗️ Arsitektur Sistem

Sistem ini menggunakan Pure Quant Tactical Architecture dengan tiga jalur eksekusi:

┌───────────────────────────────────────────────────────┐
│                  SERVER (Entry Point)                 │
│    Pure Quant Engine + Trinity v2 Router              │
├─────────────┬──────────┬──────────┬───────────────────┤
│     API     │   CORE   │ EXCHANGE │     SERVICES      │
│  (Fastify)  │(AI/Quant)│ (Bitget) │ (Trade Orchestr.) │
├─────────────┴──────────┴──────────┴───────────────────┤
│                  DATABASE (MongoDB)                   │
│    Models → Repositories → Mongoose (Directive)       │
├───────────────────────────────────────────────────────┤
│              MONITORING & UTILITIES                   │
│     Prometheus │ Health Check │ Alert Manager         │
└───────────────────────────────────────────────────────┘

Arsitektur Detail:

• Pure Quant Tactical Architecture — Bot dijalankan dalam MOCK_AI=true (Pure Quant Mode), di mana QuantEngine adalah pengambil keputusan mutlak tanpa intervensi LLM
• Battle Directive System — Saat MOCK_AI=true, Gemma tidak dipanggil. Parameter (bias=NEUTRAL, z_score_threshold, kalman_aggressiveness) menggunakan nilai default optimal yang sudah di-hardcode
• Quant Trinity v2 Engine — Mesin matematika murni untuk deteksi peluang (Z-Score + Hurst Exponent + VWAP + Kalman Filter + RSI + Volume + EMA)
• Regime-Aware Execution — Otomatis memilih strategi: Trend Following (Hurst ≥ threshold) atau Mean Reversion (Hurst < threshold)
• Strategy-Driven — Mendukung multiple trading strategy (SCALPING, INTRADAY, SWING) dengan parameter persentase dinamis
• Scan Mode System — Multiple mode pemindaian: VIP (17 major pairs), HOT{N} (top volume), ALL (seluruh market)
• PAPER Mode Isolation — Mode simulasi terisolasi: posisi mock dihitung dari session trades, bukan posisi exchange riil
• Percent-Based Risk — Semua SL/TP dan batas kerugian menggunakan persentase (bukan USD statis) agar universal untuk semua ukuran modal
• Self-Learning Memory — MongoDB menyimpan pelajaran dari kesalahan
• Risk First Trading System — Risk Manager + Liquidation Guard + 40% Block Rule sebagai penjaga terakhir

---

🛠️ Tech Stack

Kategori	Teknologi
Runtime	Node.js + TypeScript 6.0
Web Server	Fastify 5
AI Engine	Ollama + Gemma 4 (opsional, MOCK_AI=true untuk Pure Quant Mode)
Database	MongoDB Atlas + Mongoose 9
Exchange	Bitget Futures API V2 (USDT-FUTURES)
Quant	simple-statistics + mathjs
Validation	Zod 4
Monitoring	Prometheus (prom-client)
Logger	Pino + pino-pretty
Scheduler	node-cron
Crypto	crypto (HMAC-SHA256 signing)
Math	Decimal.js (precision)
HTTP	Axios

---

📁 Struktur Folder Project

hyper-gemma-ai-trader/
├── src/
│   ├── server.ts                    # Entry point utama (bootstrap + hybrid tactical engine)
│   ├── config/                      # Konfigurasi aplikasi
│   │   ├── env.ts                   # Environment schema validation (Zod)
│   │   └── constants.ts             # Trading & market constants (MAX_LEVERAGE, RSI_PERIOD, dll)
│   ├── core/                        # Logika inti (AI, Quant, Market, Risk)
│   │   ├── ai/
│   │   │   ├── decision-engine.ts   # Orkestrator keputusan AI + GEMMA_FLIP_BLOCKED guard
│   │   │   ├── strategy-governor.ts # Gubernur Strategi Makro (Cold Path / Commander)
│   │   │   ├── ollama-client.ts     # HTTP client untuk Ollama API (generic + validated JSON)
│   │   │   ├── prompt-builder.ts    # Builder prompt dinamis untuk Gemma
│   │   │   └── learning-engine.ts   # Engine pembelajaran dari kesalahan
│   │   ├── quant/
│   │   │   ├── quant-engine.ts      # Mesin trading matematika kecepatan tinggi (Hot Path)
│   │   │   └── quant-utils.ts       # Utilitas: Z-Score, Hurst, VWAP, Kalman, Velocity
│   │   ├── market/
│   │   │   ├── indicator-engine.ts  # Kalkulator indikator teknikal (EMA, RSI, ATR)
│   │   │   └── market-regime.ts     # Deteksi regime market (Trending/Ranging/Volatile)
│   │   └── risk/
│   │       ├── risk-manager.ts      # Validasi risiko, leverage cap & staged allocation
│   │       ├── cooldown-manager.ts  # Sistem cooldown setelah loss
│   │       ├── symbol-cooldown.ts   # Cooldown per-simbol (15 menit setelah gagal eksekusi)
│   │       ├── adaptive-sizer.ts    # Adaptive position sizing
│   │       └── risk-of-ruin.ts      # Kalkulasi Risk of Ruin
│   ├── exchange/
│   │   ├── bitget.client.ts         # Client API Bitget V2 (HMAC-SHA256 signature)
│   │   ├── market-data.provider.ts  # Provider data market real-time (Bitget)
│   │   └── order.executor.ts        # Eksekutor order ke Bitget (atomic SL/TP preset)
│   ├── database/
│   │   ├── mongo.ts                 # Koneksi MongoDB
│   │   ├── models/
│   │   │   ├── trade.model.ts       # Schema trade + lifecycle (entry, exit, PnL, result)
│   │   │   ├── memory.model.ts      # Schema memory/pelajaran
│   │   │   ├── session.model.ts     # Schema sesi trading
│   │   │   ├── directive.model.ts   # Schema Battle Directive (Mongoose)
│   │   │   ├── pulse-log.model.ts   # Schema pulse log (Z-Score, Hurst, Regime per scan)
│   │   │   └── cooldown.model.ts    # Schema cooldown per-simbol
│   │   └── repositories/
│   │       ├── trade.repository.ts  # Repository trade (CRUD + open/close + pair analytics)
│   │       ├── memory.repository.ts # Repository akses data memory
│   │       ├── session.repository.ts # Repository akses data session
│   │       ├── directive.repository.ts # Repository akses Battle Directive
│   │       └── pulse-log.repository.ts # Repository pulse log per scan cycle
│   ├── services/
│   │   ├── trade.service.ts         # Orchestrator eksekusi trade
│   │   └── session.service.ts       # Manajemen sesi trading (lifecycle)
│   ├── api/
│   │   ├── monitoring-api.ts        # Setup Fastify server
│   │   └── routes/
│   │       ├── health.route.ts      # Endpoint /health
│   │       └── metrics.route.ts     # Endpoint /metrics (Prometheus)
│   ├── monitoring/
│   │   ├── metrics.ts               # Custom Prometheus metrics
│   │   ├── health-check.ts          # System health check
│   │   └── alert-manager.ts         # Alert manager (multi-level)
│   ├── types/
│   │   ├── ai.types.ts              # Types untuk AI decision & Ollama
│   │   ├── market.types.ts          # Types untuk market data & account status
│   │   └── enum.types.ts            # Enum untuk trading strategy, mode, action, dll
│   ├── utils/
│   │   ├── json-validator.ts        # Validator JSON ketat (Zod schema: AIDecision + BattleDirective)
│   │   ├── helpers.ts               # Utilitas: formatCurrency, formatCompactNumber, sleep
│   │   └── logger.ts                # Logger configuration (Pino)
│   ├── scripts/                     # Script utilitas dan testing
│   │   ├── backtest.ts              # Script backtesting strategi
│   │   ├── check-balance.ts         # Cek saldo akun Bitget
│   │   ├── simulate-live.ts         # Simulasi trading live
│   │   └── verify-all.ts            # Verifikasi semua komponen sistem
│   ├── tests/                       # Unit & integration tests
│   │   ├── unit/                    # Unit tests
│   │   └── integration/             # Integration tests
│   └── jobs/
│       └── memory-consolidation.job.ts # Job konsolidasi memori harian
├── etc/                             # Dokumentasi & hasil testing
│   ├── ai-promt.json                # Konfigurasi prompt AI & rencana pengembangan
│   ├── financial_projection.md      # Proyeksi finansial & target profit
│   ├── BACKTEST_RESULTS.md          # Hasil backtesting
│   ├── SIMULATION_RESULTS.md        # Hasil simulasi
│   ├── FINAL_VERIFICATION.md        # Verifikasi final sistem
│   └── system_audit_report.md       # Laporan audit sistem
├── images/                          # Screenshot hasil trading riil
├── .env                             # Environment variables (tidak di-commit)
├── .env.example                     # Template environment variables
├── .gitignore                       # Git ignore rules
├── LICENSE                          # MIT License
├── package.json                     # Dependencies & scripts
├── tsconfig.json                    # TypeScript configuration
└── README.md                        # Dokumentasi ini

---

🧩 Detail Fitur

1. 🧠 Strategy Governor (Cold Path / Commander)

File: src/core/ai/strategy-governor.ts

Saat MOCK_AI=true (Pure Quant Mode), Gemma tidak dipanggil. Strategy Governor langsung menulis nilai default ke MongoDB:

• bias: NEUTRAL (tidak memihak arah — biarkan QuantEngine yang menentukan)
• z_score_threshold: 1.5 (SCALPING) atau 2.0 (INTRADAY/SWING)
• kalman_aggressiveness: 0.1
• max_leverage: 50 (akan dicap oleh executor sesuai batas exchange)
• allowed_symbols: [] (semua simbol diizinkan)

Saat MOCK_AI=false (AI Mode), Gemma bertindak sebagai "Gubernur Strategi" yang menganalisis BTC & ETH sebagai barometer pasar dan mengeluarkan Battle Directive setiap jam:

• bias — Arah pasar: LONG, SHORT, atau NEUTRAL
• z_score_threshold — Threshold sensitivitas untuk QuantEngine (1.0-5.0)
• kalman_aggressiveness — Agresivitas Kalman Filter (0.01-0.5)
• max_leverage — Leverage maksimal yang direkomendasikan
• allowed_symbols — Daftar simbol yang diperbolehkan
• reasoning — Alasan di balik keputusan
• Strategy-Adaptive Threshold — SCALPING mendapat threshold rendah (1.0-1.8), INTRADAY mendapat threshold menengah (1.5-2.5)
• Persistent Directive — Disimpan di MongoDB via DirectiveRepository, bertahan antar restart
• Graceful Fallback — Jika gagal, menggunakan directive terakhir yang tersimpan

---

2. ⚡ QuantEngine — Quant Trinity (Hot Path / Math Sensor)

File: src/core/quant/quant-engine.ts

Mesin trading matematika murni yang bekerja dalam milidetik tanpa memanggil AI, menggunakan 3 sinyal utama (Trinity):

• OHLCV Data Pipeline — Mengambil data candlestick lengkap (Open, High, Low, Close, Volume) via getOHLCVHistory() dari Bitget
• Dual Window Analysis — Menggunakan 2 jendela data:
  • Short Window (20 candles) → Untuk Z-Score (anomali jangka pendek)
  • Long Window (50-100 candles) → Untuk Hurst Exponent (SCALPING: 50, INTRADAY/SWING: 100)
• Regime-Aware Execution Logic — Otomatis memilih strategi berdasarkan Hurst Exponent:
  • MODE A: Trend Following (Hurst ≥ threshold) → Macro Alignment + Kalman Bullish + 2/6 Confirmation (termasuk Order Flow Imbalance)
  • MODE B: Mean Reversion (Hurst < threshold) → Z-Score extreme + RSI extreme + Bounce + Macro Alignment + Volume Profile Area (VAL/VAH) + !isSharpDrop (Hard Blocker)
• 6 Konfirmasi (Need 2 of 6): VWAP Dev, RSI 14, Volume Spike, Candle Momentum, Multi-scale Hurst, Order Flow Imbalance (VSA)
• Gatekeeper & Support Filters: ATR > batas fee, Macro Alignment (EMA 20 & VWAP Macro), Momentum Threshold (tolak pisau jatuh/pump > 1.2%), Volume Profile Area (VAL untuk LONG, VAH untuk SHORT)
• Order Flow Absorption Guard: Saklar pengaman akhir yang membatalkan entry jika terdeteksi absorpsi berlawanan arah (bearish absorption saat LONG / bullish absorption saat SHORT) dan mendongkrak tingkat keyakinan (HIGH confidence / +15% confidence score) jika absorption searah.
• VWAP Confirmation — Daily VWAP (reset 00:00 UTC) sebagai value/premium area detector
• Kalman Trend Filter — Anti-noise: Adaptive Gain Kalman Filter yang menyesuaikan noise berdasarkan volatilitas lokal, dikontrol oleh kalman_aggressiveness dari Directive
• Directive-Driven — Menggunakan z_score_threshold, bias, dan kalman_aggressiveness dari Battle Directive
• Strategy-Adaptive Hurst Threshold — SCALPING: >= 0.55, INTRADAY: >= 0.60, SWING: >= 0.65 (inclusive >=)
• NEUTRAL Safety — Jika bias NEUTRAL, menggunakan threshold ketat 2.2 untuk kedua arah
• Instant Decision — Menghasilkan AIDecision lengkap (confidence, leverage, regime, hurst, vwap deviation) tanpa latency AI

File: src/core/quant/quant-utils.ts

Utilitas matematika yang digunakan oleh QuantEngine:

Fungsi	Deskripsi
calculateZScore(prices)	Mengukur deviasi standar harga terakhir dari mean (short window)
hurstExponent(prices)	Multi-Scale R/S Analysis — Menggunakan sub-window scales (8, 16, 32, 64 candles), menghitung R/S per chunk, lalu OLS linear regression pada log-log plot untuk mendapatkan slope H
calculateVWAP(ohlcv)	Volume Weighted Average Price: Σ(TP × Vol) / Σ(Vol)
vwapDeviation(price, vwap)	Deviasi harga terhadap VWAP dalam persentase
applyKalmanFilter(prices, noise)	Adaptive Gain Kalman — Menghitung local volatility (std dev 10 candle terakhir), lalu menyesuaikan measureNoise secara dinamis: volatilitas tinggi → filter lebih konservatif. Fallback ke scalar Kalman untuk sample < 10
calculateVelocity(prices)	Weighted Least Squares (WLS) — Linear regression dengan exponential decay weights (decay=0.1): candle terbaru mendapat bobot terbesar

OHLCV Interface:

interface OHLCV {
  t: number;  // timestamp
  o: number;  // open
  h: number;  // high
  l: number;  // low
  c: number;  // close
  v: number;  // volume
}

---

3. 📝 Prompt Builder (Konstruktor Prompt Dinamis)

File: src/core/ai/prompt-builder.ts

Membangun prompt terstruktur dalam Bahasa Indonesia untuk model Gemma:

• Strategy-Adaptive Prompt — Instruksi berbeda berdasarkan TRADING_STRATEGY:
  • SCALPING → Aggressive Scalping — fokus Volatility Bursts, Volume Spikes, Price Anomalies, profit instan
  • INTRADAY/SWING → Konfirmasi trend solid, ruang nafas untuk SL, target profit lebar
• System Instruction — Persona "Hyper-Gemma Ultra" sebagai AI Scalping Engine agresif
• Regime Context Injection — [NEW] Menyuntikkan regimeContext (Hurst, regime TRENDING/RANGING, Trio Direction) ke prompt:
  • MARKET REGIME ALERT (MANDATORY) — Jika regime = TRENDING, Gemma WAJIB mengikuti Trio Direction atau return WAIT
  • Mencegah AI mengembalikan arah berlawanan (ditegakkan oleh GEMMA_FLIP_BLOCKED di Decision Engine)
• Small Account Optimization — Instruksi leverage tinggi (rata kanan) khusus akun mikro agar memenuhi minimum order $5
• Tight SL/TP Instruction — Wajib memberikan target SL/TP dalam % pergerakan harga yang ketat
• Enhanced Market Context — Menyertakan high_24h dan low_24h untuk analisis range harian
• Account Context — Menyertakan equity, PnL harian, dan loss streak
• Memory Injection — Menyuntikkan pelajaran dari trading sebelumnya
• Response Schema — Memaksa output JSON dengan format ketat (12 field)
• Prinsip Capital Multiplication — Eksekusi peluang dengan probabilitas profit tertinggi

---

3.5. 🛡️ Decision Engine — AI Sniper + GEMMA_FLIP_BLOCKED

File: src/core/ai/decision-engine.ts

Orkestrator keputusan trading AI yang menggabungkan analisis Gemma dengan hard constraint matematika:

• Pre-AI Risk Check — Memeriksa posisi penuh atau safety risk sebelum memanggil AI
• Continuous Learning — Menginjeksikan 5 trade terakhir sebagai pelajaran ke prompt (threshold: minimal 5 trades)
• Regime Context Injection — Menghitung Hurst secara independen untuk menyuntikkan context ke Prompt Builder
• Synchronized mathDir — Menerima mathDir (trioDirection) langsung dari QuantEngine via server.ts, memastikan sinkronisasi sempurna antara sinyal matematika dan guard constraint
• GEMMA_FLIP_BLOCKED (Hard Constraint) — Fitur kritis yang mencegah Gemma membalik arah trading saat regime TRENDING:
  • Menggunakan mathDir dari QuantEngine (bukan recalculate) — single source of truth
  • Jika regime TRENDING dan Gemma mencoba arah berlawanan → Force WAIT
  • Contoh: Jika mathDir = LONG dan Gemma return SHORT → Diblokir dengan log ⚠️ GEMMA_FLIP_BLOCKED
  • Menggunakan inclusive Hurst check (>= threshold) — konsisten dengan QuantEngine
• Symbol Injection — Menyuntikkan symbol ke keputusan AI (type-safe)
• Final Risk Validation — Keputusan AI divalidasi ulang oleh Risk Manager sebelum eksekusi
• Fallback Decision — Jika engine gagal, mengembalikan SKIP dengan risk_level: HIGH

---

4. 📚 Learning Engine (Mesin Pembelajaran)

File: src/core/ai/learning-engine.ts

Sistem self-learning yang menyimpan dan mengkonsolidasi pelajaran:

• Memory Consolidation — Konsolidasi memori dari trade sebelumnya
• Record Lesson — Mencatat pelajaran baru ke koleksi Memory di MongoDB
• Upsert Pattern — Update jika pelajaran serupa sudah ada, buat baru jika belum
• Occurrence Tracking — Melacak frekuensi kesalahan yang sama terulang
• Kategori Memory — ENTRY, EXIT, RISK, PSYCHOLOGY

---

5. 📊 Indicator Engine (Mesin Indikator Teknikal)

File: src/core/market/indicator-engine.ts

Menghitung indikator teknikal dari data candlestick:

Indikator	Metode
EMA 20	Exponential Moving Average 20 periode
EMA 50	Exponential Moving Average 50 periode
RSI 14	Relative Strength Index 14 periode
ATR 14	Average True Range 14 periode (null-safe)

---

6. 🌍 Market Regime Detector (Deteksi Kondisi Market)

File: src/core/market/market-regime.ts

Mengklasifikasikan kondisi market saat ini berdasarkan indikator:

Regime	Kondisi
VOLATILE	RSI > 70 atau RSI < 30
TRENDING	ADX > 25
RANGING	ADX < 20
UNCLEAR	Kondisi lainnya

---

7. 🛡️ Risk Manager (Manajemen Risiko)

File: src/core/risk/risk-manager.ts

Layer perlindungan modal yang dapat meng-override keputusan AI:

• Dynamic Max Positions — Membatasi jumlah posisi aktif berdasarkan MAX_POSITIONS di environment (default: 1, configurable)
• Duplicate Position Block — Memblokir pembukaan posisi baru pada koin yang sudah dipegang (type-safe: decision.symbol)
• Strategy-Dynamic Liquidation Safety — Threshold likuidasi berbeda per strategi:
  • SCALPING → 15% jarak minimum ke harga likuidasi (lebih toleran karena leverage tinggi)
  • INTRADAY/SWING → 30% jarak minimum (lebih konservatif)
• Staged Allocation — Ukuran posisi ditentukan berdasarkan tingkat kepercayaan AI:
  • Formula: max_risk = (100% / MAX_CONSECUTIVE_LOSS) / 2
  • HIGH confidence → 100% dari max_risk
  • MEDIUM confidence → 60% dari max_risk
  • LOW confidence → 20% dari max_risk
  • Hard cap oleh MAX_TRADE_ALLOCATION (default: 25%)
• Leverage Cap — Membatasi leverage hingga maksimal 500x
• Silent Pre-Scan — Log validasi disuprekan untuk PRE_SCAN_CHECK (mengurangi noise log)
• Position Sizing — Kalkulasi ukuran posisi berdasarkan tingkat risiko:
  • NORMAL → 100% dari safe margin
  • REDUCED → 50% dari safe margin
  • SMALL → 25% dari safe margin
• Trading Blocked — Memblokir trade baru jika posisi penuh, ada safety risk, atau duplicate coin

---

8. ⏳ Cooldown Manager (Sistem Pendinginan)

File: src/core/risk/cooldown-manager.ts

Mengelola periode cooldown setelah kerugian beruntun:

• Start Cooldown — Mengaktifkan cooldown selama N menit (default: 30 menit)
• Check Active — Mengecek apakah cooldown masih aktif
• Auto Reset — Otomatis reset ketika waktu cooldown berakhir
• Remaining Time — Menampilkan sisa waktu cooldown dalam menit

---

9. 🔌 Bitget Client (Koneksi Exchange)

File: src/exchange/bitget.client.ts

Client lengkap untuk Bitget Futures API V2 dengan autentikasi HMAC-SHA256:

Fitur	Deskripsi
HMAC-SHA256 Signing	Tanda tangan kriptografis menggunakan crypto.createHmac
Get Candles	Mengambil data candlestick (klines) untuk analisis
Get Price History	Shortcut: mengambil array harga close untuk QuantEngine
Get All Tickers	Mengambil semua 24h ticker sekaligus (normalized format)
Get Account Balance	Mengambil saldo akun (USDT-FUTURES)
Get Positions	Mengambil posisi-posisi aktif
Get Symbol Info	Mengambil quantityPrecision, pricePrecision, maxLeverage, dan minTradeUSDT per simbol
Get Exchange Info	Mengambil seluruh daftar kontrak (untuk deteksi RWA/saham)
Get Fill History	Mengambil riwayat fill per simbol untuk deteksi trade close otomatis
Place Order	Membuat market/limit order dengan Atomic SL/TP (presetStopLossPrice + presetTakeProfitPrice)
Place TPSL Order	Membuat TP/SL order terpisah via place-tpsl-order (planType: profit_plan/loss_plan, holdSide)
Set Leverage	Mengatur leverage per simbol (PAPER mode: simulated)
Set Prefix	Konfigurasi clientOid prefix untuk diferensiasi bot vs script

Order Modes:

• tradeSide: 'open' + posSide: 'net' — Unilateral/net position mode
• Atomic SL/TP — SL/TP dikirim dalam request yang sama via presetStopSurplusPrice + presetStopLossPrice
• Standalone TPSL — placeTPSLOrder() untuk SL/TP terpisah dengan holdSide (long/short)

Autentikasi:

• Menggunakan HMAC-SHA256 signing (timestamp + method + path + body)
• Headers: ACCESS-KEY, ACCESS-SIGN, ACCESS-TIMESTAMP, ACCESS-PASSPHRASE
• Product Type: USDT-FUTURES

PAPER Mode:

• placeOrder() → Return mock orderId tanpa mengirim ke exchange
• placeTPSLOrder() → Return mock orderId untuk TP/SL
• setLeverage() → Simulated tanpa API call (KYC Bypass)

---

10. 📈 Market Data Provider (Penyedia Data Market)

File: src/exchange/market-data.provider.ts

Aggregator data market yang menggabungkan raw data dari Bitget dengan indikator teknikal:

• Strategy-Adaptive Interval — Menggunakan timeframe 5m untuk SCALPING dan 1h untuk INTRADAY/SWING
• Real-time Market Data — Mengambil klines dan ticker dari Bitget V2
• Indicator Calculation — Menghitung EMA20, EMA50, RSI, ATR dari data candlestick
• Trend Detection — Menentukan trend (BULLISH/BEARISH/NEUTRAL) dari EMA crossover
• 24h High/Low Data — Mengambil high_24h dan low_24h dari raw Bitget ticker
• Aggregated Account Metrics — Menghitung equity, available balance, margin ratio, maintenance margin, margin balance, dan total wallet balance
• Active Position Filtering — Filter posisi dengan total ≠ 0 dan normalisasi field names
• Position Field Mapping — Memetakan holdSide (arah posisi) dan marginUsed (marginSize/margin) dari Bitget ke format internal
• Virtual Balance Fallback — Dalam PAPER mode dengan $0 balance, menyediakan virtual $1.00 untuk simulasi
• LIVE Mode Position Isolation — Dalam LIVE mode, hanya posisi yang memiliki matching trade di session aktif yang dihitung (mencegah interferensi posisi manual)
• PAPER Mode Position Isolation — Dalam PAPER mode, posisi riil di exchange diabaikan:
  • Mock positions dibangun dari sessionTrades di sesi aktif saat ini
  • Mock positions menyertakan holdSide dan marginUsed yang disimulasikan
  • Setiap mock position menggunakan 10% estimated margin usage
  • Hanya trade dari currentSessionId yang dihitung (isolasi antar sesi)
  • Mencegah double-counting saat restart simulasi

---

11. 💹 Order Executor (Eksekutor Order)

File: src/exchange/order.executor.ts

Mengeksekusi order ke Bitget dengan proteksi otomatis dan optimisasi leverage:

• Dynamic Notional Sizing — Ukuran order ditentukan oleh formula:
  • TARGET_NOTIONAL = max(SAFETY_FLOOR, available_balance × staged_allocation)
  • staged_allocation dihitung oleh riskManager.getStagedAllocation() berdasarkan confidence AI
  • SAFETY_FLOOR = max(symbolInfo.minTradeUSDT, MIN_TPSL_NOTIONAL, 5.5) — memastikan notional cukup besar untuk SL/TP placement
  • MIN_TPSL_NOTIONAL dikonfigurasi via environment (default: 10 USDT)
• Dynamic Quantity — Menghitung kuantitas: ceil(TARGET_NOTIONAL / price) dengan presisi simbol
• Exchange-Aware Leverage — Mengambil maxLeverage langsung dari kontrak Bitget per simbol
• Auto-Leverage Optimization — Menaikkan leverage otomatis jika saran AI terlalu rendah:
  • ceil(targetNotional / (available * 0.98)) — 2% buffer
  • Capped by maxExchangeLeverage per simbol
• Hard Leverage Cap — Membatasi leverage absolut maksimal 25x (terlepas dari saran AI/directive)
• 2% Safety Buffer — Final affordability check: marginUsed = targetNotional / finalLeverage vs available * 0.98
• Detailed Sizing Log — Mencatat targetNotional, marginUsed, finalLeverage, dan qty per order
• Precision Handling — Menggunakan Math.ceil untuk memastikan kuantitas selalu ≥ minimum
• Execution Price Retries — Melakukan hingga 3 kali percobaan untuk fetch execution price dari fill history
• ATR-Based Dynamic SL/TP — Menyesuaikan Take Profit dan Stop Loss menggunakan ATR jika tersedia:
  • SL = 1.5x ATR (Floor minimum: 1.0%)
  • TP = 25% Moon Bag (Membiarkan bursa menutup jauh di atas, agar Trailing Stop di server yang mengatur exit)
  • Fallback ke persentase statis dari .env (SCALP/INTRADAY/SWING _MAX_LOSS_PERCENT dan _PROFIT_TARGET_PERCENT) jika ATR tidak tersedia
  • Menambahkan Slippage Buffer 0.01% untuk eksekusi yang lebih aman
• Liquidation Guard — Menolak trade jika SL terlalu dekat dengan harga likuidasi (mencegah margin call)
• Limit Order First — Mencoba limit order (fee 0.02%) sebelum fallback ke market order (fee 0.1%)
• Atomic SL/TP (Preset) — SL/TP dikirim dalam request yang sama dengan market order (bukan Plan Order terpisah):
  • presetStopLossPrice + presetTakeProfitPrice dimasukkan ke body place-order
  • Benefit: SL/TP dijamin terpasang, tidak ada race condition atau partial fill

---

12. 🔄 Trade Service (Layanan Trading)

File: src/services/trade.service.ts

Orkestrator yang menghubungkan keputusan AI dengan eksekusi order:

• Decision Handling — Memfilter keputusan SKIP/WAIT dan hanya mengeksekusi LONG/SHORT
• Order Execution — Meneruskan order ke Order Executor
• Session Linking — Menghubungkan setiap trade ke session aktif via SessionService
• Accurate Entry Price — Menyimpan harga eksekusi aktual dari Order Executor
• Database Logging — Menyimpan setiap trade ke MongoDB dengan detail lengkap
• Error Handling — Menangkap dan mencatat error eksekusi

---

13. 🗄️ Database Layer (Lapisan Database)

Models

Model	File	Deskripsi
Trade	trade.model.ts	Trade lifecycle lengkap (entry, exit, PnL, result, exit_reason, fees)
Memory	memory.model.ts	Pelajaran dari kesalahan (kategori, severity, occurrence)
Session	session.model.ts	Sesi trading (mode, start/end time, total trades)
BattleDirective	directive.model.ts	Perintah strategi makro dari Gemma (bias, threshold, leverage)

Trade Lifecycle Schema

{
  // Entry
  pair: string,
  action: TradeAction,       // LONG | SHORT
  entry_price: number,
  leverage: number,
  confidence_score: number,

  // Exit (auto-populated via fill history detection)
  exit_price?: number,
  realized_pnl?: number,
  result?: TradeResult,      // WIN | LOSS | BREAKEVEN
  exit_reason?: TradeExitReason,  // TP_HIT | SL_HIT | MANUAL_OR_UNKNOWN
  closed_at?: Date,
  fees?: number,

  // AI Context
  ai_reasoning: string,
  self_reflection?: string,
  market_regime: MarketRegime
}

BattleDirective Schema

{
  bias: 'LONG' | 'SHORT' | 'NEUTRAL',
  z_score_threshold: number,        // Sensitivitas QuantEngine
  kalman_aggressiveness: number,     // Agresivitas filter noise
  max_leverage: number,              // Leverage maks yang direkomendasikan
  allowed_symbols: string[],         // Simbol yang diperbolehkan
  last_updated: Date                 // Timestamp directive terakhir
}

Repositories

• trade.repository.ts — CRUD untuk trade records + findOpenTrades() + closeTradeRecord() + aggregatePairPerformance() (win rate, PnL ratio, composite score)
• memory.repository.ts — Upsert pelajaran trading
• session.repository.ts — Lifecycle management sesi
• directive.repository.ts — getLatest() dan update() untuk Battle Directive (upsert single document)

---

14. 🔧 Monitoring & API

Prometheus Metrics

File: src/monitoring/metrics.ts

Metric	Tipe	Deskripsi
trader_trades_total	Counter	Total trades yang dieksekusi
trader_decisions_total	Counter	Total keputusan AI (per label)
trader_pnl_total	Gauge	Total Profit and Loss
Default Metrics	Auto	CPU, memory, event loop, dll.

Health Check

File: src/monitoring/health-check.ts

• System uptime
• Memory usage (heap, RSS, external)
• Database connection status
• Timestamp

Alert Manager

File: src/monitoring/alert-manager.ts

• Alert dengan 3 level severity: LOW, MEDIUM, HIGH
• Balance threshold alert (jika saldo < $1)
• Console error untuk alert CRITICAL
• Placeholder untuk integrasi Telegram/Discord/Slack

---

15. ♾️ Pure Quant Engine & Background Jobs

Arsitektur Pure Quant: Menggabungkan 3 jalur eksekusi secara paralel.

Komponen	Tipe	Jadwal	Deskripsi
Strategy Governor	Cron 0 * * * *	Setiap 1 jam	Menulis Battle Directive (hardcoded defaults saat MOCK_AI=true, Gemma saat MOCK_AI=false)
Pure Quant Loop	while(true)	Terus-menerus	Trinity v2 scan → Gatekeeper → 2/5 Confirm → Execute (Atomic SL/TP)
Memory Consolidation	Cron 0 0 * * *	Setiap tengah malam	Konsolidasi pelajaran harian

Pure Quant Loop:

runHybridTradingLoop(mode) {
  1. Strategy Governor: Refresh Battle Directive (initial)

  while (true) {
     2. Auto-Close Detection (setiap cycle):
        - Cek open trades di DB vs live positions di exchange
        - Jika posisi hilang → fetch fill history → record PnL, exit_price, result, fees
        - Log: [TRADE CLOSED] BTCUSDT LONG → TP_HIT | PnL: +0.52 USDT
     3. Capital Shield & Tactical Exits:
         - BACKUP SHIELD: Exit force loss jika PnL exceed 1.3x threshold (Bitget SL gagal)
         - THE 40% BLOCK: Trailing Stop DILARANG aktif jika profit < 40% dari Max Loss
         - DYNAMIC TRAILING: 25%/35%/45% dari puncak (berdasarkan level profit)
         - TIME EXIT: Max Hold Minutes → force close
         - PROFIT TIME EXIT: Setelah X menit, jika profit > fee buffer → secure
      4. Cek Account & Risk Status
         - Jika Safety Block ATAU Max Positions → Portfolio Snapshot → Wait 1.5s → Retry
     5. Determine Pairs to Scan:
        - SINGLE MODE: Hanya `FOCUS_PAIR`
        - MULTI MODE: Fetch tickers → Filter RWA blacklist → Apply SCAN_MODE
     6. Fetch All Tickers → Filter berdasarkan SCAN_MODE:
       - VIP: 17 major pairs (BTC, ETH, BNB, XRP, SUI, TON, dll)
       - HOT5: Top 5 by volume
       - HOT20: Rank 6-20 by volume
       - HOT40: Rank 21-40 by volume
       - HOT60: Rank 41-60 by volume
       a. 📊 TRINITY SENSOR (Instant, 100 candles):
          - Ambil OHLCV history → Hitung Z-Score (20 candle) + Hurst (100 candle) + VWAP
          - Determine regime: Hurst >= threshold → TRENDING, else → RANGING
          - Pulse log: [PULSE] BTCUSDT | Z: -1.85 (-1.50) | H: 0.62 [TRND]
          - MODE A (Trending, H ≥ threshold): Kalman + VWAP momentum → Hit!
          - MODE B (Ranging, H < threshold): Z-Score extreme + Bounce + VWAP value area → Hit!
          - Return trioDirection (Kalman direction) untuk sinkronisasi guard
       b. 🛡️ VOLUME GATE & MOMENTUM GUARD:
           - Skip jika volume 24h < $1M (Scalping) / $5M (Intraday)
           - Block LONG jika coin sudah pump > 10% (buy-at-top risk)
           - Block SHORT jika coin sudah crash > 10% (sell-at-bottom risk)
           - Block semua jika change > ±20% (parabolic/crash)
       c. 🤖 AI SNIPER (Gemma confirms, dengan mathDir & isAlpha):
           - Kirim ke Decision Engine + mathDir → Gemma validasi
           - GEMMA_FLIP_BLOCKED guard menggunakan mathDir dari step (a)
           - Jika LONG/SHORT → TACTICAL STRIKE → Execute (Atomic SL/TP)
           - Jika SKIP/WAIT → TACTICAL VETO → Skip
        d. ⏱️ Micro-delay 250ms antar pair
     7. Wait 10s → Ulang dari step 2
    * On crash → Wait 5s → Retry
  }
}

Scan Mode System:

Mode	Pairs	Deskripsi
VIP	17 pairs	Major crypto: BTC, ETH, ASTER, BNB, XRP, ZEC, XLM, SUI, TON, BCH, LINK, ADA, AVAX, LTC, TRX, ETC, HYPE
TOP20	Top 20	Top 20 berdasarkan 24h volume (termasuk RWA-filtered)
HOT5	Top 5	Top 5 berdasarkan 24h volume tertinggi
HOT20	Rank 6-20	Mid-cap teratas (peringkat volume 6–20)
HOT40	Rank 21-40	Mid-cap menengah (peringkat volume 21–40)
HOT60	Rank 41-60	Small-cap teratas (peringkat volume 41–60)
HOT80	Rank 61-80	Small-cap menengah (peringkat volume 61–80)
HOT100	Rank 81-100	Micro-cap (peringkat volume 81–100, fallback default)
ALL	Semua	Seluruh pasangan di Bitget USDT-FUTURES

Engine Features:

• Real-time Trinity Pulse — Visual tracking Z-Score + Hurst + Regime setiap pair di terminal (\r overwrite)
• Pure Quant Execution — MOCK_AI=true: QuantEngine langsung mengeksekusi sinyal tanpa menunggu AI/LLM
• Capital Shield (Backup) — Percent-Loss Exit backup jika Bitget SL gagal (triggers at 1.3x maxLossDollarLimit)
• The 40% Block Rule — Trailing Stop DILARANG aktif sebelum profit mencapai 40% dari batas Cut Loss (mencegah profit recehan merusak R:R)
• Dynamic Trailing Stop — 3 level: 25% (default), 35% (target tercapai), 45% (Moon Bag 2x target)
• Volume Gate — Filter koin illiquid: $1M (Scalping), $5M (Intraday), $500K (Swing)
• Momentum Guard — Block LONG jika pump > 10%, Block SHORT jika crash > 10%, Block semua jika > ±20%
• Alpha Detection — Mendeteksi koin dengan independen momentum (Hurst > 0.70)
• Smart Safety Block — Block untuk Blocked: Safety DAN Blocked: Max positions, wait 1.5s
• Auto-Close Detection — Setiap cycle, cek open trades vs live positions → auto-record PnL, result, exit_reason via fill history
• RWA Blacklist — Otomatis filter saham/komoditas (isRwa) dari scan, hanya crypto murni yang di-scan
• Execution Failure Cooldown — Jika eksekusi gagal (misal CANNOT AFFORD), koin diblokir 15 menit (anti-spam)
• Pending Order Cleanup — Cancel stale orders > 15 menit secara otomatis
• Single Pair Mode — TRADING_MODE_PAIR=SINGLE + FOCUS_PAIR untuk fokus satu koin saja
• Tactical Strike/Veto — Logging eksplisit untuk setiap keputusan (konfirmasi atau tolak)
• API-Friendly — Micro-delay 250ms antar pair, 1.5s antar cycle saat posisi terbuka

---

16. ✅ Validasi & Safety

File: src/utils/json-validator.ts

Validasi JSON ketat menggunakan Zod schema untuk dua jenis output AI:

AIDecision Schema

• decision → Preprocess ke uppercase, fallback ke SKIP
• confidence_score → 0-100
• market_regime → Preprocess ke uppercase, fallback ke UNCLEAR
• risk_level → Preprocess ke uppercase, fallback ke MEDIUM
• leverage_suggestion → 1-500
• position_size → Preprocess ke uppercase, fallback ke NORMAL
• 6 field string tambahan (entry_reason, risk_factors, stop_loss_logic, dll)

BattleDirective Schema (NEW)

• bias → LONG | SHORT | NEUTRAL
• z_score_threshold → 1-5
• kalman_aggressiveness → 0.001-1.0
• max_leverage → 1-500
• allowed_symbols → Array string
• reasoning → String

JSON Extraction

• extractJsonFromResponse() — Mengekstrak JSON dari response AI yang mungkin mengandung teks tambahan
• Mencari { pertama dan } terakhir dari response string

---

17. 🤖 Ollama Client (Koneksi AI)

File: src/core/ai/ollama-client.ts

Client untuk Ollama API yang mendukung dua mode generasi:

• generateDecision(prompt) — Khusus untuk trading decisions dengan validasi AIDecision schema
• generateValidatedJson<T>(prompt, validator) — [NEW] Generic method untuk validated JSON generation (digunakan oleh Strategy Governor)
• generateRawJson(prompt) — Internal helper untuk raw JSON tanpa validasi spesifik
• Mock AI Mode — Jika MOCK_AI=true, return mock decision tanpa memanggil Ollama
• Timeout 5 Menit — Timeout diperbesar untuk model besar seperti Gemma 4
• Clean Error Logging — Hanya log error message, bukan seluruh axios error object

---

18. 📋 Type System (Sistem Tipe)

Enum Types (src/types/enum.types.ts)

Enum	Values
TradingStrategy	SCALPING, INTRADAY, SWING
TradingMode	PAPER, LIVE
TradeAction	LONG, SHORT, WAIT, SKIP
MarketRegime	TRENDING, RANGING, VOLATILE, UNCLEAR
RiskLevel	LOW, MEDIUM, HIGH
SessionMode	NORMAL, SAFE_MODE, COOLDOWN
MemoryCategory	ENTRY, EXIT, RISK, PSYCHOLOGY
PositionSize	SMALL, NORMAL, REDUCED
TradeResult	WIN, LOSS, BREAKEVEN

Market Types (src/types/market.types.ts)

• MarketData — Data market lengkap (harga, indikator, trend, high_24h, low_24h, price_change_24h)
• AccountStatus — Status akun lengkap:
  • Core: current_equity, open_positions, daily_pnl, loss_streak
  • Extended: available_balance, margin_ratio, maintenance_margin, margin_balance, total_wallet_balance

---

🔄 Trading Pipeline (Alur Trading)

 0. 🚀 Bootstrap: Connect DB → Start API → Init Session
         │
 1. 📜 Strategy Governor: Initial Battle Directive
         │
 ┌───────┤ PARALLEL EXECUTION
 │       │
 │  PATH 1: 🧠 COLD PATH (Every 1 hour)
 │       │     └─ Strategy Governor → Gemma Macro Analysis → Save Directive to DB
 │       │
 │  PATH 2: ⚡ HOT PATH (Continuous Loop)
 │       │     ┌─ Account & Risk Check
 │       │     │     └─ Safety Block? → Wait 10s → Retry
 │       │     │
 │       │     ├─ Fetch All Tickers → Filter by SCAN_MODE (VIP/HOT50/ALL)
 │       │     │
 │       │     ├─ Loop hot pairs:
 │       │     │     ├─ 📊 TRINITY SENSOR: OHLCV → Z-Score + Hurst + VWAP
 │       │     │     ├─ [PULSE] Regime detection: TRND (Trend) or RNG (Range)
 │       │     │     │
 │       │     │     ├─ If TRINITY HIT (Mode A: Trend H≥T / Mode B: Reversion H<T):
 │       │     │     │     ├─ 🤖 AI SNIPER: Gemma confirms/vetoes
 │       │     │     │     ├─ ⚡ TACTICAL STRIKE → Auto-Leverage → Execute → SL/TP
 │       │     │     │     └─ ❌ TACTICAL VETO → Skip → Next pair
 │       │     │     │
 │       │     │     └─ ⏱️ Micro-delay 50ms
 │       │     │
 │       │     └─ Wait 1s → Next cycle
 │       │
 │  PATH 3: 📅 Memory Consolidation (Daily at 00:00)
 │       │
 └───────┘

---

🚀 Cara Menjalankan

Prerequisites

• Node.js LTS
• MongoDB (Atlas atau lokal)
• Ollama terinstal dan running (ollama serve) — hanya diperlukan jika MOCK_AI=false
• Model Gemma 4 terinstal di Ollama (ollama pull gemma4:latest) — hanya diperlukan jika MOCK_AI=false
• Bitget Account dengan API Key, Secret Key, dan Passphrase

Setup

# 1. Install dependencies
npm install

# 2. Setup environment variables
cp .env.example .env
# Edit .env dengan konfigurasi yang sesuai

# 3. Build
npm run build

# 4. Jalankan
npm start

# Atau untuk development:
npm run dev

Environment Variables

Variable	Deskripsi	Default
NODE_ENV	Environment	development
LOG_LEVEL	Level logging	info
PORT	Port monitoring API (Fastify)	3000
MONGODB_URI	URI koneksi MongoDB	— (wajib)
OLLAMA_BASE_URL	URL server Ollama	http://localhost:11434
OLLAMA_MODEL	Model Ollama yang digunakan	gemma:7b-instruct (kode), gemma4:latest (.env.example)
MOCK_AI	Aktifkan mock AI (tanpa Ollama)	false
BITGET_API_KEY	API Key Bitget	— (wajib)
BITGET_SECRET_KEY	Secret Key Bitget	— (wajib)
BITGET_PASSPHRASE	Passphrase Bitget	— (wajib)
BITGET_BASE_URL	Base URL Bitget API	https://api.bitget.com
TRADING_MODE	Mode trading: PAPER (simulasi) atau LIVE	PAPER
MAX_POSITIONS	Jumlah maksimal posisi aktif bersamaan	1
MAX_TRADE_ALLOCATION	Hard cap persentase balance per trade (0.0-1.0)	0.25 (25%)
MAX_CONSECUTIVE_LOSS	Jumlah loss beruntun sebelum allocation minimum	10
MIN_TPSL_NOTIONAL	Minimum notional agar SL/TP bisa terpasang (USDT)	10
TRADING_STRATEGY	Strategi trading: SCALPING / INTRADAY / SWING	INTRADAY
SCAN_MODE	Mode pemindaian market: VIP / TOP20 / HOT5 / HOT20 / HOT40 / HOT60 / HOT80 / HOT100 / ALL	VIP
MAX_DRAWDOWN_PERCENT	Batas maksimum drawdown harian (%) sebelum Circuit Breaker aktif	20
SCALP_MAX_HOLD_MINUTES	Durasi hold maksimal (menit) untuk Scalping	10
SCALP_PROFIT_TARGET_PERCENT	Target profit (%) untuk Scalping	0.5
SCALP_MAX_LOSS_PERCENT	Batas loss mutlak (%) untuk Scalping	0.3
INTRADAY_PROFIT_TARGET_PERCENT	Target profit (%) untuk Intraday	1.5
INTRADAY_MAX_LOSS_PERCENT	Batas loss mutlak (%) untuk Intraday	0.5

---

🔮 Roadmap & Scalability

✅ Sudah Diimplementasi

• Pure Quant Tactical Architecture (Quant Trinity v2 Engine)
• Strategy Governor / Battle Directive System (Menggunakan default dinamis saat MOCK_AI=true)
• Quant Trinity Engine (Z-Score + Hurst Exponent + VWAP + Kalman Filter)
• Regime-Aware Execution (Trend Following vs Mean Reversion berdasarkan Hurst)
• Dual Window Analysis (Short 20 candles + Long 50-100 candles)
• OHLCV Data Pipeline (Full candlestick data dari Bitget)
• Bitget Futures API V2 (HMAC-SHA256, market orders, atomic SL/TP)
• PAPER Mode Position Isolation (mock positions dari session trades, bukan exchange riil)
• LIVE Mode Position Isolation (filter posisi by session trades)
• Scan Mode System (VIP / TOP20 / HOT5 / HOT20 / HOT40 / HOT60 / HOT80 / HOT100 / ALL — granular volume tiers + RWA filter)
• Real-time Trinity Pulse (Z-Score + Hurst + Regime terminal visualization)
• AI Decision Engine dengan Gemma 4
• Trading Strategy System (SCALPING / INTRADAY / SWING)
• Auto-Leverage Optimization (auto-increase + exchange-aware cap)
• Staged Allocation (confidence-based sizing: HIGH/MEDIUM/LOW × MAX_CONSECUTIVE_LOSS formula)
• Dynamic Notional Sizing (staged_allocation + minTradeUSDT + MIN_TPSL_NOTIONAL safety floor)
• Atomic SL/TP (preset params dalam request market order, bukan plan order terpisah)
• TPSL Order Support (place-tpsl-order endpoint dengan holdSide + planType)
• trioDirection Passthrough (QuantEngine → server.ts → DecisionEngine — single source of truth)
• VWAP Value/Premium Area Detection (daily reset 00:00 UTC)
• Trade Lifecycle Tracking (auto-detect closed positions via Bitget fill history → record exit_price, realized_pnl, result, fees)
• RWA Blacklist (otomatis filter saham/komoditas dari scan menggunakan getExchangeInfo().isRwa)
• Pair Performance Analytics (aggregatePairPerformance: win rate, avg PnL, PnL ratio, composite score per pair)
• Execution Failure Cooldown (Blokir koin selama 15 menit jika gagal eksekusi API untuk cegah loop)
• Capital Shield (Persentase-Loss Exit backup fallback dengan lantai dasar SL 1.0%)
• The 40% Block Rule (Hard Blocker Trailing Stop: Trailing tidak akan aktif sebelum profit mencapai 40% dari batas Cut Loss)
• ATR-Based Dynamic SL/TP (1.5x ATR SL, 2.5x ATR TP dengan slippage buffer 0.01% dan Moon Bag)
• Volume Profile Area Gate (Mean Reversion masuk hanya di/di bawah VAL untuk LONG atau di/di atas VAH untuk SHORT)
• Order Flow Absorption Guard (Anti-fakeout dan pendorong keyakinan entri berdasarkan penyerapan institusional)
• Volume Gate & Momentum Guard (Filter volume < $100k, block melawan trend ekstrem ±20%)
• Execution Price Retry (3x attempt fetch actual fill history price)
• holdSide/marginUsed Mapping (field posisi dari Bitget V2 dipetakan akurat)
• Duplicate Position Block (cegah double exposure pada koin yang sama)
• Dynamic Liquidation Threshold (Mencegah SL melewatai harga Margin Call)
• GEMMA_FLIP_BLOCKED (hard constraint: blokir AI flip arah saat regime TRENDING)
• Adaptive Kalman Filter (volatility-adjusted measureNoise dengan local std dev)
• WLS Price Velocity (Weighted Least Squares dengan exponential decay weights)
• Regime Context Prompt Injection (Hurst + regime + trioDirection disuntikkan ke prompt Gemma)
• Validated JSON for Both AI Schemas (AIDecision + BattleDirective via Zod)
• Indikator teknikal (EMA, RSI, ATR) dengan null-safety
• Risk Management & Leverage Cap (500x)
• Dynamic Max Positions (configurable via MAX_POSITIONS)
• Pre-AI Risk Validation (skip AI jika posisi penuh)
• Session Management (lifecycle tracking)
• Reusable Portfolio Snapshot (equity, margin, ROE, liq price)
• Safety Block Pattern (mencegah trade saat API gagal)
• Trade History dengan exit_reason & mistake_analysis
• Self-Learning Memory System
• Monitoring API (Prometheus + Fastify)
• Backtesting & Simulation
• Comprehensive Type Safety (Zod + TypeScript)
• Enhanced Market Data (high_24h, low_24h untuk analisis range)
• Clean Error Logging (axios error message only, bukan full object)
• Hurst-Adaptive Strategy Selection (SCALPING H>=0.55, INTRADAY H>=0.60, SWING H>=0.65 — inclusive)

🔜 Rencana Pengembangan

• Volatility Spike Detector — Filter event-driven moves (change24h > 10% + volume spike > 3x average) menggunakan data MarketData yang sudah ada. Mencegah entry saat pump/dump ekstrem yang tidak diprediksi oleh Trio.
• Multi-agent trading
• Vector memory embeddings
• RAG-based market memory
• Sentiment analysis
• Portfolio balancing AI
• Web dashboard
• Telegram/Discord alert integration

---

📊 Protokol Evaluasi & Uji Statistik (Hypothesis Testing)

Sistem ini dievaluasi secara matematis menggunakan uji statistik formal berdasarkan Central Limit Theorem. Pengujian wajib dilakukan setelah bot mengumpulkan minimal 30 sampel transaksi (Large Samples, $n \ge 30$) agar kurva Z/T relevan.

Perintah Uji Manual:

npm run stats

Sistem Pemicu Otomatis (Auto-Trigger):

Bot akan secara otomatis mengevaluasi hasil trade di database dan mencetak laporan pengujian statistik langsung ke konsol log setiap kali trade baru mencapai kelipatan 30 (30, 60, 90, dst) untuk melacak edge sistem tanpa intervensi manual.

Parameter Uji Standar:

1. Uji Proporsi (Win Rate Test):
   • $H_0$: $p = 0.55$ (Sistem hanya break-even dengan win rate 55%)
   • $H_1$: $p &gt; 0.55$ (Sistem memiliki edge statistik nyata)
   • One Sample Proportion Test (Right-Tailed) dengan $\alpha = 0.05$.
2. Uji Rata-Rata Profit (Expectancy Test):
   • $H_0$: $\mu = 0$ (Rata-rata profitabilitas per trade nol)
   • $H_1$: $\mu &gt; 0$ (Sistem terbukti profitabel)
   • One Sample Mean Test (Right-Tailed).
3. Uji A/B Algoritma (Version Testing):
   • $H_0$: $\mu_1 - \mu_2 = 0$ (Update baru tidak memberikan PnL lebih baik)
   • $H_1$: $\mu_1 - \mu_2 &gt; 0$ (Update terbukti memberikan performa superior)
   • Two Sample Mean Test untuk membandingkan Versi A (Sistem Lama) vs Versi B (Sistem Baru).

🚫 Pantangan Keras (Hard Blockers):

• Sampel Kecil ($n &lt; 30$): Dilarang keras mengambil kesimpulan prematur (menganggap bot gagal/sukses) berdasarkan ukuran sampel kecil.
• Intervensi Manual: Dilarang keras menutup trade secara manual (Close Manual) sebelum menyentuh TP/SL otomatis. Intervensi manusia merusak data uji statistik dan membongkar sistem Trailing Stop.

---

📄 Lisensi

MIT License © 2026 Silki

---

⚠️ Disclaimer: Sistem ini dibuat untuk tujuan eksperimen dan edukasi. Trading cryptocurrency memiliki risiko tinggi. Gunakan dengan bijak dan pahami risiko yang ada.