Re-ground parsed signals when entry drifts from live price; back-fill HOLD N/A

Two remaining failure modes from the live Space:

1. NVDA returned BUY at $10 (with stop $9.70 / target $10.50) because
Qwen3-14B hallucinated small fake numbers that satisfied the BUY
inequality but had nothing to do with the real $215 price. The
parser happily accepted them.

2. BTC-USD HOLD card rendered with 'N/A' for stop and target because
the LLM wrote 'Stop Loss: N/A' literally.

Fix: after the primary parser succeeds, call get_price_change directly
and compare the parsed entry to the live price. If the drift exceeds
30 %, swap the whole signal with the deterministic synthesis. Also
back-fill any missing stop/target (particularly on HOLD) with the
standard ±3–5 % bands so every card shows three concrete prices.

crew/crew.py

@@ -98,6 +98,15 @@ class FinAgentCrew:
             # even when Qwen loses the output format mid-deliberation.
             if signal is None:
                 signal = self._synthesize_from_tools(ticker, raw_output)
+            else:
+                # Cross-check the parsed entry against the live tool
+                # price. Small LLMs occasionally emit completely
+                # fabricated prices (e.g. $10.00 for a $215 stock) that
+                # happen to pass the relative-ordering sanity check
+                # because stop/target are on the right side of entry.
+                # Re-synthesize from tools whenever the parsed entry is
+                # wildly off from reality.
+                signal = self._reground_if_drifted(ticker, signal, raw_output)
 
             if signal is not None:
                 if self._callback:
@@ -214,6 +223,117 @@ class FinAgentCrew:
         """
         return self._parser.parse(raw_output, ticker)
 
+    def _reground_if_drifted(
+        self,
+        ticker: str,
+        signal: TradingSignal,
+        raw_output: str,
+    ) -> TradingSignal:
+        """Swap out a parsed signal whose entry is wildly off the live price.
+
+        Qwen3-14B occasionally invents prices at synthesis time that happen
+        to satisfy the BUY/SELL inequalities — e.g. returning a \$10.00
+        entry for NVDA on a day it traded at \$215. Those pass the parser
+        but mislead the user. We fetch the live price via
+        :func:`get_price_change` and, if the parsed entry differs by more
+        than 30 %, replace the whole signal with the deterministic
+        synthesis from :meth:`_synthesize_from_tools`. If the entry is in
+        range we also back-fill any missing stop/target so HOLD cards
+        render with real numbers instead of N/A.
+        """
+        parsed_entry = signal.entry_price
+
+        # Get the live price (best-effort; don't block on tool errors).
+        live_entry: Optional[float] = None
+        try:
+            market_tools = self._tools.get("market_scanner", [])
+            price_tool = next(
+                (t for t in market_tools
+                 if getattr(t, "name", "") == "Get Price Change"),
+                None,
+            )
+            if price_tool is not None:
+                price_fn = getattr(price_tool, "func", price_tool)
+                result = str(price_fn(ticker))
+                m = re.search(
+                    r"Current Price:\s*\$\s*([\d,]+\.?\d*)", result
+                )
+                if m:
+                    live_entry = float(m.group(1).replace(",", ""))
+        except Exception:
+            live_entry = None
+
+        # If we couldn't fetch a live price, leave the signal as-is —
+        # the sanity-fix already clamped relative ordering.
+        if live_entry is None or live_entry <= 0:
+            return self._backfill_missing_prices(signal)
+
+        # If the parsed entry is missing or drifts by more than 30 %,
+        # replace with the deterministic synthesis.
+        drifted = (
+            parsed_entry is None
+            or parsed_entry <= 0
+            or abs(parsed_entry - live_entry) / live_entry > 0.30
+        )
+        if drifted:
+            synthesized = self._synthesize_from_tools(ticker, raw_output)
+            if synthesized is not None:
+                return synthesized
+            # If synthesis failed too, at least swap the entry.
+            return TradingSignal(
+                ticker=signal.ticker,
+                action=signal.action,
+                confidence=signal.confidence,
+                entry_price=live_entry,
+                stop_loss=signal.stop_loss,
+                target_price=signal.target_price,
+                reasoning=signal.reasoning,
+            )
+
+        # Parsed entry is close to live price — keep the LLM signal and
+        # just back-fill any missing stop/target fields.
+        return self._backfill_missing_prices(signal)
+
+    @staticmethod
+    def _backfill_missing_prices(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.
+        """
+        entry = signal.entry_price
+        if entry is None or entry <= 0:
+            return signal
+
+        stop = signal.stop_loss
+        target = signal.target_price
+
+        if stop is None or stop <= 0:
+            if signal.action == Action.BUY:
+                stop = round(entry * 0.97, 2)
+            elif signal.action == Action.SELL:
+                stop = round(entry * 1.03, 2)
+            else:  # HOLD
+                stop = round(entry * 0.97, 2)
+
+        if target is None or target <= 0:
+            if signal.action == Action.BUY:
+                target = round(entry * 1.05, 2)
+            elif signal.action == Action.SELL:
+                target = round(entry * 0.95, 2)
+            else:  # HOLD
+                target = round(entry * 1.03, 2)
+
+        return TradingSignal(
+            ticker=signal.ticker,
+            action=signal.action,
+            confidence=signal.confidence,
+            entry_price=entry,
+            stop_loss=stop,
+            target_price=target,
+            reasoning=signal.reasoning,
+        )
+
     def _synthesize_from_tools(
         self, ticker: str, raw_output: str
     ) -> Optional[TradingSignal]: