Apply the trigger-correlation importance boost in the default clustering path

_run_clustering built each ClusterData with is_trigger_correlated=False
and a comment promising it would be 'refined below after sorting' - but
rank_and_merge_clusters only runs the optional semantic merge and
re-sorts; it never recomputes importance. So in the default
fingerprint-only path (embeddings disabled), no cluster ever got the
scoring.py trigger_weight boost, even though is_trigger was already
correctly detected and stored on the cluster.

is_trigger is known before compute_importance_score is called, so pass
it straight through instead of hardcoding False - the same pattern
semantic_merge.py's _merge_component already uses. This also fixes the
embeddings-enabled case for single-member components, which bypass
_merge_component entirely and previously kept their unboosted score.

Extracted the per-fingerprint ClusterData construction into
_build_cluster_data() so this path is unit-testable without a database
- the rest of _run_clustering is only covered by the Postgres-backed
integration suite.

Fixes #63

Author: afonsojanu

src/core/clustering/clusterer.py

@@ -39,6 +39,51 @@ class ClusterData:
     merged_fingerprints: list[str] = field(default_factory=list)
 
 
+def _build_cluster_data(
+    fingerprint: str, group: dict, baseline_counts: dict[str, int]
+) -> ClusterData:
+    """Build a ClusterData from one fingerprint's grouped log rows."""
+    count = len(group["ids"])
+    services = dict(group["services"])
+    levels = dict(group["levels"])
+    timestamps = sorted([t for t in group["timestamps"] if t is not None])
+
+    baseline_count = baseline_counts.get(fingerprint, 0)
+    change_ratio = compute_change_ratio(count, baseline_count)
+
+    # Representative message: most common
+    rep_msg = ""
+    if group["messages"]:
+        from collections import Counter
+
+        rep_msg = Counter(group["messages"]).most_common(1)[0][0]
+
+    is_trigger = is_trigger_message(rep_msg)
+
+    importance = compute_importance_score(
+        count=count,
+        levels_distribution=levels,
+        change_ratio=change_ratio,
+        services_count=len(services),
+        is_trigger_correlated=is_trigger,
+    )
+
+    return ClusterData(
+        fingerprint=fingerprint,
+        representative_message=rep_msg,
+        count=count,
+        services=services,
+        levels=levels,
+        first_seen=timestamps[0] if timestamps else None,
+        last_seen=timestamps[-1] if timestamps else None,
+        baseline_count=baseline_count,
+        change_ratio=change_ratio,
+        importance_score=importance,
+        is_trigger=is_trigger,
+        log_entry_ids=group["ids"],
+    )
+
+
 def run_clustering(
     db: Session,
     window_start: datetime,
@@ -171,50 +216,9 @@ def _run_clustering(
         )
 
     # 4. Build cluster data
-    clusters: list[ClusterData] = []
-
-    for fp, g in groups.items():
-        count = len(g["ids"])
-        services = dict(g["services"])
-        levels = dict(g["levels"])
-        timestamps = sorted([t for t in g["timestamps"] if t is not None])
-
-        baseline_count = baseline_counts.get(fp, 0)
-        change_ratio = compute_change_ratio(count, baseline_count)
-
-        # Representative message: most common
-        rep_msg = ""
-        if g["messages"]:
-            from collections import Counter
-
-            rep_msg = Counter(g["messages"]).most_common(1)[0][0]
-
-        is_trigger = is_trigger_message(rep_msg)
-
-        importance = compute_importance_score(
-            count=count,
-            levels_distribution=levels,
-            change_ratio=change_ratio,
-            services_count=len(services),
-            is_trigger_correlated=False,  # refined below after sorting
-        )
-
-        clusters.append(
-            ClusterData(
-                fingerprint=fp,
-                representative_message=rep_msg,
-                count=count,
-                services=services,
-                levels=levels,
-                first_seen=timestamps[0] if timestamps else None,
-                last_seen=timestamps[-1] if timestamps else None,
-                baseline_count=baseline_count,
-                change_ratio=change_ratio,
-                importance_score=importance,
-                is_trigger=is_trigger,
-                log_entry_ids=g["ids"],
-            )
-        )
+    clusters: list[ClusterData] = [
+        _build_cluster_data(fp, g, baseline_counts) for fp, g in groups.items()
+    ]
 
     # 5. Optional semantic merge, then rank and cap
     top_clusters, algorithm = rank_and_merge_clusters(clusters, max_clusters)

tests/unit/test_clusterer_trigger_boost.py

@@ -0,0 +1,63 @@
+"""The trigger-correlation importance boost must apply in the default
+(fingerprint-only, embeddings-disabled) clustering path.
+
+_run_clustering computed importance with is_trigger_correlated=False and a
+"refined below after sorting" comment promising a later fix-up that never
+existed, so trigger-correlated clusters never got the scoring.py
+trigger_weight boost unless they happened to be merged by the (opt-in)
+semantic-merge path.
+"""
+
+import uuid
+from datetime import datetime, timezone
+
+from src.core.clustering.baseline import compute_change_ratio
+from src.core.clustering.clusterer import _build_cluster_data
+from src.core.clustering.scoring import compute_importance_score
+
+
+def _group(message: str) -> dict:
+    return {
+        "messages": [message] * 5,
+        "services": {"api": 5},
+        "levels": {"error": 5},
+        "timestamps": [datetime(2026, 3, 12, 22, 0, 0, tzinfo=timezone.utc)],
+        "ids": [uuid.uuid4() for _ in range(5)],
+    }
+
+
+def test_trigger_message_sets_is_trigger_and_boosts_importance():
+    cluster = _build_cluster_data("fp-trigger", _group("deployment started"), {})
+
+    assert cluster.is_trigger is True
+
+    expected = compute_importance_score(
+        count=5,
+        levels_distribution={"error": 5},
+        change_ratio=compute_change_ratio(5, 0),
+        services_count=1,
+        is_trigger_correlated=True,
+    )
+    assert cluster.importance_score == expected
+
+
+def test_non_trigger_message_gets_no_boost():
+    cluster = _build_cluster_data("fp-plain", _group("request handled"), {})
+
+    assert cluster.is_trigger is False
+
+    expected = compute_importance_score(
+        count=5,
+        levels_distribution={"error": 5},
+        change_ratio=compute_change_ratio(5, 0),
+        services_count=1,
+        is_trigger_correlated=False,
+    )
+    assert cluster.importance_score == expected
+
+
+def test_trigger_cluster_outranks_otherwise_identical_non_trigger_cluster():
+    trigger_cluster = _build_cluster_data("fp-a", _group("deployment started"), {})
+    plain_cluster = _build_cluster_data("fp-b", _group("request handled"), {})
+
+    assert trigger_cluster.importance_score == plain_cluster.importance_score + 2.0