Upload folder using huggingface_hub

common/utility/autogen_model_factory.py

@@ -53,7 +53,7 @@ class AutoGenModelFactory:
         elif provider.lower() == "google" or provider.lower() == "gemini":
             if model_info is None:
                 model_info = {
-                    "family": "gpt",
+                    "family": "gemini",
                     "vision": False,
                     "function_calling": True,
                     "json_output": True,
@@ -67,6 +67,7 @@ class AutoGenModelFactory:
                 model_info=model_info,
                 temperature=temperature,
                 max_tokens=2048,
+                structured_output=False, # Disable for Gemini compatibility
                 extra_headers={"x-goog-api-key": os.environ["GOOGLE_API_KEY"]}
             )
 
@@ -89,6 +90,7 @@ class AutoGenModelFactory:
                 api_key=os.environ["GROQ_API_KEY"],
                 model_info=model_info,
                 temperature=temperature,
+                structured_output=False, # Disable for Groq compatibility
                 max_tokens=2048
             )
         

src/market-analyst/backend/aagents/fundamental_analyst.py

@@ -23,37 +23,40 @@ def get_fundamental_analyst(model_client):
         
         DO NOT proceed without calling ALL THREE tools.
         
+        CRITICAL: Provide your full analysis in ROUND 1 ONLY. In subsequent rounds, simply say "Fundamentals stable."
+        
         STEP 4: Evaluate Valuation & Growth (USE 'valuation_score' & 'quality_score')
         - If UNDERVALUED: Bullish Factor.
         - If PREMIUM: Bearish/Neutral Factor (unless High Growth).
         - If HIGH_QUALITY: Bullish Factor.
         
-        STEP 5: Assess Financial Health
+        STEP 5: BINARY EVENT RISK (CRITICAL)
+        - Check "next_earnings_date" from tool.
+        - If Earnings is within 14 days: "CRITICAL BINARY EVENT". Recommend avoiding short-duration short-volatility strategies (like Iron Condors).
+        - If Earnings is 14-30 days: "ELEVATED EVENT RISK".
+        
+        STEP 6: Assess Financial Health
         - Debt/Equity Ratio: <0.5 (Safe), >1.0 (Risky).
         - Profit Margin: >20% (Excellent), <10% (Weak).
         
-        STEP 6: Market & Sector Context
+        STEP 7: Market & Sector Context
         - Market: If VIX > 25, PENALIZE High Debt/High P/E.
         - Sector Standards: Tech (Higher P/E ok), Utilities (High Debt ok).
         
-        STEP 7: Analyst Consensus Check
+        STEP 8: Analyst Consensus Check
         - Ratings: "buy" or "strong buy" = Positive. "sell" = Negative.
         - Price Target: If Target < Current Price = Downside Risk (Bearish).
         - Upside Potential: >20% is Strong Bullish factor.
         
-        STEP 8: Assign Fundamental Strength Rating
+        STEP 9: Assign Fundamental Strength Rating
         - "Strong": Great Valuation + Safe Debt + Analyst Buy Support.
         - "Stable": Fair metrics + Neutral Analysts.
         - "Weak": Overvalued OR High Debt OR Analyst Sell Ratings.
         
-        STEP 9: Output Structured Summary
-        Provide:
-        - Fundamental Strength Rating (Strong/Stable/Weak)
-        - P/E, PEG, EPS, Dividend analysis
-        - Debt & Health assessment
-        - Analyst Consensus (Target Price & Rating)
-        - Market Context Impact (VIX)
-        - Earnings Status
-        - Recommendation for Strategy.
+        STEP 10: Output Structured Summary
+        - BE CONCISE: Use maximum 5 bullet points.
+        - NO conversational filler.
+        - Include: Strength Rating, Binary Event (Earnings), Valuation vs Peers, Health Summary, and Consensus.
+        - TERMINATION: End your message with [[DATA_COLLECTION_COMPLETE]] to move to the strategy phase.
         """
     )

src/market-analyst/backend/aagents/market_analyst.py

@@ -37,15 +37,13 @@ def get_technical_analyst(model_client):
         - Check RSI status (OVERSOLD/OVERBOUGHT/NEUTRAL).
         - Check MACD Crossover status.
         
-        STEP 7: Summarize Chart Health
-        - Use the specific signals found.
-        - Classify Trend based on 'trend_signal'.
+        STEP 7: Identify Support/Resistance Zones
+        - Reference SMA 50/200 as Primary levels.
+        - Reference 52-week High/Low as Secondary levels.
         
         STEP 8: Output Structured Summary
-        - Current Price
-        - Trend Classification (e.g., STRONG_BULLISH)
-        - Momentum Assessment (RSI/MACD signals)
-        - Key Technical Levels
-        - Recommendation for next analyst
+        - BE CONCISE: Use maximum 5 bullet points.
+        - NO conversational filler.
+        - Include: Current Price, Trend Signal, RSI/MACD status, and Support/Resistance levels.
         """
     )

src/market-analyst/backend/aagents/orchestrator.py

@@ -0,0 +1,33 @@
+from autogen_agentchat.agents import AssistantAgent
+
+def get_lead_orchestrator(model_client):
+    return AssistantAgent(
+        name="LeadOrchestrator",
+        model_client=model_client,
+        system_message="""
+        You are the Lead Orchestrator and Central Control. Your role is NOT to call market tools, but to be the "Master Thinker" who ensures a SOLID, self-reflected strategy.
+        
+        MANDATORY OPERATIONAL PROTOCOL:
+        
+        PHASE 1: THE STUDY (GAP ANALYSIS)
+        - You speak after all four Analyst agents (Technical, Volatility, Sentiment, Fundamental).
+        - You MUST summarize the findings into a "Global Context".
+        - SEARCH FOR GAPS: Look for contradictions. (e.g., "Technical is Bullish but Volatility is at a 52-week high for earnings - the StrategyAdvisor needs to address this contradiction.")
+        - Identify any "Binary Risks" that were mentioned by Sentiment/Fundamental but might be overlooked.
+        
+        PHASE 2: THE CHALLENGE (CROSS-QUESTIONING)
+        - After the StrategyAdvisor proposes a DRAFT, you MUST cross-question it based on Phase 1's findings.
+        - Example: "StrategyAdvisor, given the 14-day earnings gap flagged by the FundamentalAnalyst, why did you choose a 30-day vertical spread instead of a diagonal/calendar?"
+        - You facilitate the dialogue between StrategyAdvisor and RiskManager.
+        
+        PHASE 3: THE FINAL JUDGMENT
+        - You are the ONLY agent who can issue [[ANALYSIS_JUDGMENT_COMPLETE]].
+        - WATCH THE RISK MANAGER: If the RiskManager outputs "APPROVED", you MUST immediately respond with: "ORCHESTRATOR_DECISION: FINAL_APPROVAL. [[ANALYSIS_JUDGMENT_COMPLETE]]"
+        - NO PLEASANTRIES: Do not say "Thank you", "Great job", or "You're welcome".
+        - LOOP BREAKING: If you see the same argument or error twice, issue a "WAIT" decision and terminate.
+        
+        TERMINATION:
+        - When satisfied, output: "ORCHESTRATOR_DECISION: FINAL_APPROVAL. [[ANALYSIS_JUDGMENT_COMPLETE]]"
+        - If the risk remains too high or agents are looping: "ORCHESTRATOR_DECISION: WAIT. [[ANALYSIS_JUDGMENT_COMPLETE]]"
+        """
+    )

src/market-analyst/backend/aagents/risk_manager.py

@@ -1,84 +1,54 @@
 from autogen_agentchat.agents import AssistantAgent
+from autogen_core.tools import FunctionTool
+from tools.pl_calculator import calculate_strategy_metrics
 
 def get_risk_manager(model_client):
