Build a Risk Gated Bybit Perpetuals Trading Bot

Scheduler and controls
        |
        v
Codex with GPT-6 Astra
        |
        +---- READ ----> Bybit official MCP ----> market and account data
        |
        +---- WRITE ---> risk-gate MCP ----------> Bybit V5 REST
                              |
                              +---- six deterministic checks
                              +---- logs/audit.jsonl
                              +---- Telegram alert

node --version
codex --version
which npx

trading-bot/
  STRATEGY.md
  HALT_TRADING
  prompts/
    cycle.md
  memory/
    trades.jsonl
    learnings.md
    decision.json
  risk-gate/
    src/index.ts
    src/checks.ts
    src/bybit.ts
    dist/
  scripts/
    position-check.js
    funding-check.js
    telegram-alert.js
    telegram-commands.js
  logs/
    audit.jsonl
    cycle.log

model = "gpt-6-astra"
model_reasoning_effort = "high"

[mcp_servers.bybit]
command = "npx"
args = ["-y", "bybit-official-trading-server@latest"]
env = { BYBIT_TESTNET = "true" }

[mcp_servers.risk-gate]
command = "node"
args = ["/absolute/path/to/trading-bot/risk-gate/dist/index.js"]
env = { BYBIT_TESTNET = "true", BYBIT_API_KEY = "...", BYBIT_API_SECRET = "..." }

codex mcp add bybit -- npx -y bybit-official-trading-server@latest

{"category":"linear"}

Create `STRATEGY.md`. Keep every trading rule in this file so the model does not need to invent missing constraints.

# Strategy: EMA 9/21 trend follow, 4h

## Pairs
BTCUSDT, ETHUSDT, SOLUSDT (category: linear)

## Timeframe
Decide on 4h close. Manage on 15m.

## Entry
Long: 9 EMA crosses above 21 EMA on 4h close, price above 200 EMA, funding < 0.03% per 8h.
Short: mirror.
No entry if a position is already open on that symbol.

## Exit
Stop: 1.5 x ATR(14) from entry.
Take profit: 3R, or 9/21 cross back, whichever first.
Time stop: close if flat after 5 days.

## Sizing
Risk 1% of equity per trade. qty = (equity * 0.01) / stop_distance.
Leverage: BTC 5x, ETH and SOL 3x. Never above the risk gate cap.

## Execution
Market entry only. Attach TP and SL on the order itself (takeProfit / stopLoss fields).

{"ts":"2026-09-14T04:00:00Z","symbol":"BTCUSDT","side":"long","qty":0.05,"entry":63120,"exit":64890,"pnl_usdt":88.5,"r":1.9,"reason":"9/21 cross, funding neutral","outcome":"tp_hit"}

{
  "ts": "2026-09-14T04:00:00Z",
  "symbol": "BTCUSDT",
  "action": "long",
  "qty": 0.05,
  "stop": 62100,
  "take_profit": 66200,
  "confidence": 0.7,
  "reasoning": "4h 9/21 cross confirmed at close, price above 200 EMA, funding 0.01%. OI rising with price.",
  "checked_learnings": [
    "Sept 8: skipped SOL longs into funding > 0.05%, saved 1.2R"
  ]
}

Create `prompts/cycle.md`:

You are the trading brain. Do exactly this, in order:

1. Read STRATEGY.md, memory/learnings.md, memory/decision.json, and the last 20 lines of memory/trades.jsonl.
2. For each pair in the strategy, call getTickers, getMarketKline (interval 240, limit 250) and getFundingRateHistory. Call getPositionInfo and getWalletBalance once.
3. Apply the strategy rules literally. Do not invent rules that are not in STRATEGY.md.
4. Write memory/decision.json with your decision and reasoning, including which learnings you checked.
5. If action is "long" or "short", call risk-gate place_order with the exact qty, stop and take_profit from your decision. If action is "close", call risk-gate close_position.
6. If the gate rejects the order, do not retry with different numbers. Log the rejection and stop.
7. Append one line to memory/learnings.md only if a trade closed since the last cycle.
8. Post a one-paragraph summary to Telegram via the alert script.

