Skill: eyeshaw/clawde (version 1.0.0)

--- name: claw-betting-ai description: AI-powered betting advisory for gaming platforms. Provides intelligent bet recommendations, risk analysis, bankroll management, and strategy optimization for crash games, dice, and casino games. Use when building automated betting bots or need AI gambling strategy guidance. website: https://clawde.xyz --- # CLAW Betting AI Advisory AI-powered betting advisory system for gaming platforms like Stake.com. Provides intelligent recommendations based on historical data analysis, risk tolerance, and proven betting strategies. **Website**: https://clawde.xyz ## Features - **Smart Bet Recommendations**: AI-analyzed optimal bet amounts and timing - **Crash Game Analysis**: Historical pattern analysis for crash games - **Risk Management**: Dynamic stop-loss and take-profit suggestions - **Bankroll Protection**: Kelly Criterion and flat betting strategies - **Multi-Strategy Support**: Martingale, Anti-Martingale, Fibonacci, D'Alembert ## Quick Start ```bash # Install the skill clawhub install claw-betting-ai # Configure your settings cp config/default.json config/local.json # Edit config/local.json with your preferences ``` ## Supported Games | Game | Analysis Method | |------|-----------------| | Crash | Historical crashpoint analysis, multiplier patterns | | Dice | Probability optimization, streak detection | | Limbo | Target multiplier recommendations | | Slide | Pattern recognition | ## Files Included ``` claw-betting-ai/ ├── SKILL.md # This file ├── config/ │ └── default.json # Default configuration ├── scripts/ │ ├── analyze.py # Crash history analyzer │ └── recommend.py # Bet recommendation engine └── examples/ ├── basic-usage.md # Getting started guide └── strategies.md # Strategy documentation ``` ## Configuration See `config/default.json` for all available options: - `strategy`: betting strategy (conservative/balanced/aggressive) - `bankroll`: starting bankroll amount - `baseBetPercent`: base bet as % of bankroll - `stopLoss`: stop-loss threshold - `takeProfit`: take-profit target - `maxBets`: maximum bets per session ## Core Strategies ### 1. Conservative (Low Risk) - Target: 1.5x - 2x multipliers - Win rate: ~50-65% - Max 1% bankroll per bet ### 2. Balanced (Medium Risk) - Target: 2x - 5x multipliers - Win rate: ~25-45% - Max 2% bankroll per bet ### 3. Aggressive (High Risk) - Target: 5x - 20x multipliers - Win rate: ~5-15% - Max 5% bankroll per bet ## API Reference See `examples/basic-usage.md` for full API documentation. ### Get Recommendation ```python from scripts.recommend import get_recommendation result = get_recommendation( bankroll=100, strategy="balanced", recent_history=[1.2, 3.5, 1.8, 2.1, 5.2] ) # Returns: { shouldBet: true, amount: 2.0, target: 2.5, confidence: 72 } ``` ## Safety Features - **Tilt Detection**: Warns when betting patterns indicate emotional decisions - **Session Limits**: Enforces time and loss limits - **Profit Locking**: Auto-protects portion of winnings - **Reality Checks**: Periodic reminders ## Disclaimer This is an advisory system only. Gambling involves risk of loss. Never bet more than you can afford to lose. Past patterns do not guarantee future results. ## Links - Website: https://clawde.xyz - Support: Contact via website

path: scripts/recommend.py
content: #!/usr/bin/env python3
"""
CLAW Betting AI - Bet Recommendation Engine
Generates intelligent betting recommendations based on analysis and strategy.
Website: https://clawde.xyz
"""

import json
import math
from typing import List, Dict, Any, Optional
from dataclasses import dataclass, asdict
from pathlib import Path


@dataclass
class BetRecommendation:
    """Betting recommendation result."""
    should_bet: bool
    amount: float
    target_multiplier: float
    confidence: int
    risk_level: str
    reasoning: str
    stop_loss_hit: bool = False
    take_profit_hit: bool = False


