feat(prefs): risk tolerance + trading style now shape the signal

app.py

@@ -196,6 +196,7 @@ def run_analysis(
         from crew import (
             LLMConfig,
             OrchestratorConfig,
+            TradePreferences,
             WatchlistRunner,
         )
         from crew.callbacks import ActivityEvent, ActivityFeedCallback, EventType
@@ -205,6 +206,12 @@ def run_analysis(
             llm=LLMConfig(base_url=VLLM_ENDPOINT_URL),
         )
 
+        preferences = TradePreferences(
+            risk_tolerance=risk_tolerance,
+            trading_style=trading_style,
+            portfolio_value=float(portfolio_value),
+        )
+
         # Buffer events emitted by the runner/crew during ``_run_single``.
         # The callback handler runs synchronously on the same thread, so
         # a plain list plus a closure is sufficient — we drain it into
@@ -219,9 +226,7 @@ def run_analysis(
         # Build the tools dict that maps each agent's name to its tool
         # function list. Without this, every agent runs without tools
         # and the LLM just hallucinates plausible-looking numbers
-        # instead of calling yfinance / ddgs / pandas-ta. (This was the
-        # cause of the "AAPL entry $192" hallucination from the first
-        # deploy — real AAPL was ~$293 at the time.)
+        # instead of calling yfinance / ddgs / pandas-ta.
         from tools import (
             search_news,
             get_price_change,
@@ -243,7 +248,10 @@ def run_analysis(
         }
 
         runner = WatchlistRunner(
-            config=config, tools=crew_tools, callback=callback
+            config=config,
+            tools=crew_tools,
+            callback=callback,
+            preferences=preferences,
         )
 
         for i, ticker in enumerate(tickers, 1):

crew/__init__.py

@@ -5,7 +5,7 @@ tickers and produce structured trading signals (BUY/SELL/HOLD).
 """
 
 from crew.callbacks import ActivityEvent, ActivityFeedCallback, EventType
-from crew.config import CrewConfig, LLMConfig, OrchestratorConfig
+from crew.config import CrewConfig, LLMConfig, OrchestratorConfig, TradePreferences
 from crew.crew import CrewResult, FinAgentCrew
 from crew.runner import WatchlistResult, WatchlistRunner
 from crew.signals import Action, TradingSignal
@@ -20,6 +20,7 @@ __all__ = [
     "FinAgentCrew",
     "LLMConfig",
     "OrchestratorConfig",
+    "TradePreferences",
     "TradingSignal",
     "WatchlistResult",
     "WatchlistRunner",

crew/config.py

@@ -1,6 +1,57 @@
 """LLM configuration, timeouts, and constants for the orchestration layer."""
 
 from dataclasses import dataclass, field
+from typing import Literal
+
+
+RiskTolerance = Literal["Conservative", "Moderate", "Aggressive"]
+TradingStyle = Literal["Day Trading", "Swing Trading", "Position Trading"]
+
+
+@dataclass(frozen=True)
+class TradePreferences:
+    """User-selected risk / style / portfolio preferences.
+
+    These come from the Gradio UI dropdowns and are threaded end-to-end
+    into the Chief Strategist's task description so the final signal
+    reflects the user's stated profile. They also tune the re-ground
+    clamps in :class:`FinAgentCrew` — Conservative + Day Trading pushes
+    stop / target toward tight, short-horizon bands; Aggressive +
+    Position Trading opens them up.
+
+    Numbers here are percentages of entry (0.03 == 3 %).
+    """
+
+    risk_tolerance: RiskTolerance = "Moderate"
+    trading_style: TradingStyle = "Swing Trading"
+    portfolio_value: float = 10000.0
+
+    @property
+    def stop_pct(self) -> float:
+        return {
+            "Conservative": 0.015,
+            "Moderate": 0.03,
+            "Aggressive": 0.05,
+        }[self.risk_tolerance]
+
+    @property
+    def target_pct(self) -> float:
+        return {
+            "Day Trading": 0.02,
+            "Swing Trading": 0.05,
+            "Position Trading": 0.10,
+        }[self.trading_style]
+
+    @property
+    def stop_clamp(self) -> float:
+        """Upper bound used by _reground_if_drifted. Slightly looser than
+        ``stop_pct`` so the LLM has headroom, but tight enough to catch
+        the wide ATR-style stops Qwen sometimes emits."""
+        return self.stop_pct * 2.5
+
+    @property
+    def target_clamp(self) -> float:
+        return self.target_pct * 3.0
 
 
 @dataclass

crew/crew.py

@@ -8,7 +8,7 @@ from typing import Optional
 
 from crewai import Crew, Process
 
-from crew.config import OrchestratorConfig
+from crew.config import OrchestratorConfig, TradePreferences
 from crew.agents import (
     create_llm,
     create_market_scanner,
@@ -47,6 +47,7 @@ class FinAgentCrew:
         config: OrchestratorConfig,
         tools: dict[str, list],
         callback: Optional[ActivityFeedCallback] = None,
+        preferences: Optional[TradePreferences] = None,
     ):
         """Initialize the crew orchestrator.
 
@@ -60,10 +61,14 @@ class FinAgentCrew:
                     "risk_manager": [calculate_position_size, set_stop_loss],
                 }
             callback: Optional activity feed callback for real-time UI updates
+            preferences: User trading preferences that shape the final
+                signal's stop / target bands. Defaults to Moderate /
+                Swing Trading / $10k when not supplied.
         """
         self._config = config
         self._tools = tools
         self._callback = callback
+        self._preferences = preferences or TradePreferences()
         self._parser = TradingSignalParser()
 
     def run(self, ticker: str) -> CrewResult:
@@ -180,11 +185,14 @@ class FinAgentCrew:
         market_task = create_market_scan_task(market_scanner, ticker)
         fundamental_task = create_fundamental_task(fundamental_analyst, ticker)
         technical_task = create_technical_task(technical_analyst, ticker)
-        risk_task = create_risk_task(risk_manager, ticker, [technical_task])
+        risk_task = create_risk_task(
+            risk_manager, ticker, [technical_task], self._preferences
+        )
         strategy_task = create_strategy_task(
             chief_strategist,
             ticker,
             [market_task, fundamental_task, technical_task, risk_task],
+            self._preferences,
         )
 
         return Crew(
@@ -324,20 +332,23 @@ class FinAgentCrew:
         new_target = None if _bad(target) else round(target * scale, 2)
 
         # Extra guard: after rescaling, stop / target should still be
-        # within a reasonable band of the new entry. Stops must stay
-        # tight (<= 8 %) so the R:R remains sane for a retail card;
-        # targets can be more ambitious (<= 15 %). If the LLM emitted
-        # something implausibly wide we let the back-fill replace it
-        # with the default 3 % / 5 % band.
+        # within a reasonable band of the new entry. Bounds come from
+        # the user's preferences — Conservative / Day Trading locks
+        # everything down tight, Aggressive / Position Trading opens
+        # it up. If the LLM emitted something implausibly wide we let
+        # the back-fill replace it with the profile default band.
+        stop_clamp = self._preferences.stop_clamp
+        target_clamp = self._preferences.target_clamp
+
         def _stop_unreasonable(v: Optional[float]) -> bool:
             if v is None:
                 return True
-            return abs(v - live_entry) / live_entry > 0.08
+            return abs(v - live_entry) / live_entry > stop_clamp
 
         def _target_unreasonable(v: Optional[float]) -> bool:
             if v is None:
                 return True
-            return abs(v - live_entry) / live_entry > 0.15
+            return abs(v - live_entry) / live_entry > target_clamp
 
         if _stop_unreasonable(new_stop):
             new_stop = None
@@ -355,12 +366,14 @@ class FinAgentCrew:
         )
         return self._backfill_missing_prices(rescaled)
 
-    @staticmethod
-    def _backfill_missing_prices(signal: TradingSignal) -> TradingSignal:
+    def _backfill_missing_prices(self, signal: TradingSignal) -> TradingSignal:
         """Back-fill stop-loss and target when the LLM emitted N/A or omitted them.
 
         This ensures the UI card always shows three numeric prices rather
-        than a mix of numbers and N/A placeholders.
+        than a mix of numbers and N/A placeholders. The band widths come
+        from the user's :class:`TradePreferences` so Conservative / Day
+        Trading produces tight short-horizon numbers and Aggressive /
+        Position Trading produces wider longer-horizon numbers.
         """
         entry = signal.entry_price
         if entry is None or entry <= 0:
@@ -368,22 +381,29 @@ class FinAgentCrew:
 
         stop = signal.stop_loss
         target = signal.target_price
+        stop_pct = self._preferences.stop_pct
+        target_pct = self._preferences.target_pct
+        # HOLD cards use a half-width band so the card still renders
+        # with numeric stop / target without implying a directional
+        # trade the Strategist wasn't making.
+        hold_stop_pct = max(0.015, stop_pct * 0.5)
+        hold_target_pct = max(0.02, target_pct * 0.5)
 
         if stop is None or stop <= 0:
             if signal.action == Action.BUY:
-                stop = round(entry * 0.97, 2)
+                stop = round(entry * (1 - stop_pct), 2)
             elif signal.action == Action.SELL:
-                stop = round(entry * 1.03, 2)
+                stop = round(entry * (1 + stop_pct), 2)
             else:  # HOLD
-                stop = round(entry * 0.97, 2)
+                stop = round(entry * (1 - hold_stop_pct), 2)
 
         if target is None or target <= 0:
             if signal.action == Action.BUY:
-                target = round(entry * 1.05, 2)
+                target = round(entry * (1 + target_pct), 2)
             elif signal.action == Action.SELL:
-                target = round(entry * 0.95, 2)
+                target = round(entry * (1 - target_pct), 2)
             else:  # HOLD
-                target = round(entry * 1.03, 2)
+                target = round(entry * (1 + hold_target_pct), 2)
 
         return TradingSignal(
             ticker=signal.ticker,
@@ -487,16 +507,21 @@ class FinAgentCrew:
         else:
             action = Action.HOLD
 
-        # Price bands: tight stop, a touch more space on target.
+        # Price bands derived from user preferences.
+        stop_pct = self._preferences.stop_pct
+        target_pct = self._preferences.target_pct
+        hold_stop_pct = max(0.015, stop_pct * 0.5)
+        hold_target_pct = max(0.02, target_pct * 0.5)
+
         if action == Action.BUY:
-            stop = round(entry * 0.97, 2)
-            target = round(entry * 1.05, 2)
+            stop = round(entry * (1 - stop_pct), 2)
+            target = round(entry * (1 + target_pct), 2)
         elif action == Action.SELL:
-            stop = round(entry * 1.03, 2)
-            target = round(entry * 0.95, 2)
+            stop = round(entry * (1 + stop_pct), 2)
+            target = round(entry * (1 - target_pct), 2)
         else:  # HOLD
-            stop = round(entry * 0.97, 2)
-            target = round(entry * 1.03, 2)
+            stop = round(entry * (1 - hold_stop_pct), 2)
+            target = round(entry * (1 + hold_target_pct), 2)
 
         # Confidence = 50 baseline + up to 25 more for stronger moves.
         confidence = int(

crew/runner.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Optional
 
-from crew.config import OrchestratorConfig
+from crew.config import OrchestratorConfig, TradePreferences
 from crew.crew import CrewResult, FinAgentCrew
 from crew.callbacks import ActivityFeedCallback
 
@@ -28,10 +28,12 @@ class WatchlistRunner:
         config: OrchestratorConfig,
         tools: dict[str, list],
         callback: Optional[ActivityFeedCallback] = None,
+        preferences: Optional[TradePreferences] = None,
     ):
         self._config = config
         self._tools = tools
         self._callback = callback
+        self._preferences = preferences or TradePreferences()
 
     def run(self, watchlist: str) -> WatchlistResult:
         """Parse the watchlist and run the analysis pipeline for each ticker.
@@ -100,6 +102,7 @@ class WatchlistRunner:
                 config=self._config,
                 tools=self._tools,
                 callback=self._callback,
+                preferences=self._preferences,
             )
             return crew.run(ticker)
         except Exception as e:

crew/tasks.py

@@ -1,7 +1,11 @@
 """Task factory functions with dependencies for CrewAI Task instances."""
 
+from typing import Optional
+
 from crewai import Task, Agent
 
+from crew.config import TradePreferences
+
 
 def create_market_scan_task(agent: Agent, ticker: str) -> Task:
     """Create the market scanning task."""
@@ -56,19 +60,36 @@ def create_technical_task(agent: Agent, ticker: str) -> Task:
     )
 
 
