Fix buy-sizing bug and improve AI analysis quality

- Fix critical bug in strategy engine where new position buys used
  target_value as price estimate, resulting in qty=1 regardless of
  actual stock price. Now uses current_price from technicals data.
- Pass risk parameters (stop loss, take profit, position limits) to
  Claude prompt so AI can calibrate signals to actual config.
- Return and log analysis_summary from Claude for better visibility.
- Increase historical data window from 60 to 90 days so SMA_50
  has enough data points to be meaningful.
- Update README to document cryptocurrency support and the
  TRADING_CRYPTO_WATCHLIST variable.

https://claude.ai/code/session_01YFZGn9hgwhbfYJZGRV75ZN

Author: claude

README.md

@@ -1,14 +1,14 @@
 # Financial Agent
 
-AI-powered stock portfolio analyzer and trading agent that runs as a GitHub Action.
+AI-powered stock and cryptocurrency portfolio analyzer and trading agent that runs as a GitHub Action.
 
 ## How It Works
 
-Every 30 minutes during market hours (Mon-Fri), the agent:
+The agent runs every 30 minutes, 24/7. Crypto is analyzed on every run; stocks are only analyzed when the US market is open.
 
-1. **Checks** if the market is open
-2. **Fetches** your current portfolio from Alpaca
-3. **Runs technical analysis** (RSI, MACD, Bollinger Bands, etc.) on your watchlist
+1. **Checks** if the stock market is open (crypto always trades)
+2. **Fetches** your current portfolio from Alpaca (stocks + crypto)
+3. **Runs technical analysis** (RSI, MACD, Bollinger Bands, etc.) on your watchlists
 4. **Sends everything to Claude** for AI-powered analysis
 5. **Generates trade orders** with position sizing and risk management
 6. **Executes trades** (or logs them in dry-run mode)
@@ -39,6 +39,7 @@ Go to **Settings > Secrets and variables > Actions > Variables** and add:
 | `ALPACA_BASE_URL` | `https://paper-api.alpaca.markets` | Broker URL. Use `https://api.alpaca.markets` for live trading |
 | `ANTHROPIC_MODEL` | `claude-sonnet-4-20250514` | Claude model for analysis |
 | `TRADING_WATCHLIST` | `AAPL,MSFT,GOOGL,AMZN,NVDA,META,TSLA,JPM,V,JNJ` | Comma-separated stock symbols |
+| `TRADING_CRYPTO_WATCHLIST` | `BTC/USD,ETH/USD,SOL/USD` | Comma-separated crypto pairs (Alpaca format) |
 | `TRADING_STRATEGY` | `balanced` | Strategy: `balanced`, `conservative`, `momentum` |
 | `TRADING_DRY_RUN` | `true` | Set to `false` to enable real trades |
 | `TRADING_MAX_POSITION_PCT` | `0.10` | Max portfolio % for a single position |
@@ -107,8 +108,9 @@ The trading agent runs automatically on schedule. You can also trigger it manual
 
 - **Dry-run mode** is ON by default — no real trades until you explicitly disable it
 - **Paper trading** URL is the default broker endpoint
-- **Position limits** prevent over-concentration in a single stock
+- **Position limits** prevent over-concentration in any single asset
 - **Cash reserves** ensure you always maintain a minimum cash buffer
+- **Separate asset pipelines** — crypto and stocks are analyzed independently with asset-appropriate risk rules
 - **Daily trade limits** prevent runaway execution
 - **Environment protection** requires manual approval for the trading environment
 - **CI pipeline** runs lint, type checks, tests, and security scans on every PR

src/financial_agent/analysis/ai_analyzer.py

@@ -63,13 +63,20 @@ def __init__(self, ai_config: AIConfig, trading_config: TradingConfig) -> None:
         self._model = ai_config.model
         self._max_tokens = ai_config.max_tokens
         self._strategy = trading_config.strategy
+        self._max_position_pct = trading_config.max_position_pct
+        self._stop_loss_pct = trading_config.stop_loss_pct
+        self._take_profit_pct = trading_config.take_profit_pct
+        self._min_cash_reserve_pct = trading_config.min_cash_reserve_pct
 
     def analyze(
         self,
         portfolio: PortfolioSnapshot,
         technicals: dict[str, dict[str, float]],
-    ) -> list[TradeSignal]:
-        """Send portfolio + technical data to Claude and parse trade signals."""
+    ) -> tuple[list[TradeSignal], str]:
+        """Send portfolio + technical data to Claude and parse trade signals.
+
+        Returns a tuple of (signals, analysis_summary).
+        """
         prompt = self._build_prompt(portfolio, technicals)
 
         log.info("ai_analysis_started", model=self._model, symbols=list(technicals.keys()))
@@ -82,16 +89,17 @@ def analyze(
         )
 
         raw_text = response.content[0].text
