Vibeship-spawner-skills trading-psychology

id: trading-psychology

install

source · Clone the upstream repo

git clone https://github.com/vibeforge1111/vibeship-spawner-skills

manifest: trading/trading-psychology/skill.yaml

Emotional State Management

Your emotional state directly impacts trade quality. Learn to monitor it.

Pre-Trade Emotional Checklist

from dataclasses import dataclass
from enum import Enum
from datetime import datetime
from typing import Optional

class EmotionalState(Enum):
    GREEN = "green"    # Optimal state
    YELLOW = "yellow"  # Caution, reduced size
    RED = "red"        # Do not trade

@dataclass
class EmotionalAssessment:
    timestamp: datetime
    state: EmotionalState
    stress_level: int  # 1-10
    sleep_quality: int  # 1-10
    recent_pnl_feeling: str  # "neutral", "frustrated", "euphoric"
    life_stress: int  # 1-10
    physical_state: str  # "good", "tired", "sick"
    notes: str

    def is_tradeable(self) -> dict:
        """Determine if current state is tradeable."""
        blockers = []

        if self.stress_level > 7:
            blockers.append("High stress")
        if self.sleep_quality < 5:
            blockers.append("Poor sleep")
        if self.recent_pnl_feeling == "frustrated":
            blockers.append("Frustration from recent losses")
        if self.recent_pnl_feeling == "euphoric":
            blockers.append("Overconfidence from recent wins")
        if self.life_stress > 7:
            blockers.append("Life stress bleeding into trading")
        if self.physical_state != "good":
            blockers.append("Suboptimal physical state")

        if len(blockers) >= 3:
            recommendation = "DO NOT TRADE"
            size_adjustment = 0
        elif len(blockers) >= 1:
            recommendation = "TRADE WITH REDUCED SIZE"
            size_adjustment = 0.5
        else:
            recommendation = "CLEAR TO TRADE"
            size_adjustment = 1.0

        return {
            'can_trade': len(blockers) < 3,
            'blockers': blockers,
            'recommendation': recommendation,
            'size_adjustment': size_adjustment
        }

def morning_assessment() -> EmotionalAssessment:
    """
    Do this BEFORE opening your trading platform.

    Be honest. Your account depends on it.
    """
    print("=== Morning Emotional Assessment ===")
    print("Rate 1-10 (1=worst, 10=best)")

    stress = int(input("Current stress level: "))
    sleep = int(input("Sleep quality last night: "))
    pnl = input("Feeling about recent P&L (neutral/frustrated/euphoric): ")
    life = int(input("Life stress level: "))
    physical = input("Physical state (good/tired/sick): ")
    notes = input("Any notes: ")

    assessment = EmotionalAssessment(
        timestamp=datetime.now(),
        state=EmotionalState.GREEN,
        stress_level=stress,
        sleep_quality=sleep,
        recent_pnl_feeling=pnl,
        life_stress=life,
        physical_state=physical,
        notes=notes
    )

    result = assessment.is_tradeable()
    print(f"\n>>> RECOMMENDATION: {result['recommendation']}")
    if result['blockers']:
        print(f">>> Blockers: {', '.join(result['blockers'])}")

    return assessment

Emotional State During Trading

State	Symptoms	Action
Anxious	Heart racing, sweating	Stop, reduce size, or step away
Frustrated	Angry at market/self	Stop immediately, no more trades today
Euphoric	Invincible feeling	Reduce size, you're overconfident
FOMO	Panic about missing move	Do nothing, FOMO trades are losers
Calm	Clear thinking	Optimal state, trade normally
success_rate: "Traders who use pre-trade checklists report 30%+ improvement in decision quality"

Cognitive Biases in Trading

Your brain is actively sabotaging your trading. Learn to catch it.

The Big 10 Trading Biases

@dataclass
class CognitiveBias:
    name: str
    description: str
    trading_manifestation: str
    detection_questions: list
    antidote: str