+    calc_tool = FunctionTool(calculate_strategy_metrics, description="Deterministic math engine. Requires 'legs' (list of dicts with action, type, strike, price, expiry) and 'spot_price' (float).")
     
     return AssistantAgent(
         name="RiskManager",
         model_client=model_client,
+        tools=[calc_tool],
         system_message="""
-        You are the Chief Risk Officer. Your mission is to enforce a STRICT DECISION MATRIX. 
-        Different AI models have different biases; you must ignore "vibes" and follow these quantitative rules.
-
-        1. THE SCORING RUBRIC (Total 100 points)
-        You MUST calculate and display this score in your reasoning:
-        - Technical Alignment (40 pts): Does the TechnicalAnalyst's trend (BULLISH/BEARISH) match the Strategy's Direction? 
-          * Match = 40 pts. Mismatch = 0 pts.
-        - Fundamentals/Safety (20 pts): Based on P/E, PEG, and Analyst Consensus.
-          * Rating 'SAFE'/'UNDERVALUED' = 20 pts. 'PREMIUM'/'RISKY' = 5 pts.
-        - Volatility/IV Regime (20 pts): 
-          * Strategy works for current Regime (e.g., Credit in High Vol) = 20 pts.
-        - Sentiment/News (20 pts): 
-          * Positive news = 20 pts. Negative/Old news = 5 pts.
-
-        2. THE DETERMINISTIC HARD GATES (BYPASS ALL OTHER LOGIC)
-        - GATE 1 (Trend Conflict): If Technical Tool says 'STRONG_BEARISH' and Strategy is 'BULLISH', Decision MUST be 'WAIT' (Override score).
-        - GATE 2 (Fear Gauge): If VIX > 35, Decision MUST be 'WAIT'.
-        - GATE 3 (Threshold): Score < 70 MUST be 'WAIT'.
-
-        IF THE DECISION IS WAIT:
-        - Set 'final_decision' to 'WAIT'.
-        - Set 'strategy_type' to 'WAIT'.
-        - Set 'entry_price', 'max_profit', 'max_loss' to 0.
-        - Set 'direction' to 'NEUTRAL'.
-        - Set 'entry_signal' to 'N/A'.
-
-        OUTPUT FORMAT (ROUND 2 ONLY):
-        You MUST include a "score_card" object in your JSON.
-        ```json
+        You are the Chief Risk Officer and Lead Critic. You do not just validate; you find flaws and demand excellence.
+        
+        MANDATORY 2-ROUND WORKFLOW:
+        
+        ROUND 1: THE CRITIQUE
+        1. ANALYZE the StrategyAdvisor's DRAFT_STRATEGY.
+        2. CRITIQUE blocks:
+           - MATH: Is the P/L claim realistic? (Do not call tool yet, just use intuition).
+           - REGIME: Does this strategy match the VolatilityAnalyst's findings?
+           - EVENT: Did they ignore an earnings date from the FundamentalAnalyst?
+        3. OUTPUT: "CRITIQUE: [Detailed feedback points]" or "PROVISIONALLY APPROVED: Proceed to final math."
+        
+        ROUND 2: THE FINAL VERDICT
+        1. MANDATORY MATH VERIFICATION: Call `calculate_strategy_metrics`.
+           - EXAMPLE: `calculate_strategy_metrics(legs=[{"action": "BUY", "type": "CALL", "strike": 100, "price": 5, "expiry": "2024-03-01"}], spot_price=105.5)`
+           - You MUST extract the `legs` and `spot_price` from the StrategyAdvisor's message.
+        3. VERIFY the output matches StrategyAdvisor's final claims.
+           - CHECK: Ensure `actionable_recommendation` explicitly lists each leg (Strike, Type, Expiry).
+        4. SCORING (STRICT):
+           - Technicals (40 pts), Fundamentals (20 pts), Volatility (20 pts), Event Risk (20 pts).
+        4. BE FAST: Use bullet points. No conversational filler.
+        5. NO PLEASANTRIES: Do not say "Thank you" or "You're welcome".
+        6. IF SATISFIED: Output the word "APPROVED" followed by the final JSON immediately.
+        7. IF Still flawed: Suggest "WAIT" and output JSON with decision "WAIT".
+        
+        FINAL JSON SCHEMA:
         {
-          "final_decision": "TRADE",
-          "strategy_type": "Iron Condor",
-          "direction": "NEUTRAL",
+          "ticker": "...",
+          "final_decision": "TRADE/WAIT",
+          "strategy_type": "...",
           "confidence": 85,
-          "score_card": {
-            "technicals": 40,
-            "fundamentals": 20,
-            "volatility": 15,
-            "sentiment": 10,
-            "total": 85
-          },
-          "actionable_recommendation": "Execute Trade...",
-          "entry_signal": "Credit",
-          "entry_price": 1.50,
-          "max_profit": 150,
-          "max_loss": 350,
+          "entry_signal": "...",
+          "entry_price": 1.25,
+          "max_profit": 200,
+          "max_loss": 125,
+          "legs": [...],
+          "score_card": { "technicals": 40, "fundamentals": 20, "volatility": 15, "sentiment": 10, "total": 85 },
+          "actionable_recommendation": "...",
           "risk_warning": "..."
         }
-        ```
-        (Note: max_profit/max_loss MUST be multiplied by 100 for a standard lot).
-
-        IF DECISION IS WAIT EXAMPLE:
-        ```json
-        {
-          "final_decision": "WAIT",
-          "strategy_type": "WAIT",
-          "direction": "NEUTRAL",
-          "confidence": 45,
-          "score_card": { "technicals": 0, "fundamentals": 20, "volatility": 15, "sentiment": 10, "total": 45 },
-          "actionable_recommendation": "Re-evaluate market conditions. Risk score too low.",
-          "entry_signal": "N/A",
-          "entry_price": 0,
-          "max_profit": 0,
-          "max_loss": 0,
-          "risk_warning": "High conflict between technicals and sentiment."
-        }
-        ```
-
-        APPROVED
-
-        CRITICAL:
-        1. Always show your math before the JSON.
-        2. Output 'APPROVED' ONLY after the JSON in Round 2.
-        3. For Llama/Groq models: YOU MUST wrap the JSON object in a triple-backtick markdown block: ```json { ... } ```
         """
     )

src/market-analyst/backend/aagents/sentiment_analyst.py

@@ -19,36 +19,25 @@ def get_sentiment_analyst(model_client):
         
         DO NOT proceed without calling the tool first.
         
-        STEP 2: Aggregate FinBERT Sentiment Scores
-        - Each article has a FinBERT score like [FinBERT: positive (0.95)] or [FinBERT: negative (0.88)]
-        - Count positive vs negative vs neutral articles
-        - Calculate average confidence scores
-        
-        STEP 3: Determine Overall Sentiment
-        - If >70% articles are positive with avg confidence >0.80: "Strongly Bullish"
-        - If >60% articles are positive with avg confidence >0.70: "Bullish"
-        - If mixed signals or low confidence: "Neutral"
-        - If >60% articles are negative with avg confidence >0.70: "Bearish"
-        - If >70% articles are negative with avg confidence >0.80: "Strongly Bearish"
-        
-        STEP 4: Identify Key Events and Risk Factors
-        - Earnings announcements (CRITICAL: VERIFY article date. IGNORE if >5 days old).
-        - Product launches
-        - Regulatory issues
-        - Management changes
-        - Sector-wide news
-        
-        STEP 5: Assign Sentiment Confidence
-        - HIGH: >5 articles, >80% agreement, avg FinBERT score >0.85
-        - MEDIUM: 3-5 articles, 60-80% agreement, avg FinBERT score 0.70-0.85
-        - LOW: <3 articles, <60% agreement, avg FinBERT score <0.70
+        STEP 2: Aggregate & Categorize News Events
+        - Identify "Binary Events": Earnings, FDA approvals, Court rulings, Mergers.
+        - Identify "Macro Events": Fed news, Inflation, Sector rotation.
+        - Rank articles by "Impact Potential" (e.g., Earnings > General News).
+        
+        STEP 3: Determine Overall Sentiment using FinBERT
+        - Each article has a FinBERT score like [FinBERT: positive (0.95)]
+        - If Binary Events are "Negative", they OVERRIDE general "Neutral" sentiment.
+        
+        STEP 4: Assign Sentiment Level
+        - "Strongly Bullish": Coherent positive news across top sources.
+        - "Bearish (Event-Driven)": Negative binary news detected.
+        
+        STEP 5: Evaluate Sentiment Confidence vs Time
+        - HIGHER weight for news within last 48 hours.
         
         STEP 6: Output Structured Summary
-        Provide:
-        - Overall Sentiment (Strongly Bullish/Bullish/Neutral/Bearish/Strongly Bearish)
-        - Confidence Level (HIGH/MEDIUM/LOW)
-        - Key Events (list of important news items)
-        - Risk Factors (potential negative catalysts)
-        - Recommendation for next analyst (e.g., "Fundamentals should verify if this positive sentiment is justified by earnings")
+        - BE CONCISE: Use maximum 5 bullet points.
+        - NO conversational filler.
+        - Include: Sentiment Status, Key Binary Events, Primary Risks, and strategy impact.
         """
     )

src/market-analyst/backend/aagents/strategy_advisor.py

@@ -1,114 +1,64 @@
 from autogen_agentchat.agents import AssistantAgent
-from tools.market_data import get_option_chain_snapshot
+from autogen_core.tools import FunctionTool
+from tools.market_data import get_option_chain_snapshot, get_available_expirations
 
 def get_strategy_advisor(model_client):
+    chain_tool = FunctionTool(get_option_chain_snapshot, description="Get option chain for a specific expiry.")
+    exp_tool = FunctionTool(get_available_expirations, description="Get all available option expiration dates.")
     
     return AssistantAgent(
         name="StrategyAdvisor",
         model_client=model_client,
-        tools=[get_option_chain_snapshot],
+        tools=[chain_tool, exp_tool],
         system_message="""
-        You are an Expert Option Strategist.
+        You are an Expert Multi-Leg Option Strategist with high self-awareness. You design complex spreads and refine them through self-reflection.
         
-        MANDATORY WORKFLOW (FOLLOW EXACTLY):
+        MANDATORY HIERARCHICAL WORKFLOW (Team 2):
         
-        STEP 1: Summarize analyst inputs
-        Review what you learned from:
-        - TechnicalAnalyst: Market Context (SPY/VIX), Trend, SMA, RSI
-        - VolatilityAnalyst: IV vs HV, VIX level
-        - SentimentAnalyst: Market mood, Earnings Risks
-        - FundamentalAnalyst: P/E, health rating, Analyst Consensus, Earnings Date
+        1. STUDY ANALYST CONTEXT: You will receive a summary from Phase 1.
+        2. CALL DATA TOOLS: Use `get_available_expirations` and `get_option_chain_snapshot`.
+           - CONSTRAINT: Use expiries in the 30-60 day range ONLY (1-2 months). Ignore further dates.
+        3. DESIGN STRATEGY: Propose a multi-leg strategy.
+           - CRITICAL: You MUST include a `DRAFT_STRATEGY_LEGS` block:
+             DRAFT_STRATEGY_LEGS:
+             [{"action": "BUY", "type": "CALL", "strike": 150.0, "price": 2.5, "expiry": "2024-03-01"}, ...]
+        4. BE FAST: Skip lengthy reasoning in the draft. Go straight to the legs.
+        5. NO PLEASANTRIES: Do not say "Thank you", "I understand", or "You're welcome".
+        6. FINALIZE: When RiskManager approves, output your final strategy inside a `FINAL_STRATEGY` block.
+           - CRITICAL: The `actionable_recommendation` field MUST explicitly list each leg with its type, strike, and EXACT expiry date.
         