-        signals = self._parse_response(raw_text)
+        signals, analysis_summary = self._parse_response(raw_text)
 
         log.info(
             "ai_analysis_complete",
             signal_count=len(signals),
             buy_count=sum(1 for s in signals if s.signal == SignalType.BUY),
             sell_count=sum(1 for s in signals if s.signal == SignalType.SELL),
+            analysis_summary=analysis_summary,
         )
 
-        return signals
+        return signals, analysis_summary
 
     def _build_prompt(
         self,
@@ -114,6 +122,12 @@ def _build_prompt(
 
         return f"""## Current Strategy Mode: {self._strategy}
 
+## Risk Parameters
+- Max position size: {self._max_position_pct * 100:.0f}% of portfolio
+- Stop loss target: {self._stop_loss_pct * 100:.1f}%
+- Take profit target: {self._take_profit_pct * 100:.1f}%
+- Min cash reserve: {self._min_cash_reserve_pct * 100:.0f}% of portfolio
+
 ## Portfolio Overview
 - Equity: ${portfolio.equity:,.2f}
 - Cash: ${portfolio.cash:,.2f} ({portfolio.cash / portfolio.equity * 100:.1f}% of equity)
@@ -134,8 +148,8 @@ def _build_prompt(
 Analyze the above data and provide your trading signals as JSON.
 """
 
-    def _parse_response(self, raw: str) -> list[TradeSignal]:
-        """Parse Claude's JSON response into TradeSignal objects."""
+    def _parse_response(self, raw: str) -> tuple[list[TradeSignal], str]:
+        """Parse Claude's JSON response into TradeSignal objects and summary."""
         # Strip markdown code fences if present
         text = raw.strip()
         if text.startswith("```"):
@@ -148,7 +162,9 @@ def _parse_response(self, raw: str) -> list[TradeSignal]:
             data = json.loads(text)
         except json.JSONDecodeError:
             log.error("ai_response_parse_error", raw=raw[:500])
-            return []
+            return [], ""
+
+        analysis_summary = data.get("analysis_summary", "")
 
         signals: list[TradeSignal] = []
         for entry in data.get("signals", []):
@@ -170,4 +186,4 @@ def _parse_response(self, raw: str) -> list[TradeSignal]:
             except (KeyError, ValueError) as e:
                 log.warning("skipping_invalid_signal", entry=entry, error=str(e))
 
-        return signals
+        return signals, analysis_summary

src/financial_agent/main.py

@@ -59,7 +59,7 @@ def main() -> None:
 
     if all_crypto:
         log.info("crypto_analysis_started", symbols=all_crypto)
-        crypto_bars = broker.get_crypto_historical_bars(all_crypto, days=60)
+        crypto_bars = broker.get_crypto_historical_bars(all_crypto, days=90)
         crypto_technicals = technical.compute_indicators(crypto_bars)
         technicals.update(crypto_technicals)
         log.info("crypto_analysis_complete", analyzed=len(crypto_technicals))
@@ -71,7 +71,7 @@ def main() -> None:
         all_stocks = list(set(stock_watchlist + held_stocks))
 
         log.info("stock_analysis_started", symbols=all_stocks)
-        stock_bars = broker.get_historical_bars(all_stocks, days=60)
+        stock_bars = broker.get_historical_bars(all_stocks, days=90)
         stock_technicals = technical.compute_indicators(stock_bars)
         technicals.update(stock_technicals)
         log.info("stock_analysis_complete", analyzed=len(stock_technicals))
@@ -83,10 +83,10 @@ def main() -> None:
         return
 
     # Step 4: AI analysis (single pass with all technicals)
-    signals = ai.analyze(portfolio, technicals)
+    signals, analysis_summary = ai.analyze(portfolio, technicals)
 
     # Step 5: Generate orders
-    orders = engine.generate_orders(signals, portfolio)
+    orders = engine.generate_orders(signals, portfolio, technicals)
     log.info("orders_generated", count=len(orders))
 
     # Step 6: Execute orders
@@ -100,6 +100,7 @@ def main() -> None:
         "equity": portfolio.equity,
         "cash": portfolio.cash,
         "market_open": market_open,
+        "analysis_summary": analysis_summary,
         "signals": {
             "buy": sum(1 for s in signals if s.signal == SignalType.BUY),
             "sell": sum(1 for s in signals if s.signal == SignalType.SELL),

src/financial_agent/strategy/engine.py

@@ -29,15 +29,17 @@ def generate_orders(
         self,
         signals: list[TradeSignal],
         portfolio: PortfolioSnapshot,
+        technicals: dict[str, dict[str, float]] | None = None,
     ) -> list[TradeOrder]:
         """Convert trade signals into concrete orders with position sizing and risk checks."""
         orders: list[TradeOrder] = []
+        technicals = technicals or {}
 
         for signal in signals:
             if signal.signal == SignalType.HOLD:
                 continue
 
-            order = self._signal_to_order(signal, portfolio)
+            order = self._signal_to_order(signal, portfolio, technicals)
             if order is not None:
                 orders.append(order)
 
@@ -57,10 +59,11 @@ def _signal_to_order(
         self,
         signal: TradeSignal,
         portfolio: PortfolioSnapshot,
+        technicals: dict[str, dict[str, float]],
     ) -> TradeOrder | None:
         """Convert a single signal to an order with position sizing."""
         if signal.signal == SignalType.BUY:
-            return self._size_buy_order(signal, portfolio)
+            return self._size_buy_order(signal, portfolio, technicals)
         elif signal.signal == SignalType.SELL:
             return self._size_sell_order(signal, portfolio)
         return None
@@ -69,6 +72,7 @@ def _size_buy_order(
         self,
         signal: TradeSignal,
         portfolio: PortfolioSnapshot,
+        technicals: dict[str, dict[str, float]],
     ) -> TradeOrder | None:
         """Size a buy order respecting position limits and cash reserves."""
         # Enforce minimum cash reserve
@@ -98,9 +102,16 @@ def _size_buy_order(
         if target_value < 1.0:
             return None
 
-        # Estimate qty (using current price from signal context)
+        # Get current price: existing position > technicals > skip
         current_pos = portfolio.get_position(signal.symbol)
-        est_price = current_pos.current_price if current_pos else target_value
+        if current_pos:
+            est_price = current_pos.current_price
+        elif signal.symbol in technicals and "current_price" in technicals[signal.symbol]:
+            est_price = technicals[signal.symbol]["current_price"]
+        else:
+            log.warning("skip_buy_no_price", symbol=signal.symbol)
+            return None
+
         qty = round(target_value / est_price, 2) if est_price > 0 else 0
 
         if qty <= 0:

tests/unit/test_ai_analyzer.py

@@ -43,12 +43,13 @@ def test_parse_valid_response(self):
           ]
         }
         """
-        signals = analyzer._parse_response(raw)
+        signals, summary = analyzer._parse_response(raw)
         assert len(signals) == 2
         assert signals[0].symbol == "AAPL"
         assert signals[0].signal == SignalType.BUY
         assert signals[0].confidence == 0.75
         assert signals[1].signal == SignalType.HOLD
+        assert summary == "Market looks bullish"
 
     def test_parse_code_fenced_response(self):
         analyzer = self._make_analyzer()
@@ -60,19 +61,21 @@ def test_parse_code_fenced_response(self):
           ]
         }
         ```"""
-        signals = analyzer._parse_response(raw)
+        signals, summary = analyzer._parse_response(raw)
         assert len(signals) == 1
         assert signals[0].signal == SignalType.SELL
+        assert summary == "Test"
 
     def test_parse_invalid_json(self):
         analyzer = self._make_analyzer()
-        signals = analyzer._parse_response("this is not json")
+        signals, summary = analyzer._parse_response("this is not json")
         assert signals == []
+        assert summary == ""
 
     def test_parse_missing_fields(self):
         analyzer = self._make_analyzer()
         raw = '{"signals": [{"symbol": "AAPL"}]}'
-        signals = analyzer._parse_response(raw)
+        signals, summary = analyzer._parse_response(raw)
         assert len(signals) == 0  # Should skip invalid entries
 
     def test_crypto_symbol_gets_crypto_asset_class(self):
@@ -96,7 +99,7 @@ def test_crypto_symbol_gets_crypto_asset_class(self):
           ]
         }
         """
-        signals = analyzer._parse_response(raw)
+        signals, summary = analyzer._parse_response(raw)
         assert len(signals) == 2
         assert signals[0].asset_class == AssetClass.CRYPTO
         assert signals[1].asset_class == AssetClass.US_EQUITY

tests/unit/test_strategy_engine.py

@@ -124,7 +124,26 @@ def test_buy_respects_cash_reserve(self):
         engine = StrategyEngine(_make_config(min_cash_reserve_pct=0.50))
         # Cash is 20% of equity but reserve is 50%, so no buys allowed
         portfolio = _make_portfolio(equity=100000.0, cash=20000.0)
+        technicals = {"AAPL": {"current_price": 160.0}}
         signals = [_make_signal(signal=SignalType.BUY)]
+        orders = engine.generate_orders(signals, portfolio, technicals)
+        assert len(orders) == 0
+
+    def test_buy_new_position_uses_technicals_price(self):
+        engine = StrategyEngine(_make_config())
+        portfolio = _make_portfolio(equity=100000.0, cash=20000.0)
+        technicals = {"AAPL": {"current_price": 160.0}}
+        signals = [_make_signal(signal=SignalType.BUY, confidence=0.8)]
+        orders = engine.generate_orders(signals, portfolio, technicals)
+        assert len(orders) == 1
+        # target_value = min(10000*0.8, 10000, 10000) = 8000
+        # qty = 8000 / 160 = 50.0
+        assert orders[0].qty == 50.0
+
+    def test_buy_new_position_skipped_without_price(self):
+        engine = StrategyEngine(_make_config())
+        portfolio = _make_portfolio(equity=100000.0, cash=20000.0)
+        signals = [_make_signal(signal=SignalType.BUY, confidence=0.8)]
         orders = engine.generate_orders(signals, portfolio)
         assert len(orders) == 0