TRADING_BIASES = [
    CognitiveBias(
        name="Confirmation Bias",
        description="Seeking information that confirms existing beliefs",
        trading_manifestation="Only looking for reasons your trade will work",
        detection_questions=[
            "Did I actively look for reasons this trade could FAIL?",
            "Would I share this analysis with someone who disagrees?",
            "Am I ignoring contradictory signals?"
        ],
        antidote="Write down 3 reasons the trade could fail before entering"
    ),
    CognitiveBias(
        name="Recency Bias",
        description="Overweighting recent events",
        trading_manifestation="Last few trades dominate your decision",
        detection_questions=[
            "Am I sizing based on last trade's outcome?",
            "Would I make this decision with no memory of recent trades?",
            "Am I 'due' for a win or 'on a roll'?"
        ],
        antidote="Use systematic position sizing, not gut feeling"
    ),
    CognitiveBias(
        name="Loss Aversion",
        description="Losses feel 2x as painful as equivalent gains",
        trading_manifestation="Holding losers, cutting winners early",
        detection_questions=[
            "Am I holding this because I 'need' it to come back?",
            "Would I enter this position at current levels?",
            "Am I afraid to lock in the loss?"
        ],
        antidote="Ask 'would I buy here?' If no, sell"
    ),
    CognitiveBias(
        name="Sunk Cost Fallacy",
        description="Continuing because you've already invested",
        trading_manifestation="Adding to losers, holding for breakeven",
        detection_questions=[
            "Am I holding just because I'm already in?",
            "Does my entry price matter for the future?",
            "Am I 'averaging down' or 'catching a falling knife'?"
        ],
        antidote="Pretend you have no position - what would you do?"
    ),
    CognitiveBias(
        name="Overconfidence",
        description="Overestimating your abilities",
        trading_manifestation="Size too large, ignore stops",
        detection_questions=[
            "When was my last losing trade? (If you can't remember...)",
            "Am I trading larger than my rules allow?",
            "Do I think I'm smarter than the market?"
        ],
        antidote="Review losing trades weekly. Keep ego in check"
    ),
    CognitiveBias(
        name="Hindsight Bias",
        description="Believing you 'knew it all along'",
        trading_manifestation="Beating yourself up for 'obvious' missed trades",
        detection_questions=[
            "Was this really obvious BEFORE it happened?",
            "Did I write down this prediction?",
            "Am I selectively remembering signals?"
        ],
        antidote="Journal predictions BEFORE outcomes"
    ),
    CognitiveBias(
        name="Anchoring",
        description="Over-relying on first piece of information",
        trading_manifestation="Fixating on entry price or analyst target",
        detection_questions=[
            "Am I thinking about my entry price when deciding to exit?",
            "Is an analyst's price target affecting my judgment?",
            "Would I view this differently with no prior information?"
        ],
        antidote="Evaluate positions as if entering fresh today"
    ),
    CognitiveBias(
        name="Gamblers Fallacy",
        description="Believing past events affect future probabilities",
        trading_manifestation="'Due for a win after 5 losses'",
        detection_questions=[
            "Am I betting more because 'probability is on my side now'?",
            "Do I think I'm 'due'?",
            "Is each trade truly independent?"
        ],
        antidote="Each trade is independent. History doesn't change probability"
    ),
    CognitiveBias(
        name="Disposition Effect",
        description="Selling winners early, holding losers long",
        trading_manifestation="Exactly what it says",
        detection_questions=[
            "Did I take profit early to 'lock in gains'?",
            "Am I holding a loser because 'it might come back'?",
            "What does the trade plan say?"
        ],
        antidote="Follow predetermined exits, not feelings"
    ),
    CognitiveBias(
        name="Availability Heuristic",
        description="Overweighting easily recalled events",
        trading_manifestation="Overtrading after a big win/loss",
        detection_questions=[
            "Is a vivid recent memory affecting my judgment?",
            "Am I generalizing from one memorable event?",
            "What does the data show, not my memory?"
        ],
        antidote="Use statistics, not memorable anecdotes"
    )
]

def bias_check(trade_idea: str) -> list:
    """Run through bias checklist before trading."""
    detected_biases = []

    for bias in TRADING_BIASES:
        print(f"\n{bias.name}:")
        for question in bias.detection_questions:
            answer = input(f"  {question} (y/n): ")
            if answer.lower() == 'y':
                detected_biases.append({
                    'bias': bias.name,
                    'antidote': bias.antidote
                })
                break

    return detected_biases

success_rate: "Bias awareness reduces impulsive trades by 40-60%"

name: Trade Journaling System description: Systematic self-analysis through detailed journaling detection: "journal|log|review|track" guidance: |

Trade Journaling System

The journal is where the real learning happens.

Comprehensive Trade Journal

from dataclasses import dataclass
from datetime import datetime
from typing import Optional, List
import pandas as pd
import json

