result = analyze_technical_indicators(
  productId="BTC-EUR",
  granularity="ONE_HOUR",
  candleCount=100,
  indicators=["rsi", "macd", "bollinger", "adx", "obv", "pivots"]
)

┌─────────────────────────────────────────────────────────────┐
│ PHASE 1: DATA COLLECTION                                    │
│   1. Check Portfolio Status                                 │
│   2. Collect Market Data                                    │
│   3. Technical Analysis                                     │
│   4. Sentiment Analysis                                     │
├─────────────────────────────────────────────────────────────┤
│ PHASE 2: MANAGE EXISTING POSITIONS (frees up capital)       │
│   5. Check SL/TP/Trailing                                   │
│   6. Rebalancing Check                                      │
│   7. Apply Compound (after exits)                           │
│  7a. Budget Exhaustion Check                                │
├─────────────────────────────────────────────────────────────┤
│ PHASE 3: NEW ENTRIES (uses freed capital)                   │
│   8. Signal Aggregation                                     │
│  8a. Apply Volatility-Based Position Sizing                 │
│   9. Check Fees & Profit Threshold                          │
│  10. Pre-Trade Liquidity Check                              │
│  11. Execute Order                                          │
├─────────────────────────────────────────────────────────────┤
│ PHASE 4: REPORT                                             │
│  12. Output Report                                          │
│  13. Sleep → Repeat                                         │
└─────────────────────────────────────────────────────────────┘

// Primary timeframe (15 min) - for entry/exit signals
candles_15m = get_product_candles(pair, FIFTEEN_MINUTE, 100)

// Higher timeframes - for trend confirmation
candles_1h = get_product_candles(pair, ONE_HOUR, 100)
candles_4h = get_product_candles(pair, FOUR_HOUR, 60)
candles_daily = get_product_candles(pair, ONE_DAY, 30)

// Current price
current_price = get_best_bid_ask(pair)

rsi = calculate_rsi(candles, period=14)
→ rsi.latestValue < 30: BUY (+2), > 70: SELL (-2)

rsi_div = detect_rsi_divergence(candles)
→ rsi_div.hasBullishDivergence: +3, hasBearishDivergence: -3

stoch = calculate_stochastic(candles)
→ stoch.latestValue.k < 20 && stoch.latestValue.k > stoch.latestValue.d: BUY (+2)

williams = calculate_williams_r(candles)
→ williams.latestValue < -80: BUY (+1), > -20: SELL (-1)

cci = calculate_cci(candles)
→ cci.latestValue < -100: BUY (+2), > +100: SELL (-2)

roc = calculate_roc(candles)
→ roc.latestValue crosses 0 upward: BUY (+2)

macd = calculate_macd(candles)
→ macd.latestValue.histogram > 0 && macd.latestValue.MACD > macd.latestValue.signal: BUY (+2)
→ Golden cross (MACD crosses signal from below): +3

ema_9 = calculate_ema(candles, period=9)
ema_21 = calculate_ema(candles, period=21)
ema_50 = calculate_ema(candles, period=50)
→ ema_9.latestValue > ema_21.latestValue > ema_50.latestValue: Uptrend (+2)

adx = calculate_adx(candles)
→ adx.latestValue.adx > 25: Strong trend (confirms signals)
→ adx.latestValue.pdi > adx.latestValue.mdi: Bullish (+2)

psar = calculate_psar(candles)
→ price > psar.latestValue: Uptrend (+1)
→ SAR flip: ±2

ichimoku = calculate_ichimoku_cloud(candles)
→ price > ichimoku.latestValue.spanA && price > ichimoku.latestValue.spanB: Bullish (+1)
→ ichimoku.latestValue.conversion crosses ichimoku.latestValue.base above cloud: +3

bb = calculate_bollinger_bands(candles)
→ bb.latestValue.pb < 0: Oversold, BUY (+2)
→ bb.latestValue.pb > 1: Overbought, SELL (-2)
→ bb.latestValue.bandwidth: Volatility measure (low = squeeze, high = expansion)

atr = calculate_atr(candles)
→ Use for position sizing: High ATR = smaller position

keltner = calculate_keltner_channels(candles)
→ price < keltner.latestValue.lower: BUY (+1)
→ price > keltner.latestValue.upper: SELL (-1)

obv = calculate_obv(candles)
→ OBV trend diverges from price: ±2

