Fix 5 bugs, add execution script tests, remove dead dependency

Bug fixes:
- portfolio.py: handle null current_price (market halt/delisted)
- portfolio.py: make starting_cash configurable via STARTING_CASH env var
- position_manager.py: abort sell if stop cancellation fails (prevent oversell)
- pyproject.toml: remove unused anthropic dependency
- Remove stale .bak migration files from git

Test coverage:
- test_screener_trade.py: 10 tests (pause, risk, crisis, PDT, filters, dry run)
- test_momentum_trade.py: 8 tests (pause, risk, crisis, PDT, filters, dry run)
- test_scan_with_sentiment.py: 19 tests (composite_signal logic + main guards)
- test_portfolio.py: 6 tests (null price, STARTING_CASH, P&L, no positions)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: costajohnt

.env.example

@@ -16,6 +16,10 @@ OPENROUTER_API_KEY=your_openrouter_key_here
 # Optional — enables insider sentiment + earnings calendar signals
 FINNHUB_API_KEY=your_finnhub_key_here
 
+# Portfolio dashboard starting cash (default: 100000)
+# Update this if you reset or fund your paper account with a different amount
+# STARTING_CASH=100000
+
 # Telegram notifications (optional)
 # TELEGRAM_BOT_TOKEN=your_bot_token_here
 # TELEGRAM_CHAT_ID=your_chat_id_here

data/cooldowns.json.bak

