fix(rectification): separate adjacent minutes with transition proximity

Day-level events now score Vimshottari/Narayana transition closeness so
nearby candidate minutes can diverge, with gated quality probes and
answer-prior ranking so high-base-rate existence questions stay out.

Co-authored-by: Cursor <cursoragent@cursor.com>

scripts/rectification/scoring_service.py

@@ -10,10 +10,11 @@ from typing import Any
 
 from scripts.active_rectification_event_engine import compute_candidate_static_contexts, compute_event_candidate_rows
 from scripts.active_rectification_events import CandidateScoreRow
+from scripts.rectification.dasha_transition_proximity import merge_transition_proximity
 from scripts.rectification.contracts import LifeEvent, RectificationRequest, is_scoreable_event
 from scripts.rectification.case_holdout import holdout_event_ids
 
-ALGORITHM_VERSION = "rectification-v5-matrix-scoring-6"
+ALGORITHM_VERSION = "rectification-v5-matrix-scoring-7"
 INPUT_CONTRACT_VERSION = "rectification-calculation-spec-v4"
 PRECISION_WEIGHTS = {
     "day": 1.0,
@@ -179,11 +180,14 @@ def precision_weight(precision: str) -> float:
 
 def public_technique_layers(domain: str, rule_ids: Sequence[str]) -> list[str]:
     """Public methods actually computed for this event. Career always lists D1-10 and D10."""
-    layers = {
-        rule.split(":", 1)[0]
-        for rule in rule_ids
-        if not rule.startswith(("event_kind:", "event_kind_profile:"))
-    }
+    layers: set[str] = set()
+    for rule in rule_ids:
+        if rule.startswith(("event_kind:", "event_kind_profile:")):
+            continue
+        if "transition_proximity" in rule:
+            layers.add("dasha-transition-proximity")
+            continue
+        layers.add(rule.split(":", 1)[0])
     if domain == "career":
         layers.update({"d1-rashi", "d10-dashamsa"})
     elif domain == "family":
@@ -235,6 +239,7 @@ def scoreable_request(request: RectificationRequest) -> RectificationRequest:
 def build_event_contribution_matrix(
     request: RectificationRequest,
     row_provider: Callable[[dict[str, Any]], Sequence[CandidateScoreRow]] | None = None,
+    static_contexts: Sequence[dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
     scoring_request = scoreable_request(request)
     if not scoring_request["events"]:
@@ -242,7 +247,8 @@ def build_event_contribution_matrix(
             "candidate_times": [], "matrix": {}, "date_sensitivity": [],
             "missing_layers": [], "static_contexts": None,
         }
-    static_contexts = None if row_provider is not None else compute_candidate_static_contexts(scoring_request)
+    if static_contexts is None and row_provider is None:
+        static_contexts = compute_candidate_static_contexts(scoring_request)
     provider = row_provider or (lambda value: compute_event_candidate_rows(value, static_contexts=static_contexts))
     matrix: dict[str, dict[str, dict[str, Any]]] = defaultdict(dict)
     missing_layers: set[str] = set()
@@ -288,9 +294,18 @@ def build_event_contribution_matrix(
             "score_variance": round(variance, 6),
             "sample_winners": winners,
         })
+    matrix_payload = dict(matrix)
+    if static_contexts:
+        merge_transition_proximity(
+            matrix_payload,
+            scoring_request["events"],
+            static_contexts,
+            scoring_request["birth_date"],
+            public_technique_layers=public_technique_layers,
+        )
     return {
         "candidate_times": candidate_grid or [],
-        "matrix": dict(matrix),
+        "matrix": matrix_payload,
         "date_sensitivity": date_sensitivity,
         "missing_layers": sorted(missing_layers),
         "static_contexts": static_contexts,