async function checkOrder(req: OrderRequest): Promise<GateResult> {
  if (fs.existsSync(path.join(BOT_DIR, "HALT_TRADING")))
    return reject("kill_switch");

  const equity = await bybit.equityUsdt();
  const todayPnl = await bybit.pnlSinceMidnightUtc();
  if (todayPnl < -0.05 * equity) return reject("daily_loss_cap");

  const mark = await bybit.markPrice(req.symbol);
  if (req.qty * mark > 0.30 * equity) return reject("notional_cap");

  const lev = await bybit.leverage(req.symbol);
  const cap = req.symbol === "BTCUSDT" ? 10 : 5;
  if (lev > cap) return reject("leverage_cap");

  if (req.price && Math.abs(req.price - mark) / mark > 0.02)
    return reject("price_sanity");

  const open = await bybit.openPositions();
  if (open.length >= 3 || open.some(p => p.symbol === req.symbol))
    return reject("position_cap");

  return pass();
}

touch HALT_TRADING

rm HALT_TRADING

# entry scan on every 15m candle close
*/15 * * * * cd /path/to/trading-bot && codex exec --model gpt-6-astra "$(cat prompts/cycle.md)" >> logs/cycle.log 2>&1

# position check every minute
* * * * * cd /path/to/trading-bot && node scripts/position-check.js >> logs/position.log 2>&1

# funding check every 4h
0 */4 * * * cd /path/to/trading-bot && node scripts/funding-check.js >> logs/funding.log 2>&1

Build me an AI trading bot for Bybit USDT perpetuals following this architecture exactly.

Runtime: this bot runs as scheduled `codex exec` calls plus a few plain Node scripts. The model is the brain; it may only trade through a risk-gate MCP server that you will build. It must never be given Bybit's createOrder tool directly.

Build these pieces:

1. STRATEGY.md with an EMA 9/21 4h trend-follow rule on BTCUSDT, ETHUSDT, SOLUSDT, 1% risk per trade, ATR stop, 3R target, attached TP/SL. Mark it clearly as a teaching scaffold.

2. memory/ with trades.jsonl, learnings.md and decision.json, plus the schemas in comments. Cap learnings.md at 50 lessons with an auto-summarise rule.

3. prompts/cycle.md: the seven-step cycle prompt. Include the instruction that a gate rejection must never be retried with different numbers.

4. risk-gate/: a stdio MCP server in TypeScript exposing place_order, close_position, set_leverage, cancel_order. It holds BYBIT_API_KEY and BYBIT_API_SECRET from env, signs Bybit V5 REST requests (HMAC-SHA256), and switches between https://api-testnet.bybit.com and https://api.bybit.com on BYBIT_TESTNET. Before forwarding any write it runs six checks in order: kill switch file HALT_TRADING, daily loss cap 5% of equity since 00:00 UTC, notional cap 30% of equity, leverage cap BTC 10x / others 5x, price sanity 2% from mark, position cap 3 open and 1 per symbol. The gate fetches equity, mark price, leverage and positions itself; it never trusts numbers from the caller. Every call is appended to logs/audit.jsonl with request, check results and exchange response. close_position places a reduceOnly market order for the full position size.

5. scripts/: position-check.js (1m, alerts on stop or TP fill), funding-check.js (4h), telegram-alert.js (posts a paragraph), telegram-commands.js (polls for /status /halt /resume /close <symbol> /why).

6. A crontab.txt with the three schedules and a README that walks a beginner through: install Node, install Codex, add both MCP servers to ~/.codex/config.toml, create a testnet key, run the cycle once by hand, turn on cron, and the exact testnet-to-mainnet checklist.

7. Use Bybit's official MCP (npx -y bybit-official-trading-server@latest) for all reads. The real read tool names are getTickers, getMarketKline, getOrderbook, getFundingRateHistory, getOpenInterest, getWalletBalance, getPositionInfo, getOpenOrders, getOrderHistory, getClosedPnl. category is always "linear".

Default everything to testnet. Do not write any key into any file. When you're done, run a dry cycle against testnet and show me the audit log line it produced.

cd /path/to/trading-bot
codex exec "$(cat prompts/cycle.md)"