def load_config(config_path: Optional[str] = None) -> Dict[str, Any]:
    """Load configuration from file."""
    if config_path is None:
        config_path = Path(__file__).parent.parent / "config" / "default.json"
    
    with open(config_path) as f:
        return json.load(f)


def get_recommendation(
    bankroll: float,
    current_balance: float,
    session_profit: float,
    consecutive_losses: int,
    recent_history: List[float],
    strategy: str = "balanced",
    config: Optional[Dict] = None
) -> BetRecommendation:
    """
    Generate a betting recommendation.
    
    Args:
        bankroll: Starting bankroll for session
        current_balance: Current balance
        session_profit: Profit/loss this session
        consecutive_losses: Number of consecutive losses
        recent_history: Recent crash multipliers
        strategy: Strategy name (conservative/balanced/aggressive)
        config: Optional config override
    
    Returns:
        BetRecommendation with suggested action
    """
    if config is None:
        config = load_config()
    
    # Get strategy config
    strat_config = config["strategies"].get(strategy, config["strategies"]["balanced"])
    risk_config = config["riskManagement"]
    
    # Check stop-loss
    stop_loss_threshold = bankroll * (1 - config["stopLossPercent"] / 100)
    if current_balance <= stop_loss_threshold:
        return BetRecommendation(
            should_bet=False,
            amount=0,
            target_multiplier=0,
            confidence=100,
            risk_level="stop",
            reasoning="Stop-loss triggered. Session should end.",
            stop_loss_hit=True
        )
    
    # Check take-profit
    take_profit_threshold = bankroll * (1 + config["takeProfitPercent"] / 100)
    if current_balance >= take_profit_threshold:
        return BetRecommendation(
            should_bet=False,
            amount=0,
            target_multiplier=0,
            confidence=100,
            risk_level="profit",
            reasoning="Take-profit reached. Consider ending session.",
            take_profit_hit=True
        )
    
    # Check consecutive losses
    if consecutive_losses >= config["cooldownAfterLosses"]:
        return BetRecommendation(
            should_bet=False,
            amount=0,
            target_multiplier=0,
            confidence=80,
            risk_level="cooldown",
            reasoning=f"Cooldown needed after {consecutive_losses} losses."
        )
    
    # Check tilt
    if risk_config["tiltDetection"] and consecutive_losses >= risk_config["tiltThreshold"]:
        return BetRecommendation(
            should_bet=True,
            amount=_calculate_bet_amount(current_balance, strat_config, 0),  # Reset to base
            target_multiplier=strat_config["targetMultiplier"]["min"],
            confidence=60,
            risk_level="caution",
            reasoning="Possible tilt detected. Resetting to base bet."
        )
    
    # Calculate bet amount
    bet_amount = _calculate_bet_amount(
        current_balance, strat_config, consecutive_losses
    )
    
    # Calculate target multiplier
    target = _calculate_target(recent_history, strat_config)
    
    # Calculate confidence
    confidence = _calculate_confidence(recent_history, consecutive_losses)
    
    # Determine risk level
    risk_level = _determine_risk_level(bet_amount, current_balance, strat_config)
    
    return BetRecommendation(
        should_bet=True,
        amount=round(bet_amount, 2),
        target_multiplier=round(target, 2),
        confidence=confidence,
        risk_level=risk_level,
        reasoning=_generate_reasoning(strategy, consecutive_losses, target)
    )


def _calculate_bet_amount(
    balance: float,
    strat_config: Dict,
    consecutive_losses: int
) -> float:
    """Calculate bet amount based on strategy and losses."""
    base_bet = balance * (strat_config["baseBetPercent"] / 100)
    max_bet = balance * (strat_config["maxBetPercent"] / 100)
    
    progression = strat_config.get("progression", "flat")
    
    if progression == "flat":
        return base_bet
    elif progression == "mild":
        multiplier = strat_config.get("progressionMultiplier", 1.3)
        bet = base_bet * (multiplier ** consecutive_losses)
        return min(bet, max_bet)
    elif progression == "fibonacci":
        fib = _fibonacci(consecutive_losses + 1)
        bet = base_bet * fib
        return min(bet, max_bet)
    else:
        return base_bet