@dataclass
class TradeJournalEntry:
    # Identification
    date: datetime
    symbol: str
    trade_id: str

    # Pre-Trade (filled BEFORE entering)
    setup_type: str
    thesis: str  # Why am I taking this trade?
    thesis_invalidation: str  # What would prove me wrong?
    emotional_state: str  # How am I feeling?
    confidence_level: int  # 1-10
    risk_reward: float

    # Execution
    entry_price: float
    entry_time: datetime
    planned_stop: float
    planned_target: float
    position_size: float

    # Post-Trade (filled AFTER exiting)
    exit_price: Optional[float] = None
    exit_time: Optional[datetime] = None
    exit_reason: Optional[str] = None  # stop, target, manual, other
    pnl: Optional[float] = None
    pnl_r: Optional[float] = None  # P&L in R-multiples

    # Analysis (filled AFTER exit)
    followed_plan: Optional[bool] = None
    what_went_well: Optional[str] = None
    what_could_improve: Optional[str] = None
    lesson_learned: Optional[str] = None
    emotional_state_during: Optional[str] = None
    would_take_again: Optional[bool] = None

    def to_dict(self) -> dict:
        return {k: str(v) if isinstance(v, datetime) else v
                for k, v in self.__dict__.items()}

class TradeJournal:
    def __init__(self, filepath: str = "trade_journal.json"):
        self.filepath = filepath
        self.entries = []
        self.load()

    def load(self):
        try:
            with open(self.filepath, 'r') as f:
                self.entries = json.load(f)
        except FileNotFoundError:
            self.entries = []

    def save(self):
        with open(self.filepath, 'w') as f:
            json.dump(self.entries, f, indent=2)

    def add_entry(self, entry: TradeJournalEntry):
        self.entries.append(entry.to_dict())
        self.save()

    def weekly_review(self) -> dict:
        """Generate weekly review metrics."""
        if not self.entries:
            return {}

        df = pd.DataFrame(self.entries)

        # Filter to last 7 days
        df['date'] = pd.to_datetime(df['date'])
        week_ago = datetime.now() - timedelta(days=7)
        weekly = df[df['date'] > week_ago]

        if len(weekly) == 0:
            return {'message': 'No trades this week'}

        # Metrics
        win_rate = (weekly['pnl'] > 0).mean()
        avg_r = weekly['pnl_r'].mean()
        total_r = weekly['pnl_r'].sum()
        plan_adherence = weekly['followed_plan'].mean()

        # Patterns
        best_setup = weekly.groupby('setup_type')['pnl_r'].mean().idxmax()
        worst_setup = weekly.groupby('setup_type')['pnl_r'].mean().idxmin()

        return {
            'trades': len(weekly),
            'win_rate': f"{win_rate:.0%}",
            'avg_r': f"{avg_r:.2f}R",
            'total_r': f"{total_r:.2f}R",
            'plan_adherence': f"{plan_adherence:.0%}",
            'best_setup': best_setup,
            'worst_setup': worst_setup,
            'lessons': weekly['lesson_learned'].dropna().tolist()
        }

Essential Journal Questions

BEFORE Trade:

Why am I taking this trade? (Be specific)
What invalidates my thesis?
What's my emotional state right now?
Am I following my rules?

AFTER Trade:

Did I follow my plan exactly?
What emotions did I feel during the trade?
If this was someone else's trade, would I respect the decision?
What's one thing I'd do differently? success_rate: "Traders who journal consistently outperform non-journalers by 25%+"

Tilt Recognition and Recovery

Tilt destroys more traders than bad strategies ever will.

Tilt Warning Signs