mfi = calculate_mfi(candles)
→ mfi.latestValue < 20: BUY (+2), > 80: SELL (-2)

vwap = calculate_vwap(candles)
→ price > vwap.latestValue: Bullish bias (+1)

volume_profile = calculate_volume_profile(candles)
→ price near volume_profile.pointOfControl: Strong support/resistance

pivots = calculate_pivot_points(candles, type="standard")
→ price bounces off pivots.support1: BUY (+2)
→ price rejected at pivots.resistance1: SELL (-2)

fib = calculate_fibonacci_retracement(swingLow, swingHigh)
→ price at fib.levels[4].price (61.8%): Strong level (±2)

candle_patterns = detect_candlestick_patterns(candles)
→ candle_patterns.bullish == true: Overall bullish bias (+2)
→ candle_patterns.bearish == true: Overall bearish bias (-2)
→ Check candle_patterns.detectedPatterns for specific patterns (e.g., ["Hammer", "Morning Star"])

chart_patterns = detect_chart_patterns(candles)
→ Bullish patterns (double_bottom, inverse_head_and_shoulders): +3
→ Bearish patterns (double_top, head_and_shoulders): -3

// Step 1: Normalize each category score (0-100) to weighted contribution
momentum_weighted = (momentum_score / 100) × 25
trend_weighted = (trend_score / 100) × 30
volatility_weighted = (volatility_score / 100) × 15
volume_weighted = (volume_score / 100) × 15
sr_weighted = (sr_score / 100) × 10
patterns_weighted = (patterns_score / 100) × 5

// Step 2: Sum all weighted contributions (result: 0-100 range)
Final_Score = momentum_weighted + trend_weighted + volatility_weighted
            + volume_weighted + sr_weighted + patterns_weighted

// For each higher timeframe (1h, 4h, daily):
//
// 1. Calculate MACD (12, 26, 9)
// 2. Calculate EMA alignment (EMA9 > EMA21 > EMA50)
// 3. Calculate ADX (14) with +DI/-DI

// Determine trend:
IF MACD > Signal AND EMA(9) > EMA(21) > EMA(50) AND +DI > -DI:
  trend = "bullish"
ELSE IF MACD < Signal AND EMA(9) < EMA(21) < EMA(50) AND -DI > +DI:
  trend = "bearish"
ELSE:
  trend = "neutral"

// Store trend for each timeframe:
trend_1h = calculate_trend(candles_1h)
trend_4h = calculate_trend(candles_4h)
trend_daily = calculate_trend(candles_daily)

BTC-EUR Trend Analysis:
  15m: MACD bullish, EMA aligned up, RSI 65
  1h: BULLISH (MACD +120, EMA 9>21>50, +DI>-DI)
  4h: BULLISH (MACD +80, EMA aligned, ADX 28)
  Daily: NEUTRAL (MACD near zero, sideways)

// Use stored values from position entry
entry_price = position.entry.price
entry_atr = position.riskManagement.entryATR
dynamic_tp = position.riskManagement.dynamicTP
dynamic_sl = position.riskManagement.dynamicSL

// Or recalculate if position > 24h old (with validation):
IF entry_price <= 0:
  → Log: "Invalid entry_price: {entry_price}, using stored values"
  → Use position.riskManagement.dynamicTP/SL
  → SKIP recalculation
ELSE IF ATR(14) < 0.001:
  → Log: "ATR too low: {atr}, insufficient volatility data"
  → Use default: ATR_PERCENT = 2.0
ELSE:
  ATR_PERCENT = ATR(14) / entry_price × 100

// Calculate TP/SL based on strategy
IF session.config.strategy == "aggressive":
  TP_PERCENT = max(2.0, ATR_PERCENT × 1.5)  // 1.5× ATR, floor at 2%
  SL_PERCENT = clamp(ATR_PERCENT × 2.0, 3.0, 15.0)  // 2.0× ATR, 3-15%

ELSE IF session.config.strategy == "conservative":
  TP_PERCENT = 3.0  // Fixed 3%
  SL_PERCENT = 5.0  // Fixed 5%

ELSE IF session.config.strategy == "scalping":
  TP_PERCENT = 1.5  // Fixed 1.5%
  SL_PERCENT = 2.0  // Fixed 2.0%

ELSE:
  // Default to aggressive if strategy not recognized
  TP_PERCENT = max(2.0, ATR_PERCENT × 1.5)
  SL_PERCENT = clamp(ATR_PERCENT × 2.0, 3.0, 15.0)