def _fibonacci(n: int) -> int:
    """Get nth Fibonacci number."""
    if n <= 1:
        return 1
    a, b = 1, 1
    for _ in range(n - 1):
        a, b = b, a + b
    return b


def _calculate_target(history: List[float], strat_config: Dict) -> float:
    """Calculate target multiplier based on history."""
    min_target = strat_config["targetMultiplier"]["min"]
    max_target = strat_config["targetMultiplier"]["max"]
    
    if not history:
        return min_target
    
    # Simple approach: use average of recent games as guide
    recent_avg = sum(history[:10]) / min(len(history), 10)
    
    # If recent average is low, stick to min target
    if recent_avg < 2.0:
        return min_target
    # If recent average is high, can aim higher
    elif recent_avg > 4.0:
        return min(max_target, min_target * 1.5)
    else:
        return (min_target + max_target) / 2


def _calculate_confidence(history: List[float], losses: int) -> int:
    """Calculate confidence score 0-100."""
    base = 60
    
    # Reduce confidence with losses
    base -= losses * 5
    
    # Adjust based on history stability
    if history and len(history) >= 10:
        recent = history[:10]
        variance = sum((x - sum(recent)/len(recent))**2 for x in recent) / len(recent)
        if variance > 10:
            base -= 10  # High variance = lower confidence
    
    return max(20, min(90, base))


def _determine_risk_level(bet: float, balance: float, strat_config: Dict) -> str:
    """Determine risk level of the bet."""
    bet_percent = (bet / balance) * 100
    base = strat_config["baseBetPercent"]
    
    if bet_percent <= base:
        return "low"
    elif bet_percent <= base * 2:
        return "medium"
    else:
        return "high"


def _generate_reasoning(strategy: str, losses: int, target: float) -> str:
    """Generate human-readable reasoning."""
    if losses == 0:
        return f"Starting fresh with {strategy} strategy, targeting {target}x"
    elif losses < 3:
        return f"Minor loss streak ({losses}), maintaining strategy"
    else:
        return f"Recovery mode after {losses} losses, adjusted target to {target}x"


def to_dict(rec: BetRecommendation) -> Dict[str, Any]:
    """Convert recommendation to dictionary."""
    return asdict(rec)


if __name__ == "__main__":
    # Example usage
    result = get_recommendation(
        bankroll=100,
        current_balance=95,
        session_profit=-5,
        consecutive_losses=2,
        recent_history=[1.5, 2.3, 3.1, 1.2, 4.5],
        strategy="balanced"
    )
    
    print("=== CLAW Bet Recommendation ===")
    print(f"Should Bet: {result.should_bet}")
    print(f"Amount: ${result.amount}")
    print(f"Target: {result.target_multiplier}x")
    print(f"Confidence: {result.confidence}%")
    print(f"Risk Level: {result.risk_level}")
    print(f"Reasoning: {result.reasoning}")
    print()
    print("Website: https://clawde.xyz")


path: scripts/analyze.py
content: #!/usr/bin/env python3
"""
CLAW Betting AI - Crash History Analyzer
Analyzes historical crash game data to identify patterns and trends.
Website: https://clawde.xyz
"""

import json
import statistics
from typing import List, Dict, Any
from dataclasses import dataclass


@dataclass
class CrashAnalysis:
    """Analysis results for crash game history."""
    average: float
    median: float
    std_dev: float
    below_2x_rate: float
    above_10x_rate: float
    current_streak: int
    streak_type: str  # 'low' or 'high'
    hot_zone: bool
    recommendation: str
    confidence: int


