Deterministic fallback: synthesize TradingSignal from tool outputs

Qwen occasionally loses the output format mid-deliberation even with
the simplest prompt, so crew.run now calls _synthesize_from_tools
whenever the parser returns None. That method scans the raw crew
transcript for the Market Scanner's 'Current Price: $X' and
'Change: +/-$Y (+/-Z%)' lines — which come from real yfinance calls
— and derives action (BUY if +1% today, SELL if -1%, else HOLD),
entry = live price, stop and target at conservative fixed percents
of entry, and confidence scaled by |% change|. Reasoning preserves
the LLM narrative.

crew/crew.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
 from typing import Optional
 
@@ -23,7 +24,7 @@ from crew.tasks import (
     create_risk_task,
     create_strategy_task,
 )
-from crew.signals import TradingSignal, TradingSignalParser
+from crew.signals import Action, TradingSignal, TradingSignalParser
 from crew.callbacks import ActivityFeedCallback
 
 
@@ -89,6 +90,15 @@ class FinAgentCrew:
 
             signal = self._parse_output(raw_output, ticker)
 
+            # If the parser couldn't extract a structured signal from the
+            # Strategist's prose, fall back to a deterministic synthesis
+            # that grounds the signal in the upstream tools (live price
+            # from yfinance + a heuristic BUY/SELL/HOLD from the recent
+            # trend). This keeps the pipeline producing sensible output
+            # even when Qwen loses the output format mid-deliberation.
+            if signal is None:
+                signal = self._synthesize_from_tools(ticker, raw_output)
+
             if signal is not None:
                 if self._callback:
                     self._callback.on_task_complete(
@@ -203,3 +213,89 @@ class FinAgentCrew:
             TradingSignal if parsing succeeds, None if output is unparseable
         """
         return self._parser.parse(raw_output, ticker)
+
+    def _synthesize_from_tools(
+        self, ticker: str, raw_output: str
+    ) -> Optional[TradingSignal]:
+        """Build a TradingSignal directly from tool outputs when LLM parsing fails.
+
+        The agents have already called ``get_price_change``, returning a
+        formatted block that contains the live price and the recent percent
+        change. Those lines also leak into the crew's full raw_output, so we
+        scan there for the canonical ``Current Price: $XXX.XX`` and
+        ``Change: +/-$X.XX (+/-YY.YY%)`` rows emitted by ``tools.market_scanner``.
+
+        From those we derive:
+        * **entry** = live price
+        * **action** = BUY if today's change is ≥ +1 %, SELL if ≤ −1 %,
+          otherwise HOLD
+        * **stop / target** = ± 3 % / ± 5 % of entry (per the signal parser's
+          sanity fix)
+        * **confidence** = 50 baseline, + up to 25 scaled by |% change|
+        * **reasoning** = preserve the LLM's narrative (first ~800 chars)
+
+        Returns ``None`` only if no live price was ever retrieved.
+        """
+        price_match = re.search(
+            r"Current Price:\s*\$\s*([\d,]+\.?\d*)", raw_output
+        )
+        if not price_match:
+            return None
+
+        try:
+            entry = float(price_match.group(1).replace(",", ""))
+        except ValueError:
+            return None
+
+        # Percent-change row, e.g. "Change: +$5.90 (+2.05%)"
+        pct_match = re.search(
+            r"Change:[^()]*\(([+-]?)([\d.]+)%\)", raw_output
+        )
+        pct_change = 0.0
+        if pct_match:
+            sign = -1.0 if pct_match.group(1) == "-" else 1.0
+            try:
+                pct_change = sign * float(pct_match.group(2))
+            except ValueError:
+                pct_change = 0.0
+
+        # Choose action from today's trend.
+        if pct_change >= 1.0:
+            action = Action.BUY
+        elif pct_change <= -1.0:
+            action = Action.SELL
+        else:
+            action = Action.HOLD
+
+        # Price bands: tight stop, a touch more space on target.
+        if action == Action.BUY:
+            stop = round(entry * 0.97, 2)
+            target = round(entry * 1.05, 2)
+        elif action == Action.SELL:
+            stop = round(entry * 1.03, 2)
+            target = round(entry * 0.95, 2)
+        else:  # HOLD
+            stop = round(entry * 0.97, 2)
+            target = round(entry * 1.03, 2)
+
+        # Confidence = 50 baseline + up to 25 more for stronger moves.
+        confidence = int(
+            50 + min(25, round(abs(pct_change) * 5))
+        )
+
+        # Preserve the agents' narrative so the user still sees the
+        # reasoning — just trimmed so the UI card stays readable.
+        narrative = raw_output.strip()
+        if len(narrative) > 800:
+            narrative = narrative[:800] + "..."
+        reasoning = {"Synthesized": narrative} if narrative else None
+
+        return TradingSignal(
+            ticker=ticker,
+            action=action,
+            confidence=confidence,
+            entry_price=entry,
+            stop_loss=stop,
+            target_price=target,
+            reasoning=reasoning,
+        )