class TiltDetector:
    def __init__(self):
        self.recent_trades = []
        self.baseline_trade_frequency = 3  # Normal trades per day
        self.baseline_size = 1.0

    def add_trade(self, trade: dict):
        self.recent_trades.append({
            **trade,
            'timestamp': datetime.now()
        })

    def detect_tilt(self) -> dict:
        """Detect signs of tilt from recent behavior."""
        if len(self.recent_trades) < 3:
            return {'tilt_probability': 0, 'signs': []}

        recent = self.recent_trades[-10:]  # Last 10 trades
        signs = []

        # Sign 1: Increased frequency
        time_span = (recent[-1]['timestamp'] - recent[0]['timestamp']).total_seconds() / 3600
        trades_per_hour = len(recent) / max(time_span, 0.1)
        if trades_per_hour > 3:
            signs.append({
                'sign': 'Overtrading',
                'severity': min(trades_per_hour / 3, 3),
                'detail': f"{trades_per_hour:.1f} trades/hour"
            })

        # Sign 2: Increasing position sizes
        sizes = [t.get('size', 1) for t in recent]
        if len(sizes) >= 3:
            size_trend = sizes[-1] / sizes[0]
            if size_trend > 1.5:
                signs.append({
                    'sign': 'Increasing size',
                    'severity': size_trend,
                    'detail': f"Size up {size_trend:.1f}x"
                })

        # Sign 3: Revenge trading (trade right after loss)
        for i in range(1, len(recent)):
            time_gap = (recent[i]['timestamp'] - recent[i-1]['timestamp']).seconds
            if recent[i-1].get('pnl', 0) < 0 and time_gap < 300:  # Trade within 5 min of loss
                signs.append({
                    'sign': 'Revenge trade pattern',
                    'severity': 2,
                    'detail': f"Trade {time_gap}s after loss"
                })
                break

        # Sign 4: Abandoning stops
        stop_violations = sum(1 for t in recent if t.get('stop_violated', False))
        if stop_violations > 0:
            signs.append({
                'sign': 'Moving/ignoring stops',
                'severity': stop_violations + 1,
                'detail': f"{stop_violations} stop violations"
            })

        # Sign 5: Consecutive losses
        recent_pnl = [t.get('pnl', 0) for t in recent[-5:]]
        consecutive_losses = 0
        for p in reversed(recent_pnl):
            if p < 0:
                consecutive_losses += 1
            else:
                break
        if consecutive_losses >= 3:
            signs.append({
                'sign': 'Consecutive losses',
                'severity': consecutive_losses / 2,
                'detail': f"{consecutive_losses} losses in a row"
            })

        # Calculate overall tilt probability
        total_severity = sum(s['severity'] for s in signs)
        tilt_probability = min(total_severity / 10, 1.0)

        return {
            'tilt_probability': tilt_probability,
            'signs': signs,
            'recommendation': self._get_recommendation(tilt_probability)
        }

    def _get_recommendation(self, tilt_prob: float) -> str:
        if tilt_prob > 0.7:
            return "STOP TRADING IMMEDIATELY. Walk away. Do not return today."
        elif tilt_prob > 0.4:
            return "Take a 30-minute break. No new positions. Review last 5 trades."
        elif tilt_prob > 0.2:
            return "Caution. Reduce size by 50%. Slow down."
        else:
            return "Clear. Continue trading normally."

Tilt Recovery Protocol

Immediate (0-30 minutes):

Close all positions
Step away from screens
Physical movement (walk, exercise)
Do NOT check prices

Short-term (30 min - 2 hours):

Journal what happened
Identify the trigger
Review your rules
Eat something, hydrate

Before returning:

Complete emotional checklist
Review and accept the damage
Commit to 50% size for rest of day
Have someone check in on you success_rate: "Recognizing tilt early saves 80%+ of potential damage"

Trading Routines

Consistency in routine creates consistency in results.

Pre-Market Routine

from datetime import datetime, time
from typing import Callable, List

@dataclass
class RoutineItem:
    name: str
    duration_minutes: int
    action: str
    required: bool = True

PRE_MARKET_ROUTINE = [
    RoutineItem(
        name="Emotional Assessment",
        duration_minutes=5,
        action="Complete morning emotional checklist",
        required=True
    ),
    RoutineItem(
        name="Physical Preparation",
        duration_minutes=10,
        action="Shower, dress professionally (yes, even at home)",
        required=True
    ),
    RoutineItem(
        name="Review Markets",
        duration_minutes=15,
        action="Check overnight action, news, key levels",
        required=True
    ),
    RoutineItem(
        name="Review Watchlist",
        duration_minutes=10,
        action="Update watchlist with setups for today",
        required=True
    ),
    RoutineItem(
        name="Review Open Positions",
        duration_minutes=5,
        action="Confirm stops and targets, verify thesis",
        required=True
    ),
    RoutineItem(
        name="Define Today's Goals",
        duration_minutes=5,
        action="Set max loss, max trades, focus areas",
        required=True
    ),
    RoutineItem(
        name="Breathing/Meditation",
        duration_minutes=5,
        action="5 minutes of calm before market open",
        required=False
    )
]

def run_routine(routine: List[RoutineItem]) -> dict:
    """Execute pre-market routine."""
    completed = []
    skipped = []

    print("=== PRE-MARKET ROUTINE ===\n")

    for item in routine:
        print(f"{item.name} ({item.duration_minutes} min)")
        print(f"  Action: {item.action}")

        if item.required:
            input("  Press Enter when complete...")
            completed.append(item.name)
        else:
            do_it = input("  Complete? (y/n): ")
            if do_it.lower() == 'y':
                completed.append(item.name)
            else:
                skipped.append(item.name)

        print()

    return {
        'completed': completed,
        'skipped': skipped,
        'ready_to_trade': len(skipped) == 0 or all(
            item.name in skipped
            for item in routine
            if not item.required
        )
    }