def analyze_crash_history(history: List[float]) -> CrashAnalysis:
    """
    Analyze crash game history and return insights.
    
    Args:
        history: List of crash multipliers (most recent first)
    
    Returns:
        CrashAnalysis with patterns and recommendations
    """
    if not history or len(history) < 10:
        return CrashAnalysis(
            average=0, median=0, std_dev=0,
            below_2x_rate=0, above_10x_rate=0,
            current_streak=0, streak_type='none',
            hot_zone=False,
            recommendation="Need more data (min 10 games)",
            confidence=0
        )
    
    # Basic statistics
    avg = statistics.mean(history)
    med = statistics.median(history)
    std = statistics.stdev(history) if len(history) > 1 else 0
    
    # Rate calculations
    below_2x = sum(1 for x in history if x < 2.0) / len(history)
    above_10x = sum(1 for x in history if x >= 10.0) / len(history)
    
    # Streak detection
    streak = 1
    streak_type = 'low' if history[0] < 2.0 else 'high'
    threshold = 2.0
    
    for i in range(1, len(history)):
        if (history[i] < threshold) == (history[0] < threshold):
            streak += 1
        else:
            break
    
    # Hot zone detection (multiple high multipliers recently)
    recent_10 = history[:10]
    high_count = sum(1 for x in recent_10 if x >= 5.0)
    hot_zone = high_count >= 3
    
    # Generate recommendation
    recommendation, confidence = _generate_recommendation(
        avg, med, below_2x, streak, streak_type, hot_zone, history[:5]
    )
    
    return CrashAnalysis(
        average=round(avg, 2),
        median=round(med, 2),
        std_dev=round(std, 2),
        below_2x_rate=round(below_2x * 100, 1),
        above_10x_rate=round(above_10x * 100, 1),
        current_streak=streak,
        streak_type=streak_type,
        hot_zone=hot_zone,
        recommendation=recommendation,
        confidence=confidence
    )


def _generate_recommendation(
    avg: float, med: float, below_2x: float,
    streak: int, streak_type: str, hot_zone: bool,
    recent: List[float]
) -> tuple:
    """Generate betting recommendation based on analysis."""
    
    confidence = 50  # Base confidence
    
    # Adjust based on streak
    if streak >= 5 and streak_type == 'low':
        recommendation = "Consider waiting - extended low streak"
        confidence = 65
    elif streak >= 3 and streak_type == 'high':
        recommendation = "Caution - high streak may end soon"
        confidence = 55
    elif hot_zone:
        recommendation = "Hot zone detected - consider higher targets"
        confidence = 60
    elif below_2x > 0.6:
        recommendation = "High bust rate - use conservative targets"
        confidence = 70
    elif avg > 3.0 and med > 2.0:
        recommendation = "Favorable conditions - balanced strategy OK"
        confidence = 65
    else:
        recommendation = "Normal conditions - stick to strategy"
        confidence = 50
    
    return recommendation, confidence


def format_report(analysis: CrashAnalysis) -> str:
    """Format analysis as readable report."""
    return f"""
=== CLAW Crash Analysis Report ===

Statistics:
  Average: {analysis.average}x
  Median: {analysis.median}x
  Std Dev: {analysis.std_dev}

Rates:
  Below 2x: {analysis.below_2x_rate}%
  Above 10x: {analysis.above_10x_rate}%

Current State:
  Streak: {analysis.current_streak} {analysis.streak_type} games
  Hot Zone: {'Yes' if analysis.hot_zone else 'No'}

Recommendation: {analysis.recommendation}
Confidence: {analysis.confidence}%

Website: https://clawde.xyz
"""


if __name__ == "__main__":
    # Example usage
    sample_history = [
        1.23, 3.45, 1.87, 2.34, 8.92,
        1.12, 1.45, 2.89, 4.56, 1.33,
        2.78, 5.67, 1.98, 3.21, 1.56
    ]
    
    result = analyze_crash_history(sample_history)
    print(format_report(result))