take_profit_price = entry_price × (1 + TP_PERCENT / 100)
stop_loss_price = entry_price × (1 - SL_PERCENT / 100)

// Priority 1: Stop-Loss
IF current_price <= stop_loss_price:
  → Immediately sell (STOP-LOSS) using Market Order
  → Log: "Stop-Loss triggered at -[X]% (ATR-based)"

// Priority 2: Take-Profit
IF current_price >= take_profit_price:
  → Secure profit (TAKE-PROFIT) using Limit Order
  → Log: "Take-Profit triggered at +[X]% (ATR-based)"

// Update highest price
IF current_price > position.riskManagement.trailingStop.highestPrice:
  position.riskManagement.trailingStop.highestPrice = current_price

// Check activation (with validation)
IF entry_price > 0:
  current_profit_pct = (current_price - entry_price) / entry_price × 100
ELSE:
  → Log: "Invalid entry_price for trailing stop: {entry_price}"
  → SKIP trailing stop check
  → current_profit_pct = 0

IF current_profit_pct >= 3.0:
  position.riskManagement.trailingStop.active = true
  position.riskManagement.trailingStop.currentStopPrice = position.riskManagement.trailingStop.highestPrice × 0.985

// Priority 3: Trailing Stop
IF position.riskManagement.trailingStop.active AND current_price <= position.riskManagement.trailingStop.currentStopPrice:
  // Ensure minimum profit (covers fees)
  IF current_price >= entry_price × 1.01:  // At least +1%
    → SELL (Trailing Stop) using Market Order
    → Log: "Trailing Stop triggered at +[X]% (peak was +[Y]%)"

Position: SOL-EUR
  Entry: 119.34 EUR
  Current: 125.00 EUR (+4.7%)
  Highest: 128.50 EUR (+7.7%)
  ATR(14): 8.0%
  Dynamic TP: 143.21 EUR (+20.0%)
  Dynamic SL: 101.44 EUR (-15.0% capped)
  Trailing Stop: ACTIVE at 126.57 EUR
  Status: TRAILING (stop rising with price)

// Force Exit Check (prevent unlimited stagnation)
stagnation_score = (holdingTimeHours / 12) × (1 - abs(unrealizedPnLPercent / 2.0))

IF stagnation_score > 2.0:
  → FORCE CLOSE (market order)
  → Reason: "Maximum stagnation threshold exceeded"
  → Log: "Force closed {PAIR} after {hours}h: stagnation_score={score}, PnL={pnl}%"
  → SKIP to next cycle (no rebalancing, position is closed)

// Example scenarios:
// - 24h hold, 0% PnL: (24/12) × (1 - 0/2) = 2.0 × 1.0 = 2.0 (threshold)
// - 30h hold, 0.5% PnL: (30/12) × (1 - 0.25) = 2.5 × 0.875 = 2.19 (FORCE CLOSE)
// - 24h hold, 1.5% PnL: (24/12) × (1 - 0.75) = 2.0 × 0.25 = 0.5 (continue)
// - 36h hold, -1% PnL: (36/12) × (1 - 0.5) = 3.0 × 0.5 = 1.5 (continue, try rebalance)
// - 48h hold, 0% PnL: (48/12) × (1 - 0) = 4.0 × 1.0 = 4.0 (FORCE CLOSE)

// Calculate opportunity delta
current_signal = position.analysis.signalStrength
best_alternative = max(all_pairs.filter(not_held AND score > 50).signalStrength)
opportunity_delta = best_alternative.score - current_signal

// Stagnation check
is_stagnant = holdingTimeHours > 12 AND abs(unrealizedPnLPercent) < 3

// Rebalancing decision
IF opportunity_delta > 40 AND is_stagnant AND unrealizedPnLPercent > -2:
  → SELL current position (market order)
  → BUY best alternative (limit order preferred)
  → Log: "Rebalanced {FROM}→{TO}: stagnant {X}h, delta +{Y}"

IF opportunity_delta > 60 AND unrealizedPnLPercent > -2:
  → REBALANCE (even if not stagnant, urgent opportunity)

═══════════════════════════════════════════════════════════════
                 REBALANCING ANALYSIS
═══════════════════════════════════════════════════════════════
Position: SOL-EUR (18h, +1.2%)
  Status: STAGNANT
  Current Signal: 25%
  Best Alternative: ETH-EUR (78%)
  Opportunity Delta: +53
  Recommendation: REBALANCE ✓