-def create_risk_task(agent: Agent, ticker: str, context: list) -> Task:
+def create_risk_task(
+    agent: Agent,
+    ticker: str,
+    context: list,
+    preferences: Optional[TradePreferences] = None,
+) -> Task:
     """Create the risk assessment task.
 
     Args:
         agent: Risk Manager agent
         ticker: Stock symbol
         context: [technical_task] — depends on Technical Analyst output
+        preferences: User preferences so the risk assessment matches the
+            investor's profile (portfolio size, risk appetite).
     """
+    prefs = preferences or TradePreferences()
+    stop_target_pct = int(round(prefs.stop_pct * 100))
+    target_target_pct = int(round(prefs.target_pct * 100))
+
     return Task(
         description=(
             f"Calculate position sizing and stop-loss levels for {ticker}. "
             f"Use the entry price from the Technical Analyst's recommendation "
-            f"to determine optimal position size and ATR-based stop-loss."
+            f"to determine optimal position size and ATR-based stop-loss.\n\n"
+            f"The user's profile:\n"
+            f"- Risk tolerance: {prefs.risk_tolerance} "
+            f"(target stop-loss distance ~{stop_target_pct}% from entry)\n"
+            f"- Trading style: {prefs.trading_style} "
+            f"(target profit distance ~{target_target_pct}% from entry)\n"
+            f"- Portfolio value: ${prefs.portfolio_value:,.0f}\n"
         ),
         expected_output=(
             f"Risk parameters for {ticker} including: "
@@ -80,20 +101,40 @@ def create_risk_task(agent: Agent, ticker: str, context: list) -> Task:
     )
 
 
-def create_strategy_task(agent: Agent, ticker: str, context: list) -> Task:
-    """Create the strategy synthesis task.
+def create_strategy_task(
+    agent: Agent,
+    ticker: str,
+    context: list,
+    preferences: Optional[TradePreferences] = None,
+) -> Task:
+    r"""Create the strategy synthesis task.
 
     Args:
         agent: Chief Strategist agent
         ticker: Stock symbol
         context: [market_task, fundamental_task, technical_task, risk_task]
+        preferences: User preferences that shape the final signal's
+            stop / target distances and horizon. When ``None``, falls
+            back to a Moderate / Swing Trading / \$10k profile.
     """
+    prefs = preferences or TradePreferences()
+    stop_pct = int(round(prefs.stop_pct * 100))
+    target_pct = int(round(prefs.target_pct * 100))
+
     return Task(
         description=(
-            f"Synthesize all analysis for {ticker} into a final trading signal. "
-            f"Use the current price reported by get_price_change as Entry. "
-            f"For BUY: Stop Loss below Entry, Target above Entry (within 5%). "
-            f"For SELL: Stop Loss above Entry, Target below Entry (within 5%). "
+            f"Synthesize all analysis for {ticker} into a final trading "
+            f"signal for a **{prefs.risk_tolerance} "
+            f"{prefs.trading_style}** investor "
+            f"with a ${prefs.portfolio_value:,.0f} portfolio.\n\n"
+            f"Use the current price reported by get_price_change as Entry.\n"
+            f"Profile-specific stop / target distances:\n"
+            f"- Stop Loss: approximately {stop_pct}% from Entry "
+            f"(tighter for Conservative, wider for Aggressive)\n"
+            f"- Target: approximately {target_pct}% from Entry "
+            f"(smaller for Day Trading, larger for Position Trading)\n\n"
+            f"For BUY: Stop Loss below Entry, Target above Entry.\n"
+            f"For SELL: Stop Loss above Entry, Target below Entry.\n"
             f"Keep the response concise — do not deliberate at length.\n\n"
             f"Output EXACTLY this format on its own lines, with NO extra prose:\n"
             f"{ticker} — BUY (Confidence: 75%)\n"