# Daily maximum limits
@dataclass
class DailyLimits:
    max_loss_dollars: float
    max_loss_r: float = 3.0
    max_trades: int = 5
    max_size: float = 1.0  # Max position size multiplier
    stop_trading_time: time = time(15, 30)  # Stop 30 min before close

    def check_limits(self, current_pnl: float, trades_today: int) -> dict:
        violations = []

        if current_pnl <= -self.max_loss_dollars:
            violations.append("Hit daily max loss")

        if trades_today >= self.max_trades:
            violations.append("Hit max trades")

        current_time = datetime.now().time()
        if current_time >= self.stop_trading_time:
            violations.append("Past trading cutoff time")

        return {
            'can_trade': len(violations) == 0,
            'violations': violations,
            'pnl': current_pnl,
            'trades': trades_today
        }

Post-Market Routine

Required (15-20 minutes):

Close all positions or confirm overnight holds
Complete trade journal for all trades today
Calculate daily P&L
Review what went well
Review what could improve
Prepare next day's watchlist

Weekly (30-60 minutes, Sunday):

Weekly journal review
Calculate weekly stats
Identify patterns in wins/losses
Adjust strategy if needed
Set goals for next week success_rate: "Traders with consistent routines have 2x better risk-adjusted returns"

anti_patterns:

name: Revenge Trading description: Trading to recover losses immediately detection: "revenge|get.*back|recover|make.*up" why_harmful: | Revenge trading is the #1 account killer. You're not thinking clearly, you're sizing too large, and you're making emotional decisions. One revenge trade often leads to another, creating a spiral. what_to_do: | Stop trading after any loss that triggers emotional response. Have a rule: no new trades for 30 minutes after a losing trade. Accept the loss. It's done. Tomorrow is a new day.
name: FOMO Trading description: Entering because you fear missing a move detection: "fomo|missing.*out|should.*have|can't.*miss" why_harmful: | FOMO trades are usually at the worst possible entry. The move already happened. You're chasing, paying up, and entering where others are taking profits. Statistically, FOMO trades have much lower win rates. what_to_do: | If you didn't plan the trade, don't take it. Write down "I am experiencing FOMO" and sit on your hands. The market will always offer new opportunities. Missing a trade costs nothing. FOMO trades cost everything.
name: Moving Stops description: Moving stop loss further away when trade goes against you detection: "move.*stop|widen.*stop|give.*room" why_harmful: | Moving stops invalidates your entire risk management. You planned a 1R loss, now you're taking 3R. This single behavior destroys more traders than any strategy flaw. It's the equivalent of removing your seatbelt because you're about to crash. what_to_do: | Set your stop at entry and don't touch it. Ever. If your stops are constantly getting hit, the problem is your entry or stop placement, not the stop itself. Fix the system, not individual trades.
name: Overtrading description: Trading too frequently, often from boredom detection: "bored|need.*trade|have.*trade|action" why_harmful: | More trades = more commissions, more spread, more mistakes. Most days don't have good setups. Trading from boredom leads to taking suboptimal setups and degrading your edge. what_to_do: | Set a maximum trades per day (3-5 for most strategies). Track your trade frequency. If you're trading more than usual, ask why. Have activities for when markets are slow - reading, exercise, anything but trading.
name: Checking P&L Constantly description: Obsessively monitoring unrealized gains/losses detection: "check.*pnl|watch.*position|refresh" why_harmful: | Watching P&L tick by tick creates emotional volatility that impairs decision making. You're more likely to cut winners early or hold losers long. You're trading the P&L, not the setup. what_to_do: | Set alerts for your stops and targets. Check positions at set intervals (hourly, not continuously). Hide the P&L column if possible. Trade the plan, not the P&L.

handoffs:

trigger: "strategy|edge|backtest" to: quantitative-research context: "Validate strategy with statistics" expects:
- Clear strategy rules
- Historical data
- Honest assessment of emotional interference
trigger: "risk|size|drawdown|stop" to: risk-management-trading context: "Apply risk management rules" expects:
- Emotional state assessment
- Capacity to follow rules
- Historical adherence data
trigger: "chart|setup|entry" to: technical-analysis context: "Analyze technical setup" expects:
- Objective criteria
- Rule-based decisions
- Emotional filter applied
trigger: "sentiment|crowd|fear|greed" to: sentiment-analysis-trading context: "Understand crowd psychology" provides:
- Emotional context
- Crowd behavior analysis
- Contrarian indicators