Today's Rebalances: 1/3
Last Rebalance: 4h ago (cooldown OK)
═══════════════════════════════════════════════════════════════

IF netPnL > 0 AND session.compound.enabled:
  compoundAmount = netPnL × session.compound.rate
  
  IF compoundAmount >= 0.10€:
    IF session.budget.remaining + compoundAmount <= session.compound.maxBudget:
      session.budget.remaining += compoundAmount
    ELSE:
      compoundAmount = maxBudget - session.budget.remaining  // Cap at max
      session.budget.remaining = maxBudget
    
    Log compound event to session.compound.compoundEvents[]
    session.compound.totalCompounded += compoundAmount
    Report: "Compounded +{X}€ → Budget now {Y}€"

// Track win/loss streak
IF trade_result == "WIN":
  session.compound.consecutiveWins++
  session.compound.consecutiveLosses = 0

  // Un-pause after 2 consecutive wins
  IF session.compound.paused AND session.compound.consecutiveWins >= 2:
    session.compound.paused = false
    session.compound.consecutiveLosses = 0
    Log: "Compound re-enabled after {wins} consecutive wins"

ELSE IF trade_result == "LOSS":
  session.compound.consecutiveLosses++
  session.compound.consecutiveWins = 0

  // Pause after 2 consecutive losses
  IF session.compound.consecutiveLosses >= 2:
    session.compound.paused = true
    Log: "Compound paused after {losses} consecutive losses"

// Apply compound only if not paused
IF session.compound.paused:
  Log: "Compound skipped (paused due to losses)"
  SKIP compound

// Determine effective compound rate
IF session.compound.consecutiveWins >= 3:
  effective_rate = session.compound.rate × 0.5  // 50% → 25%
  Log: "Compound rate reduced to {effective_rate}% after {wins} consecutive wins (risk control)"
ELSE:
  effective_rate = session.compound.rate

// Calculate compound amount with effective rate
IF net_pnl > 0:
  compound_amount = net_pnl × effective_rate
  IF compound_amount >= MIN_COMPOUND_AMOUNT:  // e.g., 0.10 EUR
    session.budget.remaining += compound_amount
    session.compound.totalCompounded += compound_amount
    Log: "Compounded {compound_amount}€ at {effective_rate}% rate"

// Step 1: Get minimum order sizes for potential trades
min_order_size_eur = 2.00  // Typical Coinbase minimum in EUR
min_order_size_btc = 0.00001  // Example BTC minimum

// Step 2: Check if budget allows ANY trade
IF session.budget.remaining < min_order_size_eur:

  // Step 3: Check if rebalancing is possible
  IF hasOpenPositions AND anyPositionEligibleForRebalancing:
    // Continue to rebalancing logic (Step 6)
    // Rebalancing can free up capital for new trades
    SKIP to Step 8 (Signal Aggregation) after rebalancing
  ELSE:
    // No positions to rebalance, insufficient budget for new entry
    Log: "Budget exhausted: {remaining}€ < minimum {min}€, no positions to rebalance"
    EXIT session with status "Budget Exhausted"
    STOP

// Rule: Only trade in direction of higher timeframe trend

// For BUY signals (score > +40):
IF signal_15m > 40:  // BUY signal detected

  // Check higher timeframe alignment
  IF trend_daily == "bearish" OR trend_4h == "bearish":
    Log: "BUY signal rejected: conflicts with higher timeframe trend"
    Log: "  Daily: {trend_daily}, 4h: {trend_4h}, 1h: {trend_1h}"
    signal_strength = signal_strength × 0.3  // Reduce by 70%

  ELSE IF trend_1h == "bearish":
    Log: "BUY signal weakened: 1h trend bearish (pullback zone)"
    signal_strength = signal_strength × 0.7  // Reduce by 30%

  ELSE IF trend_daily == "bullish" AND trend_4h == "bullish":
    Log: "BUY signal CONFIRMED: aligned with higher timeframes ✓"
    // No reduction, proceed with full strength