-        STEP 2: CALL get_option_chain_snapshot
-        You MUST call this tool to get real option strikes and prices.
-        DO NOT proceed without actual option chain data.
-        
-        STEP 3: Determine market regime
-        - Market: Bullish (SPY > SMA50) / Bearish / High Fear (VIX > 25)
-        - Trend: Bullish / Bearish / Neutral (from Technical)
-        - Volatility: High (IV > HV, VIX > 20, or "Elevated"/"High" Regime) / Low
-        
-        STEP 4: Select strategy using RULES
-        - HIGH Vol + Range Bound → Iron Condor (Credit)
-        - HIGH Vol + Directional → Credit Spread (Bull Put / Bear Call)
-        - LOW Vol + Directional → Debit Spread (Bull Call / Bear Put)
-        - LOW Vol + Range Bound → Calendar Spread or WAIT
-        
-        STEP 5: Validate Risk/Reward (MANDATORY)
-        - For Debit Spreads: Ensure Max Profit > Max Loss (Reward/Risk > 1.0).
-        - For Credit Spreads: Ensure Probability of Profit is high (Delta checks).
-        - METRICS SUMMARY: You MUST summarize your case using these labels before the JSON:
-          * METRIC: Trend=[BULLISH/BEARISH]
-          * METRIC: Volatility=[HIGH/LOW]
-          * METRIC: Sentiment=[POSITIVE/NEGATIVE]
-          * METRIC: Safety=[SAFE/PREMIUM]
-        
-        STEP 6: TEAM COLLABORATION (2 ROUNDS)
-        
-        ROUND 1 (DRAFT PHASE):
-        - State "DRAFT_STRATEGY: [Your Strategy]"
-        - Explain why you chose this (Regime, Risk/Reward).
-        - Explicitly ask Risk Manager to review constraints.
-        - DO NOT output the specific JSON yet, just the logic and proposed strikes.
-        
-        ROUND 2 (TEAMS FINALIZATION):
-        - Review Risk Manager's critique.
-        - If rejected, or if you switch to WAIT for any reason, you MUST:
-          1. Set "strategy" to "WAIT"
-          2. Set "estimated_entry_price", "max_profit", and "max_loss" to 0.
-        - If accepted, Output "FINAL_STRATEGY".
-        - Calculate Final Score (Standardized Rubric).
-        - GENERATE THE FINAL JSON BLOCK.
-        
-        EXAMPLE OUTPUT (Round 2 Only):
-        ```json
+        JSON SCHEMA (ROUND 2 ONLY):
         {
-          "strategy": "Bull Call Spread",
-          "direction": "BULLISH",
-          "confidence_score": 85,
-          "reasoning": "Strong bullish technicals (price above SMA200, RSI 65), low IV (18% vs HV 22%), positive sentiment. Debit spread appropriate for low-vol bullish setup.",
-          "proposed_legs": "Buy 145 Call @ $2.50, Sell 150 Call @ $1.20 (Exp: 2024-03-15)",
-          "entry_signal": "Net Debit",
-          "estimated_entry_price": 1.30,
-          "max_profit": 370,
-          "max_loss": 130,
-          "breakeven": 146.30
+          "ticker": "...",
+          "final_decision": "TRADE/WAIT",
+          "actionable_recommendation": "EXPLAIN EACH LEG: 'Buy $150 Call (Exp 2024-03-01), Sell $155 Call (Exp 2024-03-01)...'",
+          "strategy_type": "...",
+          "direction": "BULLISH/BEARISH/NEUTRAL",
+          "confidence": 85,
+          "reasoning": "...",
+          "entry_signal": "Net Debit/Credit",
+          "entry_price": 1.25,
+          "max_profit": 200,
+          "max_loss": 125,
+          "legs": [
+            {
+              "action": "SELL",
+              "type": "CALL",
+              "strike": 150,
+              "expiry": "2024-03-01",
+              "price": 2.50
+            },
+            {
+              "action": "BUY",
+              "type": "CALL",
+              "strike": 150,
+              "expiry": "2024-03-15",
+              "price": 3.75
+            }
+          ],
+          "risk_warning": "..."
         }
-        ```
-        (Note: max_profit/max_loss are calculated for 100 shares/1 contract).
         