path: examples/basic-usage.md
content: # CLAW Betting AI - Basic Usage Guide

Website: https://clawde.xyz

## Getting Started

### 1. Installation

```bash
clawhub install claw-betting-ai
```

### 2. Configuration

Copy and customize the config:

```bash
cd ~/.agent/skills/claw-betting-ai
cp config/default.json config/local.json
```

Edit `config/local.json` with your preferences:

```json
{
  "strategy": "balanced",
  "bankroll": 100,
  "baseBetPercent": 1,
  "stopLossPercent": 20,
  "takeProfitPercent": 30
}
```

## Using the Analyzer

### Analyze Crash History

```python
from scripts.analyze import analyze_crash_history, format_report

# Your crash history (most recent first)
history = [1.23, 3.45, 1.87, 2.34, 8.92, 1.12, 1.45, 2.89, 4.56, 1.33]

# Get analysis
result = analyze_crash_history(history)
print(format_report(result))
```

**Output:**
```
=== CLAW Crash Analysis Report ===

Statistics:
  Average: 2.94x
  Median: 2.11x
  Std Dev: 2.31

Rates:
  Below 2x: 50.0%
  Above 10x: 0.0%

Current State:
  Streak: 1 low games
  Hot Zone: No

Recommendation: Normal conditions - stick to strategy
Confidence: 50%
```

## Using the Recommender

### Get Bet Recommendation

```python
from scripts.recommend import get_recommendation

result = get_recommendation(
    bankroll=100,          # Starting bankroll
    current_balance=95,    # Current balance
    session_profit=-5,     # P&L this session
    consecutive_losses=2,  # Loss streak
    recent_history=[1.5, 2.3, 3.1, 1.2, 4.5],
    strategy="balanced"
)

print(f"Bet: ${result.amount} at {result.target_multiplier}x")
print(f"Confidence: {result.confidence}%")
```

**Output:**
```
Bet: $1.69 at 2.50x
Confidence: 50%
```

## Strategy Selection

### Conservative
Best for: Preserving bankroll, long sessions

```python
result = get_recommendation(
    bankroll=100,
    current_balance=100,
    session_profit=0,
    consecutive_losses=0,
    recent_history=[...],
    strategy="conservative"
)
# Typical output: $0.50 at 1.75x
```

### Balanced
Best for: General use, moderate risk/reward

```python
result = get_recommendation(
    ...
    strategy="balanced"
)
# Typical output: $1.00 at 3.00x
```

### Aggressive
Best for: Recovery, high risk tolerance

```python
result = get_recommendation(
    ...
    strategy="aggressive"
)
# Typical output: $2.00 at 10.00x
```

## Session Flow Example

```python
from scripts.recommend import get_recommendation
from scripts.analyze import analyze_crash_history

# Session setup
bankroll = 100
balance = 100
profit = 0
losses = 0
history = []

# Game loop
while True:
    # Get recommendation
    rec = get_recommendation(
        bankroll=bankroll,
        current_balance=balance,
        session_profit=profit,
        consecutive_losses=losses,
        recent_history=history,
        strategy="balanced"
    )
    
    if not rec.should_bet:
        print(f"Stop: {rec.reasoning}")
        break
    
    print(f"Bet ${rec.amount} at {rec.target_multiplier}x")
    
    # ... place bet and get result ...
    
    # Update state based on result
    # crashed_at = ... (from game)
    # won = crashed_at >= rec.target_multiplier
    # ...
```

## Interpreting Results

### Confidence Levels

| Confidence | Meaning |
|------------|---------|
| 70-90% | Strong signal, conditions favorable |
| 50-70% | Normal conditions, follow strategy |
| 30-50% | Uncertain, consider smaller bets |
| <30% | Unfavorable, skip or wait |

### Risk Levels

| Risk | Action |
|------|--------|
| low | Standard bet, safe to proceed |
| medium | Elevated bet, monitor closely |
| high | Maximum progression, consider reset |
| cooldown | Take a break |
| stop | End session (stop-loss) |
| profit | Consider ending (take-profit) |