@@ -6,7 +6,6 @@ readme = "README.md"
 requires-python = ">=3.14"
 dependencies = [
     "alpaca-py>=0.43.2",
-    "anthropic>=0.83.0",
     "finnhub-python>=2.4.27",
     "flask>=3.1.2",
     "numpy>=2.4.2",

data/high_water_marks.json.bak

@@ -13,7 +13,8 @@ def main():
     client = get_trading_client()
     account = client.get_account()
 
-    starting_cash = 100_000.00  # IMPORTANT: Update this if you reset the paper account
+    import os
+    starting_cash = float(os.environ.get("STARTING_CASH", "100000"))
     portfolio_value = float(account.portfolio_value)
     total_pnl = portfolio_value - starting_cash
     total_pnl_pct = (total_pnl / starting_cash) * 100
@@ -39,12 +40,14 @@ def main():
 
         total_unrealized = 0
         for p in sorted(positions, key=lambda x: x.symbol):
+            if p.current_price is None:
+                print(f"  {p.symbol:<8}  ** price unavailable (market halt / delisted?) **")
+                continue
             qty = float(p.qty)
             entry = float(p.avg_entry_price)
             current = float(p.current_price)
             pnl = float(p.unrealized_pl)
             pnl_pct = float(p.unrealized_plpc) * 100
-            market_val = float(p.market_value)
             total_unrealized += pnl
 
             print(f"  {p.symbol:<8} {qty:>6.1f} ${entry:>9.2f} ${current:>9.2f} "

data/partial_profits.json.bak

@@ -416,8 +416,17 @@ def main():
                     if n_cancelled:
                         print(f"              ^ Cancelled {n_cancelled} open order(s) for {symbol}")
                 except Exception as cancel_err:
-                    print(f"              ^ WARNING: Failed to cancel open orders: {cancel_err}")
-                    print(f"              ^ Proceeding with sell — risk of double execution")
+                    print(f"              ^ CRITICAL: Failed to cancel open orders: {cancel_err}")
+                    print(f"              ^ Aborting sell to prevent oversell (stop may still be live)")
+                    try:
+                        send_alert(
+                            f"SELL ABORTED: {symbol}",
+                            f"Could not cancel open orders for {symbol}: {cancel_err}\n"
+                            f"Sell aborted to prevent double execution. Manual intervention needed.",
+                        )
+                    except Exception:
+                        pass
+                    continue
 
                 try:
                     order = MarketOrderRequest(

pyproject.toml

@@ -0,0 +1,172 @@
+"""Tests for momentum_trade.py — auto-trade execution pipeline guards and vetoes."""
+
+import sys
+from types import SimpleNamespace
+from unittest.mock import patch, MagicMock
+
+import pytest
+
+from strategies.enums import Action, InsiderRecommendation
+
+
+def _mock_account(equity=100_000, daytrade_count=0):
+    return SimpleNamespace(equity=str(equity), daytrade_count=daytrade_count)
+
+
+def _mock_candidate(symbol="TEST", price=50.0, mom_10d=15.0, mom_50d=25.0, avg_volume=500_000):
+    return SimpleNamespace(symbol=symbol, price=price, mom_10d=mom_10d, mom_50d=mom_50d, avg_volume=avg_volume)
+
+
+def _mock_insider(rec=InsiderRecommendation.NEUTRAL, earnings_in_days=None):
+    return SimpleNamespace(recommendation=rec, earnings_in_days=earnings_in_days, reasoning="")
+
+
+class TestAgentPause:
+    def test_paused_exits_early(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, "argv", ["momentum_trade.py", "--execute"])
+        with patch("scripts.momentum_trade.acquire_process_lock", return_value=True), \
+             patch("scripts.momentum_trade.is_strategy_paused", return_value=True):
+            from scripts.momentum_trade import main
+            main()
+        assert "PAUSED" in capsys.readouterr().out
+
+
+class TestRiskGuard:
+    def test_unhealthy_halts(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, "argv", ["momentum_trade.py", "--execute", "--skip-sentiment"])
+        with patch("scripts.momentum_trade.acquire_process_lock", return_value=True), \
+             patch("scripts.momentum_trade.is_strategy_paused", return_value=False), \
+             patch("scripts.momentum_trade.check_portfolio_health", return_value=(False, "loss exceeded")):
+            from scripts.momentum_trade import main
+            main()
+        assert "HALTED" in capsys.readouterr().out
+
+
+class TestCrisisRegime:
+    def test_crisis_halts(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, "argv", ["momentum_trade.py", "--execute", "--skip-sentiment"])
+        with patch("scripts.momentum_trade.acquire_process_lock", return_value=True), \
+             patch("scripts.momentum_trade.is_strategy_paused", return_value=False), \
+             patch("scripts.momentum_trade.check_portfolio_health", return_value=(True, "")), \
+             patch("scripts.momentum_trade.get_trading_client") as mock_tc, \
+             patch("scripts.momentum_trade.get_data_client"), \
+             patch("scripts.momentum_trade.get_market_regime", return_value=("crisis", {"realized_vol": 40})), \
+             patch("scripts.momentum_trade.send_alert"):
+            mock_tc.return_value.get_all_positions.return_value = []
+            mock_tc.return_value.get_account.return_value = _mock_account()
+            from scripts.momentum_trade import main
+            main()
+        assert "CRISIS" in capsys.readouterr().out
+
+
+class TestPDTGuard:
+    def test_pdt_limit_halts(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, "argv", ["momentum_trade.py", "--execute", "--skip-sentiment"])
+        with patch("scripts.momentum_trade.acquire_process_lock", return_value=True), \
+             patch("scripts.momentum_trade.is_strategy_paused", return_value=False), \
+             patch("scripts.momentum_trade.check_portfolio_health", return_value=(True, "")), \
+             patch("scripts.momentum_trade.get_trading_client") as mock_tc, \
+             patch("scripts.momentum_trade.get_data_client"), \
+             patch("scripts.momentum_trade.get_market_regime", return_value=("normal", {})), \
+             patch("scripts.momentum_trade.load_cooldowns", return_value={}):
+            mock_tc.return_value.get_all_positions.return_value = []
+            mock_tc.return_value.get_account.return_value = _mock_account(daytrade_count=3)
+            from scripts.momentum_trade import main
+            main()
+        assert "PDT limit" in capsys.readouterr().out
+
+
+class TestCandidateFilters:
+    def _run_with_candidate(self, monkeypatch, candidate, extra_patches=None):
+        monkeypatch.setattr(sys, "argv", ["momentum_trade.py", "--execute", "--skip-sentiment"])
+        patches = {
+            "scripts.momentum_trade.acquire_process_lock": MagicMock(return_value=True),
+            "scripts.momentum_trade.is_strategy_paused": MagicMock(return_value=False),
+            "scripts.momentum_trade.check_portfolio_health": MagicMock(return_value=(True, "")),
+            "scripts.momentum_trade.get_market_regime": MagicMock(return_value=("normal", {})),
+            "scripts.momentum_trade.get_liquid_symbols": MagicMock(return_value=[candidate.symbol]),
+            "scripts.momentum_trade.screen_for_momentum": MagicMock(return_value=[candidate]),
+            "scripts.momentum_trade.load_cooldowns": MagicMock(return_value={}),
+            "scripts.momentum_trade.is_on_cooldown": MagicMock(return_value=False),
+            "scripts.momentum_trade.log_signal": MagicMock(),
+            "scripts.momentum_trade.log_audit_entry": MagicMock(),
+            "scripts.momentum_trade.send_alert": MagicMock(),
+        }
+        if extra_patches:
+            patches.update(extra_patches)
+
+        mock_tc = MagicMock()
+        mock_tc.get_all_positions.return_value = []
+        mock_tc.get_account.return_value = _mock_account()
+        patches["scripts.momentum_trade.get_trading_client"] = MagicMock(return_value=mock_tc)
+        patches["scripts.momentum_trade.get_data_client"] = MagicMock()
+
+        ctx = {k: patch(k, v) for k, v in patches.items()}
+        for cm in ctx.values():
+            cm.start()
+        try:
+            from scripts.momentum_trade import main
+            main()
+        finally:
+            for cm in ctx.values():
+                cm.stop()
+
+    def test_existing_position_skipped(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, "argv", ["momentum_trade.py", "--execute", "--skip-sentiment"])
+        candidate = _mock_candidate("HELD")
+        with patch("scripts.momentum_trade.acquire_process_lock", return_value=True), \
+             patch("scripts.momentum_trade.is_strategy_paused", return_value=False), \
+             patch("scripts.momentum_trade.check_portfolio_health", return_value=(True, "")), \
+             patch("scripts.momentum_trade.get_trading_client") as mock_tc, \
+             patch("scripts.momentum_trade.get_data_client"), \
+             patch("scripts.momentum_trade.get_market_regime", return_value=("normal", {})), \
+             patch("scripts.momentum_trade.get_liquid_symbols", return_value=["HELD"]), \
+             patch("scripts.momentum_trade.screen_for_momentum", return_value=[candidate]), \
+             patch("scripts.momentum_trade.load_cooldowns", return_value={}):
+            mock_tc.return_value.get_all_positions.return_value = [SimpleNamespace(symbol="HELD", market_value=5000)]
+            mock_tc.return_value.get_account.return_value = _mock_account()
+            from scripts.momentum_trade import main
+            main()
+        assert "Traded: 0" in capsys.readouterr().out
+
+    def test_insider_bearish_skipped(self, monkeypatch, capsys):
+        candidate = _mock_candidate("BAD")
+        self._run_with_candidate(monkeypatch, candidate, {
+            "scripts.momentum_trade.get_insider_signal": MagicMock(return_value=_mock_insider(InsiderRecommendation.BEARISH)),
+        })
+        assert "insider selling" in capsys.readouterr().out
+
+    def test_earnings_imminent_skipped(self, monkeypatch, capsys):
+        candidate = _mock_candidate("EARN")
+        self._run_with_candidate(monkeypatch, candidate, {
+            "scripts.momentum_trade.get_insider_signal": MagicMock(return_value=_mock_insider(earnings_in_days=3)),
+        })
+        assert "earnings in 3d" in capsys.readouterr().out
+
+
+class TestDryRun:
+    def test_dry_run_no_orders(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, "argv", ["momentum_trade.py", "--skip-sentiment"])
+        candidate = _mock_candidate("DRY")
+        with patch("scripts.momentum_trade.acquire_process_lock", return_value=True), \
+             patch("scripts.momentum_trade.is_strategy_paused", return_value=False), \
+             patch("scripts.momentum_trade.get_data_client"), \
+             patch("scripts.momentum_trade.get_trading_client") as mock_tc, \
+             patch("scripts.momentum_trade.get_market_regime", return_value=("normal", {})), \
+             patch("scripts.momentum_trade.get_liquid_symbols", return_value=["DRY"]), \
+             patch("scripts.momentum_trade.screen_for_momentum", return_value=[candidate]), \
+             patch("scripts.momentum_trade.load_cooldowns", return_value={}), \
+             patch("scripts.momentum_trade.is_on_cooldown", return_value=False), \
+             patch("scripts.momentum_trade.get_insider_signal", return_value=_mock_insider()), \
+             patch("scripts.momentum_trade.check_sector_guard", return_value=(True, "")), \
+             patch("scripts.momentum_trade.calculate_momentum_size", return_value=3000), \
+             patch("scripts.momentum_trade.apply_regime_to_size", return_value=3000), \
+             patch("scripts.momentum_trade.format_momentum_sizing", return_value="base=$1000"), \
+             patch("scripts.momentum_trade.log_signal"), \
+             patch("scripts.momentum_trade.log_audit_entry"), \
+             patch("scripts.momentum_trade.send_alert"):
+            mock_tc.return_value.get_all_positions.return_value = []
+            mock_tc.return_value.get_account.return_value = _mock_account()
+            from scripts.momentum_trade import main
+            main()
+            mock_tc.return_value.submit_order.assert_not_called()

scripts/portfolio.py

@@ -0,0 +1,155 @@
+"""Tests for portfolio.py — null price handling, STARTING_CASH config, P&L calculation."""
+
+from types import SimpleNamespace
+from unittest.mock import patch, MagicMock
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def _mock_alpaca_imports():
+    """Ensure alpaca SDK enums/requests are available even when other tests stub sys.modules."""
+    with patch("alpaca.trading.enums.QueryOrderStatus", SimpleNamespace(ALL="all")), \
+         patch("alpaca.trading.requests.GetOrdersRequest", MagicMock()):
+        yield
+
+
+def _mock_account(portfolio_value=105_000, cash=50_000, buying_power=100_000, daytrade_count=0):
+    return SimpleNamespace(
+        portfolio_value=str(portfolio_value),
+        cash=str(cash),
+        buying_power=str(buying_power),
+        daytrade_count=daytrade_count,
+    )
+
+
+def _mock_position(symbol, qty=10, entry=100.0, current=110.0, pnl=100.0, pnl_pct=0.1, market_value=1100.0):
+    return SimpleNamespace(
+        symbol=symbol,
+        qty=str(qty),
+        avg_entry_price=str(entry),
+        current_price=str(current) if current is not None else None,
+        unrealized_pl=str(pnl),
+        unrealized_plpc=str(pnl_pct),
+        market_value=str(market_value),
+    )
+
+
+class TestNullPriceHandling:
+    """Positions with current_price=None should not crash the dashboard."""
+
+    @patch("strategies.equity_tracker.format_equity_summary", return_value="")
+    @patch("strategies.equity_tracker.record_daily_snapshot")
+    @patch("strategies.state_db.ensure_db")
+    @patch("scripts.portfolio.get_trading_client")
+    def test_null_price_prints_warning(self, mock_client, mock_db, mock_record, mock_fmt, capsys):
+        mock_client.return_value.get_account.return_value = _mock_account()
+        mock_client.return_value.get_all_positions.return_value = [
+            _mock_position("HALT", current=None),
+        ]
+        mock_db.return_value = MagicMock()
+        mock_client.return_value.get_orders.return_value = []
+
+        from scripts.portfolio import main
+        main()
+
+        output = capsys.readouterr().out
+        assert "HALT" in output
+        assert "price unavailable" in output
+
+    @patch("strategies.equity_tracker.format_equity_summary", return_value="")
+    @patch("strategies.equity_tracker.record_daily_snapshot")
+    @patch("strategies.state_db.ensure_db")
+    @patch("scripts.portfolio.get_trading_client")
+    def test_normal_position_displays(self, mock_client, mock_db, mock_record, mock_fmt, capsys):
+        mock_client.return_value.get_account.return_value = _mock_account()
+        mock_client.return_value.get_all_positions.return_value = [
+            _mock_position("AAPL", qty=10, entry=150.0, current=160.0, pnl=100.0, pnl_pct=0.0667),
+        ]
+        mock_db.return_value = MagicMock()
+        mock_client.return_value.get_orders.return_value = []
+
+        from scripts.portfolio import main
+        main()
+
+        output = capsys.readouterr().out
+        assert "AAPL" in output
+        assert "160.00" in output
+
+    @patch("strategies.equity_tracker.format_equity_summary", return_value="")
+    @patch("strategies.equity_tracker.record_daily_snapshot")
+    @patch("strategies.state_db.ensure_db")
+    @patch("scripts.portfolio.get_trading_client")
+    def test_mixed_null_and_normal_positions(self, mock_client, mock_db, mock_record, mock_fmt, capsys):
+        mock_client.return_value.get_account.return_value = _mock_account()
+        mock_client.return_value.get_all_positions.return_value = [
+            _mock_position("GOOD", current=50.0),
+            _mock_position("HALT", current=None),
+        ]
+        mock_db.return_value = MagicMock()
+        mock_client.return_value.get_orders.return_value = []
+
+        from scripts.portfolio import main
+        main()
+
+        output = capsys.readouterr().out
+        assert "GOOD" in output
+        assert "HALT" in output
+        assert "price unavailable" in output
+
+
+class TestStartingCash:
+    """STARTING_CASH env var controls P&L baseline."""
+
+    @patch("strategies.equity_tracker.format_equity_summary", return_value="")
+    @patch("strategies.equity_tracker.record_daily_snapshot")
+    @patch("strategies.state_db.ensure_db")
+    @patch("scripts.portfolio.get_trading_client")
+    def test_default_starting_cash(self, mock_client, mock_db, mock_record, mock_fmt, monkeypatch, capsys):
+        monkeypatch.delenv("STARTING_CASH", raising=False)
+        mock_client.return_value.get_account.return_value = _mock_account(portfolio_value=105_000)
+        mock_client.return_value.get_all_positions.return_value = []
+        mock_db.return_value = MagicMock()
+        mock_client.return_value.get_orders.return_value = []
+
+        from scripts.portfolio import main
+        main()
+
+        output = capsys.readouterr().out
+        # Default $100K, portfolio $105K = +$5,000 P&L
+        assert "+5,000" in output
+
+    @patch("strategies.equity_tracker.format_equity_summary", return_value="")
+    @patch("strategies.equity_tracker.record_daily_snapshot")
+    @patch("strategies.state_db.ensure_db")
+    @patch("scripts.portfolio.get_trading_client")
+    def test_custom_starting_cash(self, mock_client, mock_db, mock_record, mock_fmt, monkeypatch, capsys):
+        monkeypatch.setenv("STARTING_CASH", "200000")
+        mock_client.return_value.get_account.return_value = _mock_account(portfolio_value=210_000)
+        mock_client.return_value.get_all_positions.return_value = []
+        mock_db.return_value = MagicMock()
+        mock_client.return_value.get_orders.return_value = []
+
+        from scripts.portfolio import main
+        main()
+
+        output = capsys.readouterr().out
+        # $200K start, $210K now = +$10,000 P&L
+        assert "+10,000" in output
+
+
+class TestNoPositions:
+    @patch("strategies.equity_tracker.format_equity_summary", return_value="")
+    @patch("strategies.equity_tracker.record_daily_snapshot")
+    @patch("strategies.state_db.ensure_db")
+    @patch("scripts.portfolio.get_trading_client")
+    def test_no_positions_message(self, mock_client, mock_db, mock_record, mock_fmt, capsys):
+        mock_client.return_value.get_account.return_value = _mock_account()
+        mock_client.return_value.get_all_positions.return_value = []
+        mock_db.return_value = MagicMock()
+        mock_client.return_value.get_orders.return_value = []
+
+        from scripts.portfolio import main
+        main()
+
+        assert "No open positions" in capsys.readouterr().out