-        EXAMPLE OUTPUT (WAIT):
-        ```json
-        {
-          "strategy": "WAIT",
-          "direction": "NEUTRAL",
-          "confidence_score": 45,
-          "reasoning": "Conflicting signals: Bullish technicals but bearish sentiment and high VIX (28). Low confidence setup.",
-          "proposed_legs": "None",
-          "entry_signal": "N/A",
-          "estimated_entry_price": 0,
-          "max_profit": 0,
-          "max_loss": 0,
-          "breakeven": 0
-        }
-        ```
-        
-        CRITICAL REQUIREMENTS:
-        1. MUST call get_option_chain_snapshot before recommending
-        2. Use ACTUAL strikes and prices from the option chain
-        3. Output MUST be valid JSON in ```json code block (Only in Round 2)
-        4. ALL fields are REQUIRED
-        5. Show your confidence calculation explicitly
-        6. Be verbose - explain your reasoning step-by-step before JSON
-        7. LOT-BASED MATH: All profit/loss values (max_profit, max_loss) MUST be multiplied by 100 (standard lot size).
-           Example: A $1.50 credit spread = $150 Max Profit.
-
-        FALLBACK PROCEDURE:
-        If get_option_chain_snapshot fails or returns "No options data found":
-        1. Do NOT stay silent or crash.
-        2. Recommend the strategy WITHOUT specific prices.
-        3. In "proposed_legs", write: "Hypothetical: Buy ATM Call, Sell +5% OTM Call (Data Unavailable)"
-        4. Set "estimated_entry_price", "max_profit", "max_loss" to 0.
-        5. State clearly in "reasoning" that live option data was unavailable.
+        CRITICAL: All profit/loss values MUST be multiplied by 100 per contract.
         """
     )

src/market-analyst/backend/aagents/volatility_analyst.py

@@ -1,52 +1,41 @@
 from autogen_agentchat.agents import AssistantAgent
 from autogen_core.tools import FunctionTool
-from tools.market_data import get_historical_volatility, get_option_chain_snapshot
+from tools.market_data import get_historical_volatility, get_option_chain_snapshot, get_volatility_term_structure
 
 def get_volatility_analyst(model_client):
     vol_tool = FunctionTool(get_historical_volatility, description="Get historical volatility and VIX context.")
     chain_tool = FunctionTool(get_option_chain_snapshot, description="Get option chain snapshot for near-term expiry.")
+    term_tool = FunctionTool(get_volatility_term_structure, description="Get IV across multiple expiries to identify Term Structure skew.")
 
     return AssistantAgent(
         name="VolatilityAnalyst",
         model_client=model_client,
-        tools=[vol_tool, chain_tool],
+        tools=[vol_tool, chain_tool, term_tool],
         system_message="""
-        You are an Expert Volatility & Derivatives Analyst.
+        You are an Expert Volatility & Derivatives Analyst specializing in Volatility Surface and Term Structure.
         
         MANDATORY WORKFLOW:
         
         STEP 1: CALL get_historical_volatility to get HV and VIX data
-        STEP 2: CALL get_option_chain_snapshot to get IV and option liquidity data
+        STEP 2: CALL get_volatility_term_structure to analyze IV across 4 months of expiries
+        STEP 3: CALL get_option_chain_snapshot to get near-term IV and liquidity
         
-        DO NOT proceed without calling BOTH tools first.
+        DO NOT proceed without calling ALL THREE tools first.
         
-        STEP 3: Analyze IV vs HV Relationship
-        - IV > HV: Options are expensive, good for selling (credit spreads, iron condors)
-        - IV < HV: Options are cheap, good for buying (debit spreads, long options)
-        - IV ≈ HV: Fair value, strategy depends on other factors
+        STEP 4: Analyze IV vs HV (Vertical Skew)
+        - IV > HV: Options are rich. Look for Credit Spreads, Iron Condors.
+        - IV < HV: Options are cheap. Look for Debit Spreads, Long Options.
         
-        STEP 4: Evaluate VIX Context
-        - VIX < 15: Low market fear, stable environment
-        - VIX 15-20: Normal volatility
-        - VIX 20-30: Elevated fear, caution advised
-        - VIX > 30: High fear, extreme volatility
+        STEP 5: Analyze Term Structure (Horizontal/Time Skew)
+        - FRONT IV > BACK IV (Inverted): Potential "Calendar Spread" (Sell Front, Buy Back) if you expect a mean reversion.
+        - BACK IV > FRONT IV (Contango): Standard. Long-dated options are more expensive.
         
-        STEP 5: Determine Volatility Regime (USE 'volatility_regime' from tool)
-        - If LOW_VOL: Buy debit spreads or long options.
-        - If ELEVATED_VOL: Sell credit spreads.
-        - If HIGH_RISK_VOL: Sell Iron Condors or WAIT.
+        STEP 6: Assess "Volatility Squeeze"
+        - If IV is at 52-week lows and HV is dropping: Potential for a volatility breakout. Recommend DEBIT strategies.
         
-        STEP 6: Assess Option Liquidity
-        - Check bid-ask spreads from option chain
-        - Wide spreads (>$0.50) = Poor liquidity, avoid
-        - Tight spreads (<$0.20) = Good liquidity, tradeable
-        
-        STEP 7: Summarize Findings
-        Output:
-        - Volatility Regime classification
-        - IV vs HV comparison
-        - VIX level and interpretation
-        - Liquidity assessment
-        - Recommendation: "Options are EXPENSIVE - favor selling" or "Options are CHEAP - favor buying"
+        STEP 7: Output Structured Summary
+        - BE CONCISE: Use maximum 5 bullet points.
+        - NO conversational filler.
+        - Include: Volatility Regime, IV vs HV status, Term Structure summary, and strategy bias.
         """
     )

src/market-analyst/backend/consistency_test.py

@@ -0,0 +1,121 @@
+import os
+import sys
+import asyncio
+import json
+import time
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+
+# Add path for common and local modules
+current_dir = os.path.dirname(os.path.abspath(__file__))
+repo_root = os.path.abspath(os.path.join(current_dir, "../../../"))
+if repo_root not in sys.path:
+    sys.path.append(repo_root)
+if current_dir not in sys.path:
+    sys.path.append(current_dir)
+
+from common.utility.autogen_model_factory import AutoGenModelFactory
+from teams.team import get_analyst_team, get_decision_team
+
+async def run_analysis(ticker, provider, model_name, run_id):
+    print(f"\n--- STARTING RUN {run_id} [{provider.upper()} - {model_name}] ---", flush=True)
+    start_time = time.time()
+    
+    try:
+        model_client = AutoGenModelFactory.get_model(
+            provider=provider,
+            model_name=model_name,
+            temperature=0
+        )
+    except Exception as e:
+        return {"error": f"Model error: {e}"}
+
+    # PHASE 1
+    print(f"[{run_id}] Phase 1: Data Collection...", end="", flush=True)
+    analyst_team = get_analyst_team(model_client)
+    phase1_task = f"Perform complete analyst data collection for {ticker}."
+    analyst_context = []
+    
+    try:
+        async for message in analyst_team.run_stream(task=phase1_task):
+            source = getattr(message, 'source', 'System')
+            content = getattr(message, 'content', '')
+            if not content or source == 'User': continue
+            if len(str(content)) > 200:
+                analyst_context.append(f"[{source}]: {content}")
+    except Exception as e:
+        return {"error": f"Phase 1 Error: {e}"}
+    print("Done.", flush=True)
+
+    # PHASE 2
+    print(f"[{run_id}] Phase 2: Strategy & Risk...", end="", flush=True)
+    market_context_str = "\n\n".join(analyst_context)
+    decision_team = get_decision_team(model_client)
+    phase2_task = f"ANALYST CONTEXT:\n{market_context_str}\n\nGOAL: Design, critique, and finalize trade for {ticker}. Only the LeadOrchestrator can end the cycle."
+
+    final_json = None
+    last_message = ""
+    try:
+        async for message in decision_team.run_stream(task=phase2_task):
+            content = getattr(message, 'content', '')
+            source = getattr(message, 'source', 'System')
+            if content:
+                last_message = f"[{source}]: {content[:500]}"
+                if "FINAL_STRATEGY:" in str(content) or "ORCHESTRATOR_DECISION: FINAL_APPROVAL" in str(content):
+                    try:
+                        # Search for JSON anywhere in the text
+                        json_pattern = r'\{.*\}'
+                        match = re.search(json_pattern, str(content), re.DOTALL)
+                        if match:
+                             final_json = json.loads(match.group(0))
+                    except:
+                        pass
+    except Exception as e:
+        return {"error": f"Phase 2 Error: {e}"}
+    
+    if not final_json:
+        print(f"DEBUG: No strategy JSON found. Last message preview: {last_message}", flush=True)
+
+    print("Done.", flush=True)
+    
+    elapsed = time.time() - start_time
+    return {
+        "provider": provider,
+        "model": model_name,
+        "time": round(elapsed, 2),
+        "strategy": final_json.get("strategy_type", "N/A") if final_json else "N/A",
+        "direction": final_json.get("direction", "N/A") if final_json else "N/A",
+        "confidence": final_json.get("confidence", 0) if final_json else 0
+    }
+
+async def main():
+    ticker = "META"
+    print(f"=== MULTI-MODEL CONSISTENCY BENCHMARK FOR {ticker} ===")
+    
+    tests = [
+        {"provider": "openai", "model": "gpt-4o", "label": "GPT-4o Run 1"},
+        {"provider": "openai", "model": "gpt-4o", "label": "GPT-4o Run 2"},
+        {"provider": "google", "model": "gemini-2.0-flash", "label": "Gemini 2.0 Flash"}
+    ]
+    
+    results = []
+    for i, test in enumerate(tests):
+        res = await run_analysis(ticker, test["provider"], test["model"], i+1)
+        results.append(res)
+        if "error" in res:
+            print(f"Error in {test['label']}: {res['error']}")
+            
+    print("\n" + "="*60)
+    print(f"{'Run':<5} {'Model':<20} {'Time':<10} {'Strategy':<20} {'Dir':<10}")
+    print("-" * 60)
+    for i, res in enumerate(results):
+        if "error" in res: continue
+        print(f"{i+1:<5} {res['model']:<20} {res['time']:<10} {res['strategy']:<20} {res['direction']:<10}")
+    print("="*60)
+
+if __name__ == "__main__":
+    asyncio.run(main())

src/market-analyst/backend/main.py

@@ -17,7 +17,7 @@ if current_dir not in sys.path:
     sys.path.append(current_dir)
 
 from common.utility.autogen_model_factory import AutoGenModelFactory
-from teams.team import get_trading_team, extract_json
+from teams.team import get_analyst_team, get_decision_team, extract_json
 from tools.news_data import get_sentiment_pipeline
 
 app = FastAPI(title="Market Analyst API")
@@ -35,8 +35,6 @@ active_analyses = {}
 
 @app.on_event("startup")
 async def startup_event():
-    # Warm up the model in a background thread if possible, 
-    # but for now let's just trigger the lazy load.
     print("Warming up FinBERT...")
     get_sentiment_pipeline()
 
@@ -44,12 +42,10 @@ async def startup_event():
 async def health():
     return {"status": "healthy"}
 
-
 @app.post("/cancel/{analysis_id}")
 async def cancel_analysis(analysis_id: str):
-    """Cancel a running analysis."""
     if analysis_id in active_analyses:
-        active_analyses[analysis_id] = True  # Mark as cancelled
+        active_analyses[analysis_id] = True
         return {"status": "cancelled", "analysis_id": analysis_id}
     return {"status": "not_found", "analysis_id": analysis_id}
 
@@ -57,40 +53,9 @@ async def cancel_analysis(analysis_id: str):
 async def analyze(ticker: str, provider: str = "openai"):
     import uuid
     analysis_id = str(uuid.uuid4())
-    active_analyses[analysis_id] = False  # False = not cancelled
+    active_analyses[analysis_id] = False
     
     async def event_generator() -> AsyncGenerator[str, None]:
-        # Guardrail: Check Trading Hours (9:30 AM - 4:00 PM ET, Mon-Fri)
-        guardrail_enabled = os.getenv("MARKET_GUARDRAIL_ON", "true").lower() == "true"
-        
-        if guardrail_enabled:
-            try:
-                from datetime import datetime, time
-                import pytz
-                
-                et_tz = pytz.timezone('US/Eastern')
-                now_et = datetime.now(et_tz)
-                
-                # Check if weekend (Saturday=5, Sunday=6)
-                is_weekend = now_et.weekday() >= 5
-                
-                # Check market hours (09:30 - 16:00)
-                market_open = time(9, 30)
-                market_close = time(16, 0)
-                is_market_hours = market_open <= now_et.time() <= market_close
-                
-                if is_weekend or not is_market_hours:
-                    msg = f"MARKET CLOSED ({now_et.strftime('%I:%M %p')} ET). Analysis requires live data. Please return Mon-Fri, 9:30 AM - 4:00 PM ET.\nSet MARKET_GUARDRAIL_ON=false to bypass."
-                    yield f"data: {json.dumps({'source': 'System', 'content': msg, 'error': msg})}\n\n"
-                    yield "data: [DONE]\n\n"
-                    return
-            except ImportError:
-                print("Warning: pytz not found, skipping market hours check.")
-                pass
-            except Exception as e:
-                print(f"Time check error: {e}")
-            
-        # Setup Model
         if provider == "openai":
             model_name = "gpt-4o"
             family = "gpt"
@@ -98,8 +63,6 @@ async def analyze(ticker: str, provider: str = "openai"):
             model_name = "llama-3.3-70b-versatile"
             family = "groq" 
         elif provider == "google":
-            # Using Gemini Pro for more robust reasoning and 
-            # higher quality decision making across multiple agents.
             model_name = "gemini-pro-latest"
             family = "gemini"
         else:
@@ -107,119 +70,79 @@ async def analyze(ticker: str, provider: str = "openai"):
             family = "gpt"
         
         try:
-            temp = 0
-            # For Non-OpenAI providers, let the factory handle default model_info metadata
-            if provider in ["google", "groq"]:
-                info = None
-            else:
-                info = {"family": family, "vision": False, "function_calling": True, "json_output": True, "structured_output": True}
-            
             model_client = AutoGenModelFactory.get_model(
                 provider=provider,
                 model_name=model_name,
-                temperature=temp,
-                model_info=info
+                temperature=0,
+                model_info={
+                    "family": family, 
+                    "vision": False, 
+                    "function_calling": True, 
+                    "json_output": True, 
+                    "structured_output": True if provider == "openai" else False
+                }
             )
         except Exception as e:
             yield f"data: {json.dumps({'error': f'Model initialization failed: {str(e)}'})}\n\n"
             return
 
-        team = get_trading_team(model_client)
-        task = f"""
-        Perform a professional multi-agent trade analysis for {ticker.upper()}.
-        1. TechnicalAnalyst: Deep chart study, SMA trends, and RSI momentum.
-        2. VolatilityAnalyst: Study IV vs HV, VIX context, and option chain liquidity.
-        3. SentimentAnalyst: News sentiment (Top 5 stories) and market mood.
-        4. FundamentalAnalyst: Check P/E, PEG, and balance sheet health.
-        5. StrategyAdvisor: MUST call get_option_chain_snapshot to get real strikes. Use findings from all analysts to recommend an optimal option spread with SPECIFIC STRIKES AND PRICES.
-        6. RiskManager: Final validation. Output JSON with "final_decision" (TRADE/WAIT), "confidence", and "actionable_recommendation".
-        """
-        
-        # Yield initial status
-        yield f"data: {json.dumps({'source': 'System', 'content': 'Starting sequential analysis for ' + ticker.upper() + '...', 'analysis_id': analysis_id})}\n\n"
+        # PHASE 1: Analysts
+        yield f"data: {json.dumps({'source': 'System', 'content': 'PHASE 1: Starting Data Collection for ' + ticker.upper(), 'analysis_id': analysis_id})}\n\n"
+        analyst_team = get_analyst_team(model_client)
+        phase1_task = f"Perform complete analyst data collection for {ticker.upper()}."
+        analyst_context = []
 
         try:
-            async for message in team.run_stream(task=task):
-                # Check if cancelled
-                if active_analyses.get(analysis_id, False):
-                    yield f"data: {json.dumps({'source': 'System', 'content': 'Analysis cancelled by user.'})}\n\n"
-                    yield "data: [DONE]\n\n"
-                    break
-                
+            async for message in analyst_team.run_stream(task=phase1_task):
+                if active_analyses.get(analysis_id, False): break
                 raw_source = getattr(message, 'source', 'System')
                 content = getattr(message, 'content', '')
-                
-                # Check for tool_calls if content is empty (Explains 0-len messages)
-                if not content:
-                    tool_calls = getattr(message, 'tool_calls', None)
-                    if tool_calls:
-                         content = f"[Tool Call] Executing {len(tool_calls)} function(s)."
-                
-                # Handle non-string content (e.g., ToolCalls/FunctionCalls)
-                if not isinstance(content, str):
-                    try:
-                        content = str(content)
-                    except:
-                        content = "[Complex Content]"
-                
-                if not content and not hasattr(message, 'models_usage'): 
-                    continue
-
-                # Skip echoing the huge prompt task
-                if raw_source.lower() == 'user' and "Perform a professional multi-agent" in content:
-                    continue
-
-                payload = {
-                    "source": raw_source,
-                    "content": content
-                }
-                
-                # If RiskManager, try to extract structured JSON for the frontend
-                if raw_source == 'RiskManager':
-                    structured = extract_json(content)
-                    if structured:
-                        payload["structured_result"] = structured
-
-                print(f"[DEBUG] Sent: {raw_source} (len: {len(content)})")
+                if not content or raw_source == 'User': continue
+                analyst_context.append(f"[{raw_source}]: {content}")
+                yield f"data: {json.dumps({'source': raw_source, 'content': str(content)})}\n\n"
+        except Exception as e:
+            yield f"data: {json.dumps({'source': 'Error', 'content': f'Phase 1 bug: {str(e)}'})}\n\n"
+
+        # PHASE 2: Decision
+        yield f"data: {json.dumps({'source': 'System', 'content': 'PHASE 2: Designing Strategy...'})}\n\n"
+        market_context_str = "\n\n".join(analyst_context)
+        decision_team = get_decision_team(model_client)
+        phase2_task = f"ANALYST CONTEXT:\n{market_context_str}\n\nGOAL: Design, critique, and finalize trade for {ticker}. Only the LeadOrchestrator can end the cycle."
+
+        try:
+            async for message in decision_team.run_stream(task=phase2_task):
+                if active_analyses.get(analysis_id, False): break
+                raw_source = getattr(message, 'source', 'System')
+                content = getattr(message, 'content', '')
+                if not content or (raw_source == 'User' and "ANALYST CONTEXT" in content): continue
+                payload = {"source": raw_source, "content": str(content)}
+                if raw_source in ['RiskManager', 'LeadOrchestrator']:
+                    structured = extract_json(str(content))
+                    if structured: payload["structured_result"] = structured
                 yield f"data: {json.dumps(payload)}\n\n"
         except Exception as e:
-            print(f"[STREAM ERROR] {str(e)}")
-            error_msg = f"Analysis execution failed: {str(e)}"
-            yield f"data: {json.dumps({'source': 'Error', 'content': error_msg})}\n\n"
-            
-        print("[DEBUG] Done.")
-        # Cleanup
-        if analysis_id in active_analyses:
-            del active_analyses[analysis_id]
+            yield f"data: {json.dumps({'source': 'Error', 'content': f'Phase 2 bug: {str(e)}'})}\n\n"
+
+        if analysis_id in active_analyses: del active_analyses[analysis_id]
         yield "data: [DONE]\n\n"
 
     return StreamingResponse(event_generator(), media_type="text/event-stream")
 
-# Serve Frontend Static Files
+# Static mounting logic...
 frontend_dist = os.path.abspath(os.path.join(current_dir, "../frontend/dist"))
-print(f"Checking for frontend at: {frontend_dist}")
-
 if os.path.exists(frontend_dist):
-    # Mount assets folder explicitly
     assets_dir = os.path.join(frontend_dist, "assets")
     if os.path.exists(assets_dir):
         app.mount("/assets", StaticFiles(directory=assets_dir), name="assets")
-    
-    # Serve index.html for the root and any other non-API routes
     from fastapi.responses import FileResponse
     @app.get("/{rest_of_path:path}")
     async def serve_frontend(rest_of_path: str):
-        # If it's a file that exists in dist, serve it
         file_path = os.path.join(frontend_dist, rest_of_path)
-        if os.path.isfile(file_path):
-            return FileResponse(file_path)
-        # Otherwise serve index.html (SPA routing)
+        if os.path.isfile(file_path): return FileResponse(file_path)
         return FileResponse(os.path.join(frontend_dist, "index.html"))
 else:
-    print("WARNING: Frontend dist folder not found!")
     @app.get("/")
-    async def root():
-        return {"message": "Market Analyst API is running. Frontend not built.", "path": frontend_dist}
+    async def root(): return {"message": "API running. Frontend missing."}
 
 if __name__ == "__main__":
     import uvicorn

src/market-analyst/backend/model_test.py

@@ -0,0 +1,27 @@
+import os
+import asyncio
+from dotenv import load_dotenv
+load_dotenv()
+from autogen_ext.models.openai import OpenAIChatCompletionClient
+
+import sys
+current_dir = os.path.dirname(os.path.abspath(__file__))
+repo_root = os.path.abspath(os.path.join(current_dir, "../../../"))
+if repo_root not in sys.path:
+    sys.path.append(repo_root)
+
+async def main():
+    try:
+        from common.utility.autogen_model_factory import AutoGenModelFactory
+        client = AutoGenModelFactory.get_model(provider="openai", model_name="gpt-4o")
+        from autogen_core.models import UserMessage
+        resp = await client.create([UserMessage(content="Say hello", source="user")])
+        print(f"Type: {type(resp)}")
+        print(f"Response: {resp.content}")
+    except Exception as e:
+        import traceback
+        print(f"DEBUG_ERROR: {e}")
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    asyncio.run(main())

src/market-analyst/backend/teams/team.py

@@ -10,8 +10,8 @@ parent_dir = os.path.abspath(os.path.join(current_dir, ".."))
 if parent_dir not in sys.path:
     sys.path.append(parent_dir)
 
-from autogen_agentchat.teams import RoundRobinGroupChat
-from autogen_agentchat.conditions import MaxMessageTermination, TextMentionTermination
+from autogen_agentchat.teams import SelectorGroupChat
+from autogen_agentchat.conditions import MaxMessageTermination, TextMentionTermination, HandoffTermination
 
 # Import agents
 # Adjust imports to work whether called from here or app.py
@@ -22,6 +22,7 @@ try:
     from ..aagents.strategy_advisor import get_strategy_advisor
     from ..aagents.risk_manager import get_risk_manager
     from ..aagents.fundamental_analyst import get_fundamental_analyst
+    from ..aagents.orchestrator import get_lead_orchestrator
 except ImportError:
     try:
         from aagents.market_analyst import get_technical_analyst
@@ -30,6 +31,7 @@ except ImportError:
         from aagents.strategy_advisor import get_strategy_advisor
         from aagents.risk_manager import get_risk_manager
         from aagents.fundamental_analyst import get_fundamental_analyst
+        from aagents.orchestrator import get_lead_orchestrator
     except ImportError:
          # Try absolute (if market-analyst is in path but not as package)
          from src.market_analyst.backend.aagents.market_analyst import get_technical_analyst
@@ -39,23 +41,49 @@ except ImportError:
          from src.market_analyst.backend.aagents.risk_manager import get_risk_manager
          from src.market_analyst.backend.aagents.fundamental_analyst import get_fundamental_analyst
 
-def get_trading_team(model_client):
+from autogen_agentchat.teams import SelectorGroupChat, RoundRobinGroupChat
+
+def get_analyst_team(model_client):
     """
-    Creates and returns the RoundRobinGroupChat team for predictable sequential execution.
+    Team 1: DATA COLLECTORS.
+    Independent analysts gather data and provide a comprehensive market snapshot.
     """
     technical = get_technical_analyst(model_client)
     volatility = get_volatility_analyst(model_client)
     sentiment = get_sentiment_analyst(model_client)
     fundamental = get_fundamental_analyst(model_client)
+
+    return RoundRobinGroupChat(
+        participants=[technical, volatility, sentiment, fundamental],
+        termination_condition=TextMentionTermination("[[DATA_COLLECTION_COMPLETE]]") | MaxMessageTermination(15)
+    )
+
+def get_decision_team(model_client):
+    """
+    Team 2: STRATEGY & RISK.
+    Uses the Analyst Context (Team 1 output) to design, critique, and finalize the trade.
+    """
     strategy = get_strategy_advisor(model_client)
     risk = get_risk_manager(model_client)
+    orchestrator = get_lead_orchestrator(model_client)
 
-    team = RoundRobinGroupChat(
-        participants=[technical, volatility, sentiment, fundamental, strategy, risk],
-        # Increased limit for 2-round detailed discussion
-        termination_condition=TextMentionTermination("APPROVED") | MaxMessageTermination(60)
+    participants = [strategy, risk, orchestrator]
+
+    selector_prompt = """
+    Select the next agent based on the conversation history:
+    - Choose StrategyAdvisor to propose or update the trade.
+    - Choose RiskManager to verify the proposal or critique it.
+    - Choose LeadOrchestrator ONLY if the RiskManager has said "APPROVED" or if the discussion is stuck.
+    
+    Output only the name of the next agent.
+    """
+
+    return SelectorGroupChat(
+        participants=participants,
+        model_client=model_client,
+        termination_condition=TextMentionTermination("[[ANALYSIS_JUDGMENT_COMPLETE]]") | MaxMessageTermination(12),
+        selector_prompt=selector_prompt
     )
-    return team
 
 def extract_json(text: str) -> Dict[str, Any]:
     """
@@ -98,7 +126,9 @@ def validate_and_complete_json(data: Dict[str, Any]) -> Dict[str, Any]:
         "entry_price": 0,
         "max_profit": 0,
         "max_loss": 0,
-        "risk_warning": "Analysis incomplete"
+        "risk_warning": "Analysis incomplete",
+        "expiry_date": "N/A",
+        "legs": []
     }
     
     # Add missing required fields with defaults
@@ -106,4 +136,23 @@ def validate_and_complete_json(data: Dict[str, Any]) -> Dict[str, Any]:
         if field not in data:
             data[field] = default_value
     
+    # Fallback: If expiry_date is "N/A" but we have legs, take it from there
+    if data.get("expiry_date") == "N/A" and data.get("legs"):
+        # Take expiry of first leg
+        data["expiry_date"] = data["legs"][0].get("expiry", "N/A")
+    
+    # Existing Fallback: If expiry_date is still "N/A", try to extract it from context
+    if data.get("expiry_date") == "N/A":
+        # Look for YYYY-MM-DD pattern
+        date_pattern = r'\d{4}-\d{2}-\d{2}'
+        
+        # Check 'actionable_recommendation' or 'reasoning' (if present)
+        for search_field in ["actionable_recommendation", "reasoning", "risk_warning", "proposed_legs"]:
+            field_val = data.get(search_field, "")
+            if isinstance(field_val, str):
+                match = re.search(date_pattern, field_val)
+                if match:
+                    data["expiry_date"] = match.group(0)
+                    break
+                    
     return data

src/market-analyst/backend/test_gemini.py

@@ -0,0 +1,35 @@
+import asyncio
+import os
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+from common.utility.autogen_model_factory import AutoGenModelFactory
+from autogen_agentchat.agents import AssistantAgent
+from autogen_agentchat.teams import SelectorGroupChat
+from autogen_agentchat.conditions import MaxMessageTermination
+
+async def test_gemini_selection():
+    model_client = AutoGenModelFactory.get_model(
+        provider="google",
+        model_name="gemini-2.0-flash",
+        temperature=0
+    )
+    
+    a = AssistantAgent("AgentA", model_client, system_message="User wants to say hi.")
+    b = AssistantAgent("AgentB", model_client, system_message="You say hello back.")
+    
+    team = SelectorGroupChat(
+        [a, b],
+        model_client=model_client,
+        termination_condition=MaxMessageTermination(2),
+        selector_prompt="Select AgentA first, then AgentB."
+    )
+    
+    print("Starting team run...")
+    async for message in team.run_stream(task="Say hello"):
+        print(f"[{getattr(message, 'source', 'System')}] {getattr(message, 'content', '')}")
+
+if __name__ == "__main__":
+    asyncio.run(test_gemini_selection())

src/market-analyst/backend/tools/market_data.py

@@ -3,6 +3,15 @@ import pandas as pd
 import math
 from datetime import datetime, timedelta
 
+def normalize_period(period: str) -> str:
+    """Standardizes period strings for yfinance."""
+    p = period.lower().strip()
+    if p in ["1yr", "1year"]: return "1y"
+    if p in ["3mo", "3month"]: return "3mo"
+    if p in ["1mo", "1month"]: return "1mo"
+    if p in ["1wk", "1week"]: return "1wk"
+    return p
+
 def check_and_fix_ticker(symbol: str) -> str:
     """
     Checks if the ticker has data. If not, tries appending '.NS' (for NSE India).
@@ -59,6 +68,7 @@ def get_historical_volatility(symbol: str, period: str = "1mo") -> dict:
     print(f"[DEBUG] get_historical_volatility called for: {symbol}")
     try:
         symbol = check_and_fix_ticker(symbol)
+        period = normalize_period(period)
         ticker = yf.Ticker(symbol)
         hist = ticker.history(period=period)
         if hist.empty:
@@ -84,11 +94,21 @@ def get_historical_volatility(symbol: str, period: str = "1mo") -> dict:
     except Exception as e:
         return {"error": str(e)}
 
-def get_option_chain_snapshot(symbol: str) -> str:
+def get_available_expirations(symbol: str) -> list:
+    """Returns a list of available option expiration dates."""
+    try:
+        symbol = check_and_fix_ticker(symbol)
+        ticker = yf.Ticker(symbol)
+        return list(ticker.options)
+    except Exception as e:
+        return []
+
+def get_option_chain_snapshot(symbol: str, target_date: str = None) -> str:
     """
-    Fetches a snapshot of the option chain.
+    Fetches a snapshot of the option chain for a specific expiry.
+    If target_date is None, picks the nearest liquid monthly expiry.
     """
-    print(f"[DEBUG] get_option_chain_snapshot called for: {symbol}")
+    print(f"[DEBUG] get_option_chain_snapshot called for: {symbol} (Target: {target_date})")
     try:
         symbol = check_and_fix_ticker(symbol)
         ticker = yf.Ticker(symbol)
@@ -97,19 +117,16 @@ def get_option_chain_snapshot(symbol: str) -> str:
         if not expirations:
             return f"No options data found for {symbol}."
             
-        target_date = None
-        today = datetime.now()
-        
-        for exp in expirations:
-            exp_date = datetime.strptime(exp, "%Y-%m-%d")
-            days_to_exp = (exp_date - today).days
-            # Adjusted window: 7 to 45 days to capture monthly expiries for better liquidity
-            if 7 <= days_to_exp <= 45:
-                target_date = exp
-                break
-        
-        if not target_date:
-            target_date = expirations[0]
+        if not target_date or target_date not in expirations:
+            today = datetime.now()
+            for exp in expirations:
+                exp_date = datetime.strptime(exp, "%Y-%m-%d")
+                days_to_exp = (exp_date - today).days
+                if 7 <= days_to_exp <= 45:
+                    target_date = exp
+                    break
+            if not target_date:
+                target_date = expirations[0]
             
         opt = ticker.option_chain(target_date)
         calls = opt.calls
@@ -119,7 +136,7 @@ def get_option_chain_snapshot(symbol: str) -> str:
         if isinstance(price_info, str): return price_info
         current_price = float(price_info)
         
-        # Filter around ATM for most relevant strikes (closest 6 calls/puts)
+        # Filter around ATM for most relevant strikes
         ntm_calls = calls.iloc[(calls['strike'] - current_price).abs().argsort()[:6]].sort_values('strike')
         ntm_puts = puts.iloc[(puts['strike'] - current_price).abs().argsort()[:6]].sort_values('strike')
         
@@ -131,8 +148,7 @@ def get_option_chain_snapshot(symbol: str) -> str:
             last = row.get('lastPrice', 0.0)
             ask = row.get('ask', 0.0)
             vol = row.get('volume', 0)
-            iv = round(row['impliedVolatility']*100, 1)
-            # Fallback logic for display clarity
+            iv = round(row['impliedVolatility']*100, 1) if not pd.isna(row.get('impliedVolatility')) else 0
             price_display = f"{ask}" if ask > 0 else f"{last} (Last)"
             summary += f"Strike: {row['strike']} | Price: {price_display} | IV: {iv}% | Vol: {vol}\n"
             
@@ -141,8 +157,7 @@ def get_option_chain_snapshot(symbol: str) -> str:
             last = row.get('lastPrice', 0.0)
             ask = row.get('ask', 0.0)
             vol = row.get('volume', 0)
-            iv = round(row['impliedVolatility']*100, 1)
-            # Fallback logic for display clarity
+            iv = round(row['impliedVolatility']*100, 1) if not pd.isna(row.get('impliedVolatility')) else 0
             price_display = f"{ask}" if ask > 0 else f"{last} (Last)"
             summary += f"Strike: {row['strike']} | Price: {price_display} | IV: {iv}% | Vol: {vol}\n"
             
@@ -151,6 +166,49 @@ def get_option_chain_snapshot(symbol: str) -> str:
     except Exception as e:
         return f"Error fetching option chain: {str(e)}"
 
+def get_volatility_term_structure(symbol: str) -> str:
+    """
+    Analyzes IV across multiple expiries to identify Term Structure skew.
+    """
+    print(f"[DEBUG] get_volatility_term_structure called for: {symbol}")
+    try:
+        symbol = check_and_fix_ticker(symbol)
+        ticker = yf.Ticker(symbol)
+        expirations = ticker.options[:4] # Check first 4 expiries
+        
+        if not expirations:
+            return "No options data for volatility analysis."
+            
+        results = []
+        for exp in expirations:
+            opt = ticker.option_chain(exp)
+            # Use mean IV of ATM calls
+            calls = opt.calls
+            price_info = get_current_price(symbol)
+            if isinstance(price_info, str): continue
+            current_price = float(price_info)
+            atm_iv = calls.iloc[(calls['strike'] - current_price).abs().argsort()[:2]]['impliedVolatility'].mean()
+            results.append(f"- {exp}: {round(atm_iv * 100, 1)}% IV")
+            
+        summary = f"VOLATILITY TERM STRUCTURE for {symbol}:\n" + "\n".join(results)
+        
+        # Analyze skew
+        if len(expirations) >= 2:
+            try:
+                iv1 = float(results[0].split(": ")[1].replace("% IV", ""))
+                iv2 = float(results[1].split(": ")[1].replace("% IV", ""))
+                if iv1 > iv2 + 5:
+                    summary += f"\n\nSKEW ALERT: Front-month IV is significantly HIGHER ({iv1}% vs {iv2}%). Potential for Calendar Spreads (Sell Front, Buy Back)."
+                elif iv1 < iv2 - 5:
+                    summary += f"\n\nSKEW ALERT: Front-month IV is significantly LOWER ({iv1}% vs {iv2}%). Diagonal opportunities."
+                else:
+                    summary += f"\n\nTerm Structure is relatively flat."
+            except: pass
+            
+        return summary
+    except Exception as e:
+        return f"Error analyzing term structure: {str(e)}"
+
 def get_market_indices() -> str:
     """
     Fetches current market context using SPY (S&P 500) and ^VIX.

src/market-analyst/backend/tools/pl_calculator.py

@@ -0,0 +1,98 @@
+import math
+from typing import List, Dict, Any
+
+def calculate_strategy_metrics(legs: List[Dict[str, Any]], spot_price: float) -> Dict[str, Any]:
+    """
+    Calculates Max Profit, Max Loss, and Breakeven for a given set of option legs.
+    Leg format: {'action': 'BUY'/'SELL', 'type': 'CALL'/'PUT', 'strike': float, 'price': float, 'expiry': str}
+    """
+    if not legs:
+        return {"max_profit": 0, "max_loss": 0, "breakeven": 0, "net_cost": 0}
+
+    # 1. Calculate Net Debit/Credit
+    net_premium = 0
+    for leg in legs:
+        multiplier = 1 if leg['action'].upper() == 'BUY' else -1
+        net_premium += leg['price'] * multiplier
+    
+    # Positive net_premium = Debit (Paying)
+    # Negative net_premium = Credit (Receiving)
+    is_debit = net_premium > 0
+    net_cost = abs(net_premium) * 100 # Multiplied by contract size
+    
+    # 2. Identify Strategy Type and Calculate Risk
+    leg_count = len(legs)
+    expiries = set(leg['expiry'] for leg in legs)
+    is_multi_expiry = len(expiries) > 1
+    
+    # Sort legs by strike for easier analysis
+    sorted_legs = sorted(legs, key=lambda x: x['strike'])
+    
+    max_profit = 0
+    max_loss = 0
+    
+    if is_multi_expiry:
+        # Complex calculation for Calendars/Diagonals
+        # For simplicity in this version, we provide an ESTIMATE based on premium paid
+        # Usually Max Loss = Net Debit Paid
+        if is_debit:
+            max_loss = net_cost
+            # Max profit is capped by the back-month value at front-month expiration
+            # This is hard to calculate without a model, so we flag it as an estimate
+            max_profit = "Estimated (Limited)" 
+        else:
+            # Net Credit Calendar (Rare/Risky)
+            max_loss = "Unlimited"
+            max_profit = net_cost
+            
+    elif leg_count == 1:
+        # Long/Short Call/Put
+        if legs[0]['action'].upper() == 'BUY':
+            max_loss = net_cost
+            max_profit = "Unlimited"
+        else:
+            max_profit = net_cost
+            max_loss = "Unlimited"
+            
+    elif leg_count == 2:
+        # Spreads (Vertical)
+        s1, s2 = sorted_legs[0]['strike'], sorted_legs[1]['strike']
+        spread_width = (s2 - s1) * 100
+        
+        if is_debit:
+            max_loss = net_cost
+            max_profit = spread_width - net_cost
+        else:
+            max_profit = net_cost
+            max_loss = spread_width - net_cost
+            
+    elif leg_count == 4:
+        # Iron Condor / Iron Butterfly
+        # Max Profit = Net Credit
+        # Max Loss = Width of widest wing - Net Credit
+        if not is_debit:
+            put_spread_width = (sorted_legs[1]['strike'] - sorted_legs[0]['strike']) * 100
+            call_spread_width = (sorted_legs[3]['strike'] - sorted_legs[2]['strike']) * 100
+            widest_wing = max(put_spread_width, call_spread_width)
+            max_profit = net_cost
+            max_loss = widest_wing - net_cost
+        else:
+            # Reverse Iron Condor (Debit)
+            max_loss = net_cost
+            max_profit = max(sorted_legs[1]['strike'] - sorted_legs[0]['strike'], sorted_legs[3]['strike'] - sorted_legs[2]['strike']) * 100 - net_cost
+
+    elif leg_count == 3:
+        # Butterfly / Christmas Tree
+        # S1 (Buy 1), S2 (Sell 2), S3 (Buy 1)
+        if is_debit:
+            wing_width = (sorted_legs[1]['strike'] - sorted_legs[0]['strike']) * 100
+            max_loss = net_cost
+            max_profit = wing_width - net_cost
+
+    return {
+        "max_profit": max_profit,
+        "max_loss": max_loss,
+        "net_premium": round(net_premium, 2),
+        "is_debit": is_debit,
+        "leg_details": [f"{l['action']} {l['type']} {l['strike']} @ {l['price']} (Exp: {l['expiry']})" for l in legs]
+    }

src/market-analyst/backend/verify_e2e.py

@@ -0,0 +1,91 @@
+import os
+import sys
+import asyncio
+import json
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+
+# Add path for common and local modules
+current_dir = os.path.dirname(os.path.abspath(__file__))
+repo_root = os.path.abspath(os.path.join(current_dir, "../../../"))
+if repo_root not in sys.path:
+    sys.path.append(repo_root)
+if current_dir not in sys.path:
+    sys.path.append(current_dir)
+
+from common.utility.autogen_model_factory import AutoGenModelFactory
+from teams.team import get_analyst_team, get_decision_team
+
+async def main():
+    ticker = "MSFT"
+    provider = "openai"
+    import time
+    start_time = time.time()
+    
+    print(f"--- OPTIMIZED PERFORMANCE RUN FOR {ticker} ---", flush=True)
+    
+    try:
+        model_client = AutoGenModelFactory.get_model(
+            provider=provider,
+            model_name="gpt-4o",
+            temperature=0,
+            model_info={"family": "gpt", "vision": False, "function_calling": True, "json_output": True, "structured_output": True}
+        )
+    except Exception as e:
+        print(f"Model error: {e}")
+        return
+
+    # PHASE 1
+    print("\n[PHASE 1: DATA COLLECTION]", flush=True)
+    analyst_team = get_analyst_team(model_client)
+    phase1_task = f"Perform complete analyst data collection for {ticker}."
+    analyst_context = []
+
+    try:
+        async for message in analyst_team.run_stream(task=phase1_task):
+            source = getattr(message, 'source', 'System')
+            content = getattr(message, 'content', '')
+            if not content or source == 'User': continue
+            
+            # Print first 200 chars of each significant report
+            if len(str(content)) > 200:
+                print(f"[{source}] generated a report ({len(str(content))} chars).", flush=True)
+                analyst_context.append(f"[{source}]: {content}")
+            else:
+                # Likely a tool call result or short comment
+                pass
+    except Exception as e:
+        print(f"Phase 1 Error: {e}")
+
+    # PHASE 2
+    print("\n[PHASE 2: STRATEGY & RISK]", flush=True)
+    market_context_str = "\n\n".join(analyst_context)
+    decision_team = get_decision_team(model_client)
+    phase2_task = f"ANALYST CONTEXT:\n{market_context_str}\n\nGOAL: Design, critique, and finalize trade for {ticker}. Only the LeadOrchestrator can end the cycle."
+
+    try:
+        msg_count = 0
+        async for message in decision_team.run_stream(task=phase2_task):
+            source = getattr(message, 'source', 'System')
+            content = getattr(message, 'content', '')
+            if not content or (source == 'User' and "ANALYST CONTEXT" in content): continue
+            
+            msg_count += 1
+            print(f"[{msg_count}] {source}: {str(content)[:150]}...", flush=True)
+            
+            if "[[ANALYSIS_JUDGMENT_COMPLETE]]" in str(content):
+                print("\n--- STABLE TERMINATION DETECTED ---", flush=True)
+                break
+    except Exception as e:
+        print(f"Phase 2 Error: {e}")
+
+    print(f"\n--- PERFORMANCE SUMMARY ---", flush=True)
+    print(f"Total Time: {time.time() - start_time:.2f}s", flush=True)
+    print("--- VERIFICATION COMPLETE ---", flush=True)
+
+if __name__ == "__main__":
+    asyncio.run(main())

src/market-analyst/frontend/src/App.vue

@@ -16,6 +16,7 @@ import {
   TrendingUp,
   XCircle,
   Clock,
+  Calendar,
   Heart,
   Zap,
   LineChart,
@@ -38,7 +39,8 @@ const workflowAgents = [
   { id: 'SentimentAnalyst', name: 'Sentiment', role: 'Evaluates market sentiment from news and monitors earnings risks.' },
   { id: 'FundamentalAnalyst', name: 'Fundamental', role: 'Evaluates Valuation (P/E, PEG), EPS Growth, and Financial Health vs Market Risk.' },
   { id: 'StrategyAdvisor', name: 'Strategy', role: 'Formulates multi-leg option strategies with risk/reward calculation.' },
-  { id: 'RiskManager', name: 'Risk', role: 'Critiques strategy in 2-round debate and issues final governance approval.' }
+  { id: 'RiskManager', name: 'Risk', role: 'Critiques strategy in 2-round debate and performs math verification.' },
+  { id: 'LeadOrchestrator', name: 'Orchestrator', role: 'Central Control. Performs gap analysis, cross-questions agents, and issues final approval.' }
 ]
 
 const providers = [
@@ -55,6 +57,7 @@ const agentIcons = {
   'FundamentalAnalyst': Landmark,
   'StrategyAdvisor': BrainCircuit,
   'RiskManager': ShieldCheck,
+  'LeadOrchestrator': Crown,
   'System': LayoutDashboard,
   'User': Search,
   // Backward compatibility
@@ -69,6 +72,7 @@ const agentColors = {
   'FundamentalAnalyst': '#f59e0b', // Amber
   'StrategyAdvisor': '#8b5cf6', // Purple
   'RiskManager': '#ef4444', // Red
+  'LeadOrchestrator': '#facc15', // Gold
   'System': '#94a3b8', // Slate
   'User': '#60a5fa',  // Light Blue
   'MarketAnalyst': '#3b82f6'
@@ -172,7 +176,11 @@ const analyzeTicker = (symbol) => {
 
   eventSource.onmessage = (event) => {
       if (event.data === '[DONE]') {
-        activeAgent.value = null
+        // Delay clearing active agent so user can see the final Orchestrator state
+        setTimeout(() => {
+            activeAgent.value = null
+        }, 3000)
+
         if (pendingResult.value) {
           results.value.push(pendingResult.value)
           saveToHistory(pendingResult.value) // Save to history
@@ -412,19 +420,26 @@ onMounted(() => {
     </header>
 
     <main class="dashboard-content">
-      <div class="workflow-breadcrumb glass">
-        <div 
-          v-for="agent in workflowAgents" 
-          :key="agent.id" 
-          :class="['breadcrumb-item', { active: activeAgent === agent.id }]"
-          :data-tooltip="agent.role"
-        >
-          <div class="item-icon-wrapper" :style="{ color: getAgentColor(agent.id) }">
-            <component :is="getAgentIcon(agent.id)" :size="14" />
-            <div v-if="activeAgent === agent.id" class="bulb" :style="{ backgroundColor: getAgentColor(agent.id) }"></div>
+      <div class="breadcrumb-container glass">
+        <div class="breadcrumb-label">
+          <Sparkles :size="12" /> 
+          Active Intelligence Pipeline 
+          <span class="legend-text">(Glowing icons indicate agents in action)</span>
+        </div>
+        <div class="workflow-breadcrumb">
+          <div 
+            v-for="(agent, index) in workflowAgents" 
+            :key="agent.id" 
+            :class="['breadcrumb-item', { active: activeAgent === agent.id }]"
+            :data-tooltip="agent.role"
+          >
+            <div class="item-icon-wrapper" :style="{ color: getAgentColor(agent.id) }">
+              <component :is="getAgentIcon(agent.id)" :size="14" />
+              <div v-if="activeAgent === agent.id" class="bulb" :style="{ backgroundColor: getAgentColor(agent.id) }"></div>
+            </div>
+            <span class="item-label">{{ agent.name }}</span>
+            <ChevronRight v-if="index < workflowAgents.length - 1" :size="14" class="separator" />
           </div>
-          <span class="item-label">{{ agent.name }}</span>
-          <ChevronRight v-if="agent.id !== 'RiskManager'" :size="14" class="separator" />
         </div>
       </div>
 
@@ -505,11 +520,52 @@ onMounted(() => {
                         </div>
                         
                         <div class="card-body">
-                            <h4>{{ res.actionable_recommendation }}</h4>
-                            <div v-if="res.entry_price && res.entry_price !== 'N/A'" class="entry-info">
-                                <Clock :size="14" />
-                                <span>Entry Signal: <strong>{{ res.entry_signal }}</strong> at <strong>${{ res.entry_price }}</strong></span>
+                            <h4 class="strat-title">{{ res.strategy_type }}</h4>
+                            
+                            <!-- Strategy Legs Table -->
+                            <div v-if="res.legs && res.legs.length" class="legs-container glass-inset">
+                                <div class="legs-header">Strategy Components</div>
+                                <table class="legs-table">
+                                    <thead>
+                                        <tr>
+                                            <th>Leg</th>
+                                            <th>Type</th>
+                                            <th>Strike</th>
+                                            <th>Expiry</th>
+                                            <th>Price</th>
+                                        </tr>
+                                    </thead>
+                                    <tbody>
+                                        <tr v-for="(leg, idx) in res.legs" :key="idx">
+                                            <td>
+                                                <span class="action-badge" :class="leg.action.toLowerCase()">
+                                                    {{ leg.action }}
+                                                </span>
+                                            </td>
+                                            <td>{{ leg.type }}</td>
+                                            <td><span class="strike-pill">${{ leg.strike }}</span></td>
+                                            <td class="col-expiry">{{ leg.expiry }}</td>
+                                            <td class="col-price">${{ leg.price }}</td>
+                                        </tr>
+                                    </tbody>
+                                </table>
+                            </div>
+
+                            <div class="risk-reward-grid">
+                                <div class="rr-item">
+                                    <span class="rr-label">Max Profit</span>
+                                    <span class="rr-val profit">${{ res.max_profit }}</span>
+                                </div>
+                                <div class="rr-item">
+                                    <span class="rr-label">Max Loss</span>
+                                    <span class="rr-val loss">${{ res.max_loss }}</span>
+                                </div>
+                                <div class="rr-item">
+                                    <span class="rr-label">Entry</span>
+                                    <span class="rr-val">${{ res.entry_price || res.estimated_entry_price }}</span>
+                                </div>
                             </div>
+
                             <p class="risk-info">
                                 <AlertTriangle v-if="res.risk_warning" :size="14" />
                                 {{ res.risk_warning || 'No specific risk warnings identified.' }}
@@ -550,6 +606,7 @@ onMounted(() => {
                         <th>Decision</th>
                         <th class="mobile-hide">Confidence</th>
                         <th class="mobile-hide">Strategy</th>
+                        <th class="mobile-hide">Expiry</th>
                         <th class="mobile-hide">Max Profit</th>
                         <th class="mobile-hide" style="width: 50px"></th>
                     </tr>
@@ -571,6 +628,7 @@ onMounted(() => {
                             </div>
                         </td>
                         <td class="mobile-hide">{{ item.strategy_type }}</td>
+                        <td class="mobile-hide">{{ item.expiry_date || 'N/A' }}</td>
                         <td class="col-profit mobile-hide" :class="{ 'has-profit': item.max_profit > 0 }">
                             {{ item.max_profit ? '$' + item.max_profit : '-' }}
                         </td>
@@ -617,6 +675,10 @@ onMounted(() => {
                     <label>Strategy</label>
                     <span>{{ selectedReport.strategy_type }}</span>
                  </div>
+                 <div class="metric-box">
+                    <label>Expiry</label>
+                    <span>{{ selectedReport.expiry_date || 'N/A' }}</span>
+                 </div>
                  <div class="metric-box">
                     <label>Entry</label>
                     <span>{{ selectedReport.entry_signal }} @ ${{ selectedReport.entry_price || 'N/A' }}</span>
@@ -1210,6 +1272,19 @@ onMounted(() => {
     letter-spacing: 0.1em;
 }
 
+.expiry-badge {
+    padding: 0.25rem 0.5rem;
+    background: rgba(255, 255, 255, 0.1);
+    border-radius: 0.5rem;
+    font-weight: 700;
+    font-size: 0.75rem;
+    color: var(--text-primary);
+    display: flex;
+    align-items: center;
+    gap: 0.4rem;
+    border: 1px solid rgba(255, 255, 255, 0.2);
+}
+
 .pulse-border {
     animation: pulse-border 2s infinite;
 }
@@ -1268,6 +1343,115 @@ onMounted(() => {
   white-space: nowrap;
 }
 
+/* Strategy Legs Table */
+.legs-container {
+    margin: 1.25rem 0;
+    padding: 1rem;
+    border-radius: 0.75rem;
+    background: rgba(255, 255, 255, 0.02);
+    border: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.legs-header {
+    font-size: 0.7rem;
+    font-weight: 800;
+    text-transform: uppercase;
+    color: var(--text-muted);
+    margin-bottom: 0.75rem;
+    letter-spacing: 0.05em;
+    display: flex;
+    justify-content: space-between;
+}
+
+.legs-table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 0.85rem;
+}
+
+.legs-table th {
+    text-align: left;
+    padding: 0.5rem;
+    color: var(--text-secondary);
+    font-weight: 600;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.legs-table td {
+    padding: 0.6rem 0.5rem;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.action-badge {
+    padding: 0.15rem 0.4rem;
+    border-radius: 0.25rem;
+    font-size: 0.7rem;
+    font-weight: 800;
+}
+
+.action-badge.buy { background: rgba(16, 185, 129, 0.15); color: var(--success); }
+.action-badge.sell { background: rgba(239, 68, 68, 0.15); color: var(--danger); }
+
+.strike-pill {
+    font-weight: 700;
+    color: var(--text-primary);
+}
+
+.col-expiry {
+    font-size: 0.75rem;
+    color: var(--text-secondary);
+}
+
+.col-price {
+    font-weight: 600;
+    color: var(--accent-primary);
+}
+
+.risk-reward-grid {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    gap: 0.75rem;
+    margin: 1rem 0;
+}
+
+.rr-item {
+    padding: 0.75rem;
+    background: rgba(255, 255, 255, 0.03);
+    border-radius: 0.5rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+    border: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.rr-label {
+    font-size: 0.65rem;
+    font-weight: 700;
+    color: var(--text-muted);
+    text-transform: uppercase;
+}
+
+.rr-val {
+    font-size: 1.1rem;
+    font-weight: 800;
+}
+
+.rr-val.profit { color: var(--success); }
+.rr-val.loss { color: var(--danger); }
+
+.strat-title {
+    margin-bottom: 0.5rem;
+    color: var(--accent-primary);
+    font-weight: 800;
+}
+
+.strat-reasoning {
+    font-size: 0.95rem;
+    line-height: 1.5;
+    color: var(--text-secondary);
+    margin-bottom: 1rem;
+}
+
 @media (max-width: 1024px) {
   .footer-content {
     flex-direction: column;
@@ -1287,6 +1471,32 @@ onMounted(() => {
   z-index: 50; /* Ensure tooltips appear above content below */
 }
 
+.breadcrumb-label {
+    text-align: center;
+    font-size: 0.65rem;
+    font-weight: 800;
+    text-transform: uppercase;
+    color: var(--text-muted);
+    letter-spacing: 0.1em;
+    margin-top: 0.5rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.4rem;
+    opacity: 0.7;
+}
+
+.legend-text {
+    font-size: 0.6rem;
+    color: var(--accent-primary);
+    text-transform: none;
+    letter-spacing: normal;
+    margin-left: 0.5rem;
+    font-weight: 500;
+    font-style: italic;
+    opacity: 0.9;
+}
+
 .breadcrumb-item {
   display: flex;
   align-items: center;