// For SELL signals (score < -40):
IF signal_15m < -40:  // SELL signal detected

  // Check higher timeframe alignment
  IF trend_daily == "bullish" OR trend_4h == "bullish":
    Log: "SELL signal rejected: conflicts with higher timeframe trend"
    Log: "  Daily: {trend_daily}, 4h: {trend_4h}, 1h: {trend_1h}"
    signal_strength = signal_strength × 0.3  // Reduce by 70%

  ELSE IF trend_1h == "bullish":
    Log: "SELL signal weakened: 1h trend bullish (rally in downtrend)"
    signal_strength = signal_strength × 0.7  // Reduce by 30%

  ELSE IF trend_daily == "bearish" AND trend_4h == "bearish":
    Log: "SELL signal CONFIRMED: aligned with higher timeframes ✓"
    // No reduction, proceed with full strength

// Step 1: Calculate base position size from signal strength (from Step 8)
IF signal_strength > 60:
  base_position_pct = 100  // Full position
ELSE IF signal_strength >= 40:
  base_position_pct = 75   // 75% position
ELSE IF signal_strength >= 20:
  base_position_pct = 50   // 50% position
ELSE:
  → SKIP trade (signal too weak)

// Step 2: Get current ATR and calculate average ATR
current_atr = ATR(14)
atr_average = calculate 14-day moving average of ATR(14)

// Defensive check
IF atr_average <= 0:
  atr_ratio = 1.0  // Default to normal volatility
ELSE:
  atr_ratio = current_atr / atr_average

// Step 3: Apply volatility adjustment
IF atr_ratio < 1.0:
  // Low volatility: increase position
  volatility_multiplier = 1.10  // +10%
ELSE IF atr_ratio <= 2.0:
  // Normal to moderate volatility: reduce slightly
  volatility_multiplier = 0.90  // -10%
ELSE:
  // High volatility: reduce significantly
  volatility_multiplier = 0.50  // -50%

// Step 4: Calculate final position size
final_position_pct = base_position_pct × volatility_multiplier

// Step 5: Apply exposure limits (from strategies.md Risk Per Trade section)
// Check ALL limits before finalizing position size:
//
// 1. Max exposure per asset: 33% of budget
//    - Sum existing positions in same asset + new position
//    - If total > 33%: reduce new position or SKIP
//
// 2. Max simultaneous positions: 3
//    - Count open positions
//    - If already at 3: SKIP trade (or force rebalancing first)
//
// 3. Max risk per trade: 2% of total portfolio
//    - Calculate: position_size × (SL_distance / entry_price)
//    - If risk > 2% of initial budget: reduce position size
//
// See strategies.md lines 145-149 for complete exposure limit definitions

final_position_size_eur = session.budget.remaining × (final_position_pct / 100)

Log: "Position: {base_position_pct}% (signal) × {volatility_multiplier} (ATR {atr_ratio:.2f}×) = {final_position_pct}% ({final_position_size_eur}€)"

maker_fee = fee_tier.maker_fee_rate  // e.g., 0.004
taker_fee = fee_tier.taker_fee_rate  // e.g., 0.006

// Signal strength determines likely order type
IF signal_strength > 70:
  // Strong signal → Market order likely
  entry_fee = taker_fee
ELSE:
  // Normal signal → Limit order attempted
  entry_fee = maker_fee

exit_fee = taker_fee  // Exits typically market orders

// Minimum Profit calculation
round_trip_fee = entry_fee + exit_fee
slippage_buffer = 0.003  // 0.3% average slippage

MIN_PROFIT_DIRECT = (round_trip_fee + slippage_buffer) × 2  // ~2.2-2.4%
MIN_PROFIT_INDIRECT = (round_trip_fee + slippage_buffer) × 4  // ~3.8-4.2%

// Check before trading
IF expected_move < MIN_PROFIT:
  → Log: "Trade unprofitable: expected {expected_move}% < required {MIN_PROFIT}%"
  → SKIP trade

// At limit order fallback (after 120s timeout)
// Re-calculate with Market Order fees
entry_fee_market = taker_fee
exit_fee = taker_fee
round_trip_fee_market = entry_fee_market + exit_fee
slippage = 0.003

MIN_PROFIT_FALLBACK = (round_trip_fee_market + slippage) × 2  // ~3.0%

IF expected_move < MIN_PROFIT_FALLBACK:
  → Log: "Fallback unprofitable: expected {expected_move}% < required {MIN_PROFIT_FALLBACK}%"
  → Cancel limit order, SKIP fallback
  → Position: None (limit order was not filled)
ELSE:
  → Proceed with Market Order fallback

Fees:
  Your Tier: [Tier Name]
  Maker: [X]%
  Taker: [Y]%
  Route: [Direct/Indirect]
  Round-Trip: [Z]%
  Min Profit Required: [W]%
  Expected Move: [V]% [✓/✗]