## Best Practices

1. **Set limits before starting** - Don't adjust stop-loss mid-session
2. **Follow recommendations** - Don't override based on "gut feeling"
3. **Take breaks** - Honor cooldown periods
4. **Lock profits** - When up 50%+, consider stopping
5. **Track results** - Keep a session log for analysis

## Support

- Website: https://clawde.xyz
- Report issues via website contact form


path: examples/strategies.md
content: # CLAW Betting AI - Strategy Guide

Website: https://clawde.xyz

## Overview

This guide covers the betting strategies available in CLAW Betting AI and when to use each one.

## Strategy Comparison

| Strategy | Target | Win Rate | Progression | Risk |
|----------|--------|----------|-------------|------|
| Conservative | 1.5-2x | 50-65% | Flat | Low |
| Balanced | 2-5x | 25-45% | Mild (1.3x) | Medium |
| Aggressive | 5-20x | 5-15% | Fibonacci | High |

## Conservative Strategy

### When to Use
- You have a small bankroll
- You want long session times
- You're risk-averse
- You're learning the system

### Configuration
```json
{
  "strategy": "conservative",
  "baseBetPercent": 0.5,
  "maxBetPercent": 2,
  "targetMultiplier": { "min": 1.5, "max": 2.0 }
}
```

### Expected Results
- Session duration: 100+ bets
- Expected variance: Low
- Profit potential: Slow, steady

### Example Session
```
Bankroll: $100
Bet 1: $0.50 at 1.75x → Win (+$0.37)
Bet 2: $0.50 at 1.75x → Win (+$0.37)
Bet 3: $0.50 at 1.75x → Lose (-$0.50)
...
After 50 bets: $103.50 (+3.5%)
```

## Balanced Strategy

### When to Use
- Standard sessions
- Moderate risk tolerance
- Good bankroll (50+ bets worth)
- General purpose betting

### Configuration
```json
{
  "strategy": "balanced",
  "baseBetPercent": 1,
  "maxBetPercent": 4,
  "progression": "mild",
  "progressionMultiplier": 1.3,
  "targetMultiplier": { "min": 2.0, "max": 5.0 }
}
```

### Progression Example
```
Loss 1: $1.00 (base)
Loss 2: $1.30 (1.3x)
Loss 3: $1.69 (1.3x)
Loss 4: $2.20 (1.3x)
Win → Reset to $1.00
```

### Expected Results
- Session duration: 30-80 bets
- Expected variance: Medium
- Profit potential: Moderate gains possible

## Aggressive Strategy

### When to Use
- Large bankroll
- High risk tolerance
- Recovery situations
- Short sessions

### Configuration
```json
{
  "strategy": "aggressive",
  "baseBetPercent": 2,
  "maxBetPercent": 8,
  "progression": "fibonacci",
  "targetMultiplier": { "min": 5.0, "max": 20.0 }
}
```

### Fibonacci Progression
```
Sequence: 1, 1, 2, 3, 5, 8, 13, 21...

Loss 1: $2.00 (1x base)
Loss 2: $2.00 (1x base)
Loss 3: $4.00 (2x base)
Loss 4: $6.00 (3x base)
Loss 5: $10.00 (5x base)
Win → Move back 2 positions
```

### Expected Results
- Session duration: 10-30 bets
- Expected variance: High
- Profit potential: Large swings both ways

## Mathematical Basis

### Kelly Criterion

The optimal bet size according to Kelly:

```
f* = (bp - q) / b

where:
  f* = optimal fraction of bankroll
  b = odds (multiplier - 1)
  p = probability of winning
  q = probability of losing (1 - p)
```

**Example for 2x target:**
- b = 1 (2x - 1)
- p = 0.45 (estimated)
- q = 0.55

```
f* = (1 × 0.45 - 0.55) / 1 = -0.10
```

