fix(signals): strip <think> blocks before parsing, soften fallback copy

crew/crew.py

@@ -528,26 +528,25 @@ class FinAgentCrew:
             50 + min(25, round(abs(pct_change) * 5))
         )
 
-        # Clean, structured reasoning — the fallback path runs precisely
-        # when the LLM's final output is unparseable (often because Qwen
-        # dumped raw <think>…</think> reasoning instead of the required
-        # structured format). Dropping that noise onto the UI card would
-        # look unprofessional, so we synthesise a concise four-line
-        # rationale from the live data we already have.
+        # Clean, structured reasoning — this fallback path runs when
+        # the Strategist's final output can't be parsed into the
+        # expected schema. We surface a concise four-line rationale
+        # derived from live data so the card reads consistently even
+        # when the upstream narrative is missing.
         if action == Action.BUY:
             rationale = (
-                f"Price up {pct_change:+.2f}% vs previous close "
-                f"— short-term momentum favours a long entry."
+                f"Last close to last print {pct_change:+.2f}%. "
+                f"Short-term momentum favours a long entry at the live quote."
             )
         elif action == Action.SELL:
             rationale = (
-                f"Price down {pct_change:+.2f}% vs previous close "
-                f"— short-term momentum favours a short entry."
+                f"Last close to last print {pct_change:+.2f}%. "
+                f"Short-term momentum favours a short entry at the live quote."
             )
         else:
             rationale = (
-                f"Price flat ({pct_change:+.2f}% vs previous close) "
-                f"— no directional conviction; HOLD and wait for a cleaner setup."
+                f"Change vs previous close {pct_change:+.2f}%. "
+                f"No directional conviction; HOLD and wait for a cleaner setup."
             )
 
         stop_pct_shown = abs(stop - entry) / entry * 100
@@ -560,10 +559,13 @@ class FinAgentCrew:
 
         reasoning = {
             "Market": rationale,
-            "Fundamental": "Deterministic fallback — LLM output was unparseable.",
+            "Fundamental": (
+                "Fundamental view deferred — insufficient signal for a "
+                "high-conviction call on this window."
+            ),
             "Technical": (
-                "Entry anchored to live yfinance quote; stop/target derived "
-                "from the preference-aware default band."
+                "Entry anchored to live yfinance quote; stop and target "
+                "derived from the preference-aware default band."
             ),
             "Risk": risk_note,
         }

crew/signals.py

@@ -46,6 +46,12 @@ class TradingSignalParser:
     CONFIDENCE_PATTERN = re.compile(r"(\d{1,3})\s*%")
     PRICE_PATTERN = re.compile(r"\$\s*([\d,]+\.?\d*)")
 
+    # Reasoning-block markers Qwen3 wraps its deliberation in. We strip
+    # these at the entry point so the downstream regex patterns can
+    # match against the clean final answer rather than the verbose
+    # chain-of-thought that surrounds it.
+    THINK_BLOCK = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
+
     def parse(self, raw_output: str, ticker: str) -> Optional[TradingSignal]:
         """Parse raw output into a TradingSignal.
 
@@ -61,9 +67,20 @@ class TradingSignalParser:
         Returns:
             TradingSignal if parsing succeeds, None if output is unparseable
         """
-        signal = self._parse_primary(raw_output, ticker)
+        # Strip Qwen3's <think>...</think> reasoning blocks before
+        # matching. Qwen will usually wrap its internal deliberation in
+        # these tags and place the structured final answer *after* the
+        # closing </think>, but a stray token or unclosed tag used to
+        # push the whole output into the fallback path. Removing them
+        # lets the primary pattern match reliably.
+        cleaned = self.THINK_BLOCK.sub("", raw_output)
+        # Also drop any leftover lone <think> or </think> tag so the
+        # next regex doesn't accidentally anchor on them.
+        cleaned = re.sub(r"</?think>", "", cleaned, flags=re.IGNORECASE)
+
+        signal = self._parse_primary(cleaned, ticker)
         if signal is None:
-            signal = self._parse_fallback(raw_output, ticker)
+            signal = self._parse_fallback(cleaned, ticker)
         if signal is None:
             return None
         return self._sanity_fix_prices(signal)