// Defensive validation against invalid data
IF best_bid <= 0 OR best_ask <= 0:
  → SKIP trade
  → Log: "Invalid order book data: bid={bid}, ask={ask}"
  → STOP

mid_price = (best_ask + best_bid) / 2
spread = (best_ask - best_bid) / max(mid_price, 0.0001)

// Sanity check for suspicious spreads
IF spread > 10.0:
  → SKIP trade
  → Log: "Suspicious spread: {spread}% (likely data error)"
  → STOP
```json
1. Decision:
   - Spread > 0.5% → SKIP trade, log "Spread too high: {X}%"
   - Spread 0.2% - 0.5% → Reduce position to 50%
   - Spread < 0.2% → Full position allowed
2. Store `entrySpread` and `liquidityStatus` in position

### 11. Execute Order

When a signal is present and expected profit exceeds MIN_PROFIT threshold:

**Order Type Selection**:

| Signal Strength | Order Type | Reason |
|-----------------|------------|--------|
| > 70% (Strong) | Market (IOC) | Speed is priority |
| 40-70% (Normal) | Limit (GTC) | Lower fees |
| < 40% (Weak) | No Trade | - |

**Route Selection**:

1. Call `list_products` to check if direct pair exists (e.g., BTC-SOL)
2. IF direct pair exists with sufficient liquidity:
   → Use direct pair, MIN_PROFIT = 2.0%
3. ELSE (no direct pair or illiquid):
   → Use indirect route (BTC → EUR → SOL)
   → MIN_PROFIT = 3.2%
   → Only trade if expected_profit > 3.2%

**For BUY (Limit Order)**:

   order_status = get_order(order_id)

   IF order_status == "FILLED":
     → Continue (fully filled, no action needed)

   ELSE IF order_status == "PARTIALLY_FILLED":
     filled_size = order.filled_size
     remaining_size = intended_size - filled_size

     IF remaining_size >= min_order_size:
       // Stage 2: Re-check profitability with Market Order fees
       IF expected_move >= MIN_PROFIT_FALLBACK:
         → Cancel original limit order
         → Place Market Order for remaining_size ONLY
         → Log: "Partial fill {filled_size}, fallback for {remaining_size}"
       ELSE:
         → Cancel order, accept partial fill only
         → Log: "Partial fill accepted: fallback unprofitable ({expected_move}% < {MIN_PROFIT_FALLBACK}%)"
     ELSE:
       → Accept partial fill, cancel order
       → Log: "Partial fill accepted: {filled_size} (remaining below minimum)"

   ELSE IF order_status == "OPEN":
     // Stage 2: Re-check profitability with Market Order fees
     IF expected_move >= MIN_PROFIT_FALLBACK:
       → Cancel order
       → Place Market Order for full intended_size
       → Log: "Limit order timeout, fallback to market"
     ELSE:
       → Cancel order, SKIP fallback
       → Log: "Fallback skipped: unprofitable with market fees ({expected_move}% < {MIN_PROFIT_FALLBACK}%)"

**For BUY (Market Order - Strong Signal)**:

**For SELL (open position)**:

### 12. Output Report

Output a structured report:

## Important Rules

1. **NEVER use more than the budget**
2. **ALWAYS call preview_order before create_order**
3. **Fees MUST be considered**
4. **When uncertain: DO NOT trade**
5. **Stop-loss is SACRED - always enforce it**

## Dry-Run Mode

If the argument contains "dry-run":

- Analyze everything normally
- But DO NOT execute real orders
- Only show what you WOULD do

## Autonomous Loop Mode

After each trading cycle:

1. **Output report** (as described above)
2. **Execute sleep**: `sleep <seconds>` based on configured interval (default: 900 = 15 minutes)
3. **Start over**: Begin again at step 1 (check portfolio status)

**Parse interval from arguments:**

- `interval=5m` → `sleep 300`
- `interval=15m` → `sleep 900` (default)
- `interval=30m` → `sleep 1800`
- `interval=1h` → `sleep 3600`
- `interval=60s` → `sleep 60`

The agent runs indefinitely until the user stops it with Ctrl+C.

**Important during the loop:**

- Load/save positions from trading-state.json each cycle
- Check stop-loss/take-profit on each cycle
- Show at the end of each cycle: "Next cycle in X minutes at Y... (sleep Z)"