Add weekly_trend tests (25%→100%), expand signal_scorer tests, gitignore .serena

- New test_weekly_trend.py: 15 tests covering uptrend, structural crash,
  SMA decline, insufficient data, API errors, recovery scenarios
- Expand test_signal_scorer.py: 32 new tests for _insider_bucket, _parse_sentiment,
  _infer_insider_from_signal, compute_bucket_stats, load_signals, clear_cache,
  relaxed match fallback, and edge cases (invalid price, zero price, missing price)
- Add .serena/ to .gitignore
- Total: 743 tests across 35 files

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

Author: costajohnt

.gitignore

@@ -8,3 +8,6 @@ __pycache__/
 data/*.log
 data/*.bak
 data/param_sweep_results.csv
+
+# Tool/IDE config
+.serena/

tests/test_signal_scorer.py

@@ -24,9 +24,15 @@
     BucketStats,
     SignalScore,
     _deviation_bucket,
+    _infer_insider_from_signal,
+    _insider_bucket,
+    _parse_sentiment,
     _sentiment_bucket,
+    clear_cache,
+    compute_bucket_stats,
     compute_outcomes,
     get_bucket_name,
+    load_signals,
     score_signal,
 )
 
@@ -401,3 +407,273 @@ def test_multiple_buys_same_symbol_all_scored_when_open(self):
         returns = [o["return_pct"] for o in outcomes]
         assert pytest.approx(5.0) in returns  # (105-100)/100 * 100
         assert pytest.approx(10.526, rel=0.01) in returns  # (105-95)/95 * 100
+
+
+# ===================================================================
+# _insider_bucket()
+# ===================================================================
+
+class TestInsiderBucket:
+    """Insider presence classification."""
+
+    def test_insider_yes(self):
+        assert _insider_bucket(True) == "insider_yes"
+
+    def test_insider_no(self):
+        assert _insider_bucket(False) == "insider_no"
+
+    def test_insider_unknown(self):
+        assert _insider_bucket(None) == "insider_unknown"
+
+
+# ===================================================================
+# _parse_sentiment()
+# ===================================================================
+
+class TestParseSentiment:
+    """Safe parsing of sentiment scores from CSV strings."""
+
+    def test_valid_float_string(self):
+        assert _parse_sentiment("0.75") == pytest.approx(0.75)
+
+    def test_negative_float_string(self):
+        assert _parse_sentiment("-0.5") == pytest.approx(-0.5)
+
+    def test_none_returns_none(self):
+        assert _parse_sentiment(None) is None
+
+    def test_empty_string_returns_none(self):
+        assert _parse_sentiment("") is None
+
+    def test_whitespace_only_returns_none(self):
+        assert _parse_sentiment("   ") is None
+
+    def test_non_numeric_returns_none(self):
+        assert _parse_sentiment("positive") is None
+
+    def test_integer_string(self):
+        assert _parse_sentiment("1") == pytest.approx(1.0)
+
+
+# ===================================================================
+# _infer_insider_from_signal()
+# ===================================================================
+
+class TestInferInsiderFromSignal:
+    """Infer insider presence from sentiment_reasoning text."""
+
+    def test_insider_keyword_detected(self):
+        signal = {"sentiment_reasoning": "Strong insider buying activity detected"}
+        assert _infer_insider_from_signal(signal) is True
+
+    def test_executive_buy_detected(self):
+        signal = {"sentiment_reasoning": "Executive buy at $150 per share"}
+        assert _infer_insider_from_signal(signal) is True
+
+    def test_no_insider_keywords(self):
+        signal = {"sentiment_reasoning": "Positive earnings report"}
+        assert _infer_insider_from_signal(signal) is None
+
+    def test_empty_reasoning(self):
+        signal = {"sentiment_reasoning": ""}
+        assert _infer_insider_from_signal(signal) is None
+
+    def test_missing_reasoning_key(self):
+        signal = {}
+        assert _infer_insider_from_signal(signal) is None
+
+    def test_none_reasoning(self):
+        signal = {"sentiment_reasoning": None}
+        assert _infer_insider_from_signal(signal) is None
+
+    def test_case_insensitive(self):
+        signal = {"sentiment_reasoning": "INSIDER buying trend"}
+        assert _infer_insider_from_signal(signal) is True
+
+
+# ===================================================================
+# compute_bucket_stats()
+# ===================================================================
+
+class TestComputeBucketStats:
+    """Bucket statistics computation from outcomes."""
+
+    def test_single_bucket_stats(self):
+        """Compute stats for a single bucket of outcomes."""
+        outcomes = [
+            {"bucket": "deep_dip+positive_sent", "symbol": "AAPL", "return_pct": 5.0, "won": True},
+            {"bucket": "deep_dip+positive_sent", "symbol": "NVDA", "return_pct": -2.0, "won": False},
+            {"bucket": "deep_dip+positive_sent", "symbol": "MSFT", "return_pct": 8.0, "won": True},
+        ]
+        stats = compute_bucket_stats(outcomes)
+        assert len(stats) == 1
+        b = stats["deep_dip+positive_sent"]
+        assert b.sample_size == 3
+        assert b.win_count == 2
+        assert b.win_rate == pytest.approx(2 / 3)
+        assert b.avg_return == pytest.approx((5.0 - 2.0 + 8.0) / 3)
+        assert b.min_return == pytest.approx(-2.0)
+        assert b.max_return == pytest.approx(8.0)
+
+    def test_multiple_buckets(self):
+        """Outcomes from different buckets are grouped separately."""
+        outcomes = [
+            {"bucket": "deep_dip+positive_sent", "symbol": "AAPL", "return_pct": 10.0, "won": True},
+            {"bucket": "shallow_dip+neutral_sent", "symbol": "NVDA", "return_pct": -3.0, "won": False},
+        ]
+        stats = compute_bucket_stats(outcomes)
+        assert len(stats) == 2
+        assert stats["deep_dip+positive_sent"].sample_size == 1
+        assert stats["shallow_dip+neutral_sent"].sample_size == 1
+
+    def test_empty_outcomes(self):
+        """Empty outcomes returns empty stats."""
+        stats = compute_bucket_stats([])
+        assert stats == {}
+
+    def test_unique_symbols_tracked(self):
+        """Symbols list in BucketStats should contain unique entries."""
+        outcomes = [
+            {"bucket": "b1", "symbol": "AAPL", "return_pct": 5.0, "won": True},
+            {"bucket": "b1", "symbol": "AAPL", "return_pct": 3.0, "won": True},
+            {"bucket": "b1", "symbol": "NVDA", "return_pct": -1.0, "won": False},
+        ]
+        stats = compute_bucket_stats(outcomes)
+        assert set(stats["b1"].symbols) == {"AAPL", "NVDA"}
+
+
+# ===================================================================
+# load_signals()
+# ===================================================================
+
+class TestLoadSignals:
+    """Signal loading from CSV."""
+
+    def test_missing_file_returns_empty(self, tmp_path, monkeypatch):
+        """Missing signals.csv should return empty list."""
+        import strategies.signal_scorer as ss
+        monkeypatch.setattr(ss, "SIGNAL_LOG", tmp_path / "nonexistent.csv")
+        assert load_signals() == []
+
+    def test_valid_csv(self, tmp_path, monkeypatch):
+        """A valid CSV should return list of dicts."""
+        import strategies.signal_scorer as ss
+        csv_file = tmp_path / "signals.csv"
+        csv_file.write_text("symbol,price,final_action\nAAPL,150.0,buy\n")
+        monkeypatch.setattr(ss, "SIGNAL_LOG", csv_file)
+        result = load_signals()
+        assert len(result) == 1
+        assert result[0]["symbol"] == "AAPL"
+        assert result[0]["price"] == "150.0"
+
+
+# ===================================================================
+# clear_cache()
+# ===================================================================
+
+class TestClearCache:
+    """Cache management."""
+
+    def test_clear_cache_resets_state(self):
+        """clear_cache should reset _cached_stats to None."""
+        import strategies.signal_scorer as ss
+        old = ss._cached_stats
+        ss._cached_stats = {"test": "data"}
+        clear_cache()
+        assert ss._cached_stats is None
+        ss._cached_stats = old
+
+
+# ===================================================================
+# score_signal() — relaxed match
+# ===================================================================
+
+class TestScoreSignalRelaxedMatch:
+    """score_signal falls back to a relaxed bucket (dropping insider dimension)."""
+
+    def test_relaxed_match_drops_insider(self):
+        """If exact bucket not found, falls back to bucket without insider dimension."""
+        # Only the non-insider bucket exists in stats
+        relaxed = get_bucket_name(-8.0, 0.5, None)  # "moderate_dip+positive_sent"
+        stats = {
+            relaxed: BucketStats(
+                bucket=relaxed,
+                sample_size=10,
+                win_count=7,
+                win_rate=0.7,
+                avg_return=4.0,
+                min_return=-1.0,
+                max_return=9.0,
+                symbols=["AAPL"],
+            ),
+        }
+        # Query with has_insider=True -> exact bucket doesn't exist -> falls back
+        score = score_signal(-8.0, 0.5, True, stats=stats)
+        assert score.conviction == pytest.approx(0.7)
+        assert score.sample_size == 10
+
+    def test_no_relaxed_match_returns_default(self):
+        """If neither exact nor relaxed bucket exists, return default."""
+        stats = {
+            "deep_dip+negative_sent": BucketStats(
+                bucket="deep_dip+negative_sent",
+                sample_size=10,
+                win_count=3,
+                win_rate=0.3,
+                avg_return=-2.0,
+                min_return=-10.0,
+                max_return=5.0,
+                symbols=["AAPL"],
+            ),
+        }
+        # Query a bucket that doesn't exist in stats
+        score = score_signal(-3.0, 0.5, None, stats=stats)
+        assert score.conviction == DEFAULT_CONVICTION
+        assert score.sample_size == 0
+
+
+# ===================================================================
+# compute_outcomes() — edge cases
+# ===================================================================
+
+class TestComputeOutcomesEdgeCases:
+    """Edge cases for compute_outcomes."""
+
+    def test_invalid_price_skipped(self):
+        """Signals with non-numeric prices should be skipped."""
+        signals = [{
+            "symbol": "AAPL",
+            "price": "INVALID",
+            "final_action": "buy",
+            "deviation_pct": "-5.0",
+            "sentiment_score": "0.5",
+            "sentiment_reasoning": "",
+        }]
+        outcomes = compute_outcomes(signals, {"AAPL": 100.0})
+        assert len(outcomes) == 0
+
+    def test_zero_entry_price_skipped(self):
+        """Entry price of zero should be skipped (division by zero)."""
+        signals = [{
+            "symbol": "AAPL",
+            "price": "0",
+            "final_action": "buy",
+            "deviation_pct": "-5.0",
+            "sentiment_score": "0.5",
+            "sentiment_reasoning": "",
+        }]
+        outcomes = compute_outcomes(signals, {"AAPL": 100.0})
+        assert len(outcomes) == 0
+
+    def test_missing_current_price_skipped(self):
+        """Signals for symbols without current price are skipped."""
+        signals = [_make_buy_signal("AAPL", 100.0)]
+        outcomes = compute_outcomes(signals, {})  # no prices
+        assert len(outcomes) == 0
+
+    def test_outcome_bucket_assignment(self):
+        """Each outcome should have the correct bucket assigned."""
+        signals = [_make_buy_signal("AAPL", 100.0, deviation_pct=-12.0, sentiment_score="0.8")]
+        outcomes = compute_outcomes(signals, {"AAPL": 110.0})
+        assert len(outcomes) == 1
+        assert outcomes[0]["bucket"] == "deep_dip+positive_sent"