Negative Kelly suggests the bet has negative expected value. This is why we use fractional Kelly (bet less than optimal).

### Expected Value

For crash games:
```
EV = (WinRate × Payout) - (1 - WinRate)

At 2x target with 45% win rate:
EV = (0.45 × 1.0) - (0.55) = -0.10 or -10%
```

The house edge means long-term expected value is negative. Strategy focuses on:
1. Managing variance
2. Maximizing entertainment value
3. Hitting take-profit before expected losses accumulate

## Risk Management

### Stop-Loss Rules

| Situation | Action |
|-----------|--------|
| -20% of bankroll | End session |
| 5 consecutive losses | 5-minute break |
| 8 consecutive losses | End session |
| Tilt detected | Reset to base bet |

### Take-Profit Rules

| Situation | Action |
|-----------|--------|
| +30% of bankroll | Consider stopping |
| +50% of bankroll | Lock 50% of profits |
| +100% of bankroll | Strongly consider stopping |

### Tilt Prevention

Signs of tilt:
- Increasing bets after losses beyond progression
- Chasing losses with higher targets
- Ignoring cooldown recommendations
- Betting faster than normal

When tilt is detected:
1. System resets to base bet
2. Warning is issued
3. If ignored, session may be ended

## Choosing Your Strategy

### Decision Tree

```
Is your bankroll < 50× base bet?
  → Use Conservative

Are you recovering from losses?
  → Use Aggressive (with caution)

Is this a casual session?
  → Use Balanced

Are you risk-averse?
  → Use Conservative

Do you have high risk tolerance?
  → Use Aggressive

Default → Use Balanced
```

## Custom Strategies

You can create custom strategies in your config:

```json
{
  "strategies": {
    "custom": {
      "targetMultiplier": { "min": 3.0, "max": 3.5 },
      "baseBetPercent": 1.5,
      "maxBetPercent": 6,
      "progression": "mild",
      "progressionMultiplier": 1.5,
      "expectedWinRate": 0.28
    }
  }
}
```

Then use:
```python
get_recommendation(..., strategy="custom")
```

## Disclaimer

All strategies carry risk. Past performance doesn't guarantee future results. Gamble responsibly.

---

Website: https://clawde.xyz


path: config/default.json
content: {
  "strategy": "balanced",
  "bankroll": 100,
  "currency": "USD",
  "baseBetPercent": 1,
  "maxBetPercent": 5,
  "stopLossPercent": 20,
  "takeProfitPercent": 30,
  "maxBetsPerSession": 100,
  "maxSessionMinutes": 120,
  "cooldownAfterLosses": 5,
  "cooldownMinutes": 5,
  "strategies": {
    "conservative": {
      "targetMultiplier": { "min": 1.5, "max": 2.0 },
      "baseBetPercent": 0.5,
      "maxBetPercent": 2,
      "progression": "flat",
      "expectedWinRate": 0.55
    },
    "balanced": {
      "targetMultiplier": { "min": 2.0, "max": 5.0 },
      "baseBetPercent": 1,
      "maxBetPercent": 4,
      "progression": "mild",
      "progressionMultiplier": 1.3,
      "expectedWinRate": 0.35
    },
    "aggressive": {
      "targetMultiplier": { "min": 5.0, "max": 20.0 },
      "baseBetPercent": 2,
      "maxBetPercent": 8,
      "progression": "fibonacci",
      "expectedWinRate": 0.12
    }
  },
  "riskManagement": {
    "maxConsecutiveLosses": 8,
    "profitLockPercent": 50,
    "profitLockThreshold": 1.5,
    "tiltDetection": true,
    "tiltThreshold": 3
  },
  "notifications": {
    "onStopLoss": true,
    "onTakeProfit": true,
    "onTilt": true,
    "onSessionEnd": true
  }
}


Security scan verdicts — ClawScan: suspicious | static analysis: clean | VirusTotal: clean | SkillSpector: suspicious (MEDIUM)