@ngocsangairvds/vsaf 3.2.13 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/src/vds_audit_orchestrator/engine/result_merger.py

@@ -1,814 +0,0 @@
-"""Cross-run result merging for project aggregation (TSK-940.60, DD-165).
-
-Provides two merge strategies:
-- Row-level: per ``row_id``, select best ``(status, score)`` across runs.
-- Repo-level: select the single best run per repo.
-
-The merge function is pure logic — no DB or I/O.  DB loading is handled
-by the caller (``_load_repo_results_from_db`` in ``workflow_cmds.py``).
-"""
-
-from __future__ import annotations
-
-import os
-import threading
-import time
-from dataclasses import dataclass, field
-from enum import StrEnum
-from typing import Any
-
-from structlog import get_logger
-
-logger = get_logger(__name__)
-_critique_timeout_lock = threading.Lock()
-_CRITIQUE_TIMEOUT_POISONED_UNTIL: float = 0.0
-CRITIQUE_TIMEOUT_COOLDOWN = float(os.getenv("VDS_AUDIT_CRITIQUE_TIMEOUT_COOLDOWN_SECONDS", "60"))
-
-# Status quality ranking: lower = better.
-_STATUS_RANK: dict[str, int] = {
-    "PASS": 0,
-    "PARTIAL": 1,
-    "FAIL": 2,
-    "N/A": 3,
-    "ERROR": 4,
-}
-
-
-class MergeLevel(StrEnum):
-    """Merge granularity level."""
-
-    ROW = "row"  # Cherry-pick best row per row_id across runs (AC-275.5)
-    REPO = "repo"  # Select best complete run per repo (DD-165)
-
-
-@dataclass(slots=True)
-class RunInput:
-    """Input data for a single run's contribution to the merge."""
-
-    run_id: str
-    repo_key: str
-    rows: list[dict[str, Any]]
-    finished_at: str | None = None  # ISO timestamp for recency tiebreaker
-    overall_score: float | None = None  # Pre-computed aggregate score
-
-
-@dataclass(slots=True)
-class MergedRow:
-    """Single row after cross-run merge with provenance."""
-
-    row_id: str
-    row_index: int
-    status: str
-    score_percent: float
-    source_run_id: str
-    row_data: dict[str, Any]
-
-
-@dataclass(slots=True)
-class MergedRepoResult:
-    """Merged result for a single repository."""
-
-    repo_key: str
-    rows: list[MergedRow] = field(default_factory=list)
-    overall_score: float = 0.0
-    source_runs: list[str] = field(default_factory=list)
-    provenance: dict[str, str] = field(default_factory=dict)
-    error_count: int = 0
-    pass_count: int = 0
-    fail_count: int = 0
-    merge_level: str = MergeLevel.ROW.value
-
-
-@dataclass(slots=True)
-class MergedAggregateResult:
-    """Complete cross-run merge result with provenance."""
-
-    repos: dict[str, MergedRepoResult] = field(default_factory=dict)
-    source_run_ids: list[str] = field(default_factory=list)
-    total_rows_merged: int = 0
-    total_repos: int = 0
-    merge_level: str = MergeLevel.ROW.value
-
-
-@dataclass(slots=True)
-class CritiqueBudget:
-    """Budget and circuit-breaker controls for critique invocations (DD-375)."""
-
-    max_invocations: int = 200
-    timeout_seconds: float = 60.0
-    circuit_breaker_threshold: float = 0.5
-    invoked: int = 0
-    succeeded: int = 0
-    failed: int = 0
-    timed_out: int = 0
-    budget_exhausted: int = 0
-    circuit_broken: bool = False
-
-    @classmethod
-    def from_env(cls) -> CritiqueBudget:
-        def _int_env(name: str, default: int) -> int:
-            raw = os.getenv(name, "")
-            try:
-                return int(raw) if raw else default
-            except ValueError:
-                return default
-
-        def _float_env(name: str, default: float) -> float:
-            raw = os.getenv(name, "")
-            try:
-                return float(raw) if raw else default
-            except ValueError:
-                return default
-
-        return cls(
-            max_invocations=max(1, _int_env("VDS_AUDIT_CRITIQUE_MAX_INVOCATIONS_PER_PROJECT", 200)),
-            timeout_seconds=max(1.0, _float_env("VDS_AUDIT_CRITIQUE_TIMEOUT_SECONDS", 60.0)),
-            circuit_breaker_threshold=min(
-                1.0,
-                max(0.0, _float_env("VDS_AUDIT_CRITIQUE_CIRCUIT_BREAKER_THRESHOLD", 0.5)),
-            ),
-        )
-
-    @property
-    def failure_rate(self) -> float:
-        if self.invoked <= 0:
-            return 0.0
-        return float(self.failed + self.timed_out) / float(self.invoked)
-
-    def can_invoke(self) -> bool:
-        if self.circuit_broken:
-            return False
-        if self.invoked >= self.max_invocations:
-            return False
-        if self.invoked >= 5 and self.failure_rate > self.circuit_breaker_threshold:
-            self.circuit_broken = True
-            return False
-        return True
-
-    def record_invoked(self) -> None:
-        self.invoked += 1
-
-    def record_success(self) -> None:
-        self.succeeded += 1
-
-    def record_failure(self) -> None:
-        self.failed += 1
-        if self.invoked >= 5 and self.failure_rate > self.circuit_breaker_threshold:
-            self.circuit_broken = True
-
-    def record_timeout(self) -> None:
-        self.timed_out += 1
-        if self.invoked >= 5 and self.failure_rate > self.circuit_breaker_threshold:
-            self.circuit_broken = True
-
-    def record_budget_exhausted(self) -> None:
-        self.budget_exhausted += 1
-
-    def to_telemetry(self) -> dict[str, Any]:
-        return {
-            "max_invocations": self.max_invocations,
-            "timeout_seconds": self.timeout_seconds,
-            "circuit_breaker_threshold": self.circuit_breaker_threshold,
-            "invoked": self.invoked,
-            "succeeded": self.succeeded,
-            "failed": self.failed,
-            "timed_out": self.timed_out,
-            "budget_exhausted": self.budget_exhausted,
-            "circuit_broken": self.circuit_broken,
-            "success_rate": 0.0 if self.invoked == 0 else float(self.succeeded) / float(self.invoked),
-        }
-
-
-def _status_rank(status: str) -> int:
-    """Return ranking for status (lower = better)."""
-    return _STATUS_RANK.get(status.upper().strip(), 99)
-
-
-def _extract_score(row: dict[str, Any]) -> float:
-    """Extract score_percent from row data."""
-    score = row.get("score_percent")
-    if isinstance(score, (int, float)):
-        return float(score)
-    breakdown = row.get("score_breakdown")
-    if isinstance(breakdown, dict):
-        final = breakdown.get("final_score")
-        if isinstance(final, (int, float)):
-            return float(final)
-    return 0.0
-
-
-def _extract_weight(row: dict[str, Any]) -> float:
-    """Extract weight_adjusted from row data (default 1.0)."""
-    weight = row.get("weight_adjusted")
-    if isinstance(weight, (int, float)):
-        return float(weight)
-    return 1.0
-
-
-def _row_identity(row: dict[str, Any]) -> str:
-    """Resolve stable row identity key with backward-compatible fallback."""
-    row_key = str(row.get("row_key") or "").strip()
-    if row_key:
-        return row_key
-    # PERMANENT SAFETY NET — do not remove (Phase 102 GGG-E)
-    return str(row.get("row_id", "")).strip()
-
-
-def _is_better_row(candidate: dict[str, Any], current_best: dict[str, Any]) -> bool:
-    """Determine if candidate row is better than current best.
-
-    Selection criteria (DD-165):
-    1. Better status (PASS > PARTIAL > FAIL > N/A > ERROR)
-    2. Higher score (tiebreaker for same status)
-    """
-    cand_rank = _status_rank(str(candidate.get("status", "ERROR")))
-    best_rank = _status_rank(str(current_best.get("status", "ERROR")))
-
-    if cand_rank != best_rank:
-        return cand_rank < best_rank
-
-    return _extract_score(candidate) > _extract_score(current_best)
-
-
-def _is_polar_conflict(row_a: dict[str, Any], row_b: dict[str, Any]) -> bool:
-    """Return True when rows disagree on PASS versus FAIL/ERROR."""
-    a_status = str(row_a.get("status", "")).upper().strip()
-    b_status = str(row_b.get("status", "")).upper().strip()
-    failish = {"FAIL", "ERROR"}
-    return (a_status == "PASS" and b_status in failish) or (b_status == "PASS" and a_status in failish)
-
-
-def _extract_row_quality_metrics(row: dict[str, Any]) -> dict[str, float]:
-    trace = row.get("retrieval_trace") if isinstance(row.get("retrieval_trace"), dict) else {}
-    trace_result = trace.get("result") if isinstance(trace.get("result"), dict) else {}
-
-    def _metric(name: str, default: float = 0.0) -> float:
-        candidates = (row, trace, trace_result)
-        for src in candidates:
-            value = src.get(name) if isinstance(src, dict) else None
-            if isinstance(value, (int, float)):
-                return float(value)
-        return default
-
-    refs = row.get("evidence_refs")
-    verified_excerpt_anchors = 0
-    if isinstance(refs, list):
-        for ref in refs:
-            if not isinstance(ref, dict):
-                continue
-            verified = bool(ref.get("verified"))
-            excerpt = str(ref.get("excerpt") or "").strip()
-            if verified and excerpt:
-                verified_excerpt_anchors += 1
-
-    return {
-        "score": _extract_score(row),
-        "citation_retention_rate": _metric("citation_retention_rate"),
-        "final_cited_ref_count": _metric("final_cited_ref_count"),
-        "verified_excerpt_anchors": float(verified_excerpt_anchors),
-    }
-
-
-def _is_quality_floor_conflict(row_a: dict[str, Any], row_b: dict[str, Any]) -> bool:
-    """Return True for materially different non-pass evidence quality (DD-380)."""
-    non_pass = {"PARTIAL", "FAIL", "ERROR"}
-    a_status = str(row_a.get("status", "")).upper().strip()
-    b_status = str(row_b.get("status", "")).upper().strip()
-    if a_status not in non_pass or b_status not in non_pass:
-        return False
-
-    a = _extract_row_quality_metrics(row_a)
-    b = _extract_row_quality_metrics(row_b)
-
-    # Zero-score collapse against non-zero peers is a hard quality-floor signal.
-    if (a["score"] <= 0.0 < b["score"]) or (b["score"] <= 0.0 < a["score"]):
-        return True
-
-    if abs(a["verified_excerpt_anchors"] - b["verified_excerpt_anchors"]) >= 1.0:
-        return True
-    if abs(a["final_cited_ref_count"] - b["final_cited_ref_count"]) >= 2.0:
-        return True
-    return abs(a["citation_retention_rate"] - b["citation_retention_rate"]) >= 0.2
-
-
-def _format_provider_evaluation(row: dict[str, Any], run_id: str) -> str:
-    """Format a compact provider evaluation summary for critique input (DD-374)."""
-    from vds_audit_orchestrator.dspy_modules.signatures import _normalize_space
-
-    status = str(row.get("status", "ERROR")).upper().strip()
-    score = _extract_score(row)
-    finding = _normalize_space(str(row.get("finding") or ""))
-    reason = _normalize_space(str(row.get("reason") or ""))
-    check_id = str(row.get("check_id") or row.get("row_id") or "").strip()
-    quality = _extract_row_quality_metrics(row)
-    return (
-        f"run={run_id};check_id={check_id};status={status};score={score:.2f};"
-        f"retention={quality['citation_retention_rate']:.3f};"
-        f"cited_refs={int(quality['final_cited_ref_count'])};"
-        f"verified_excerpt_anchors={int(quality['verified_excerpt_anchors'])};"
-        f"finding={finding};reason={reason}"
-    )
-
-
-def _invoke_cross_provider_critique(
-    *,
-    requirement_text: str,
-    check_id: str,
-    row_a: dict[str, Any],
-    row_b: dict[str, Any],
-    run_id_a: str,
-    run_id_b: str,
-    trigger_type: str,
-    judge_lm_name: str | None,
-    fallback_judge_lm_name: str | None,
-    timeout_seconds: float | None = None,
-) -> dict[str, Any] | None:
-    """Invoke critique module when available; return selected row payload or None."""
-    global _CRITIQUE_TIMEOUT_POISONED_UNTIL
-    with _critique_timeout_lock:
-        if time.time() < _CRITIQUE_TIMEOUT_POISONED_UNTIL:
-            return {"outcome": "timeout_cooldown"}
-    try:
-        import dspy
-
-        from vds_audit_orchestrator.dspy_modules.modules import CrossProviderCritiqueModule
-        from vds_audit_orchestrator.dspy_modules.runtime import load_dspy_runtime
-    except Exception as exc:  # pragma: no cover - depends on optional module wiring
-        logger.debug("critique_module_unavailable", error=str(exc))
-        return None
-
-    def _run_module() -> tuple[Any, Any]:
-        load_dspy_runtime()
-        module = CrossProviderCritiqueModule()
-        judge_lm = getattr(getattr(dspy, "settings", None), "lm", None)
-        if judge_lm is None:
-            raise RuntimeError("dspy_judge_lm_not_configured")
-        with dspy.context(lm=judge_lm):
-            prediction = module(
-                requirement_text=requirement_text,
-                check_id=check_id,
-                provider_a_evaluation=_format_provider_evaluation(row_a, run_id_a),
-                provider_b_evaluation=_format_provider_evaluation(row_b, run_id_b),
-                provider_a_label=run_id_a,
-                provider_b_label=run_id_b,
-            )
-        return judge_lm, prediction
-
-    def _run_with_timeout() -> tuple[Any, Any]:
-        timeout = float(timeout_seconds) if timeout_seconds is not None else 0.0
-        if timeout <= 0.0:
-            return _run_module()
-
-        holder: dict[str, Any] = {}
-
-        def _worker() -> None:
-            try:
-                holder["result"] = _run_module()
-            except Exception as exc:
-                holder["error"] = exc
-
-        worker = threading.Thread(
-            target=_worker,
-            name="cross-provider-critique-timeout-guard",
-            daemon=True,
-        )
-        worker.start()
-        worker.join(timeout)
-        if worker.is_alive():
-            raise TimeoutError("cross_provider_critique_timeout")
-        error = holder.get("error")
-        if error is not None:
-            raise error
-        result = holder.get("result")
-        if not isinstance(result, tuple) or len(result) != 2:
-            raise RuntimeError("cross_provider_critique_no_result")
-        return result
-
-    try:
-        _judge_lm, prediction = _run_with_timeout()
-    except TimeoutError:
-        with _critique_timeout_lock:
-            _CRITIQUE_TIMEOUT_POISONED_UNTIL = time.time() + CRITIQUE_TIMEOUT_COOLDOWN
-        logger.warning(
-            "critique_invocation_timeout",
-            check_id=check_id,
-            run_id_a=run_id_a,
-            run_id_b=run_id_b,
-            trigger_type=trigger_type,
-            timeout_seconds=timeout_seconds,
-        )
-        return {"outcome": "timeout_cooldown"}
-    except Exception as exc:  # pragma: no cover - dependent on DSPy runtime availability
-        logger.warning("critique_invocation_failed", error=str(exc))
-        return {"outcome": "failed"}
-
-    superior = str(getattr(prediction, "superior_provider", "") or "").upper().strip()
-    selected_row = dict(row_a if superior == "A" else row_b)
-    selected_run_id = run_id_a if superior == "A" else run_id_b
-
-    meta = {
-        "invoked": True,
-        "trigger_type": trigger_type,
-        "superior_provider": superior if superior in {"A", "B"} else "B",
-        "judge_lm": judge_lm_name or fallback_judge_lm_name or "",
-        "original_a_status": str(row_a.get("status", "ERROR")).upper().strip(),
-        "original_b_status": str(row_b.get("status", "ERROR")).upper().strip(),
-        "original_a_run": run_id_a,
-        "original_b_run": run_id_b,
-    }
-    selected_row["critique_metadata"] = meta
-    return {"outcome": "success", "row": selected_row, "source_run_id": selected_run_id}
-
-
-def _compute_weighted_score(rows: list[MergedRow]) -> float:
-    """Compute weighted average score, excluding N/A rows."""
-    applicable = [r for r in rows if r.status not in {"N/A", "NA"}]
-    if not applicable:
-        return 0.0
-    total_weight = sum(_extract_weight(r.row_data) for r in applicable)
-    if total_weight <= 0:
-        return sum(r.score_percent for r in applicable) / len(applicable)
-    return sum(r.score_percent * _extract_weight(r.row_data) for r in applicable) / total_weight
-
-
-def merge_cross_run_results(
-    run_inputs: list[RunInput],
-    *,
-    merge_level: MergeLevel = MergeLevel.ROW,
-    critique_enabled: bool = False,
-    critique_budget: CritiqueBudget | None = None,
-    judge_lm_name: str | None = None,
-    fallback_judge_lm_name: str | None = None,
-) -> MergedAggregateResult:
-    """Merge results from multiple runs.
-
-    Args:
-        run_inputs: List of RunInput with run_id, repo_key, and row data.
-        merge_level: ``ROW`` for row-level cherry-pick (default),
-                     ``REPO`` for best-run-per-repo selection.
-
-    Returns:
-        MergedAggregateResult with per-repo merged results and provenance.
-    """
-    if not run_inputs:
-        return MergedAggregateResult(merge_level=merge_level.value)
-
-    repo_runs: dict[str, list[RunInput]] = {}
-    all_run_ids: list[str] = []
-    for ri in run_inputs:
-        repo_runs.setdefault(ri.repo_key, []).append(ri)
-        if ri.run_id not in all_run_ids:
-            all_run_ids.append(ri.run_id)
-
-    result = MergedAggregateResult(
-        source_run_ids=all_run_ids,
-        total_repos=len(repo_runs),
-        merge_level=merge_level.value,
-    )
-
-    total_merged = 0
-    for repo_key, runs in sorted(repo_runs.items()):
-        if merge_level == MergeLevel.ROW:
-            merged_repo = _merge_repo_row_level(
-                repo_key,
-                runs,
-                critique_enabled=critique_enabled,
-                critique_budget=critique_budget,
-                judge_lm_name=judge_lm_name,
-                fallback_judge_lm_name=fallback_judge_lm_name,
-            )
-        else:
-            merged_repo = _merge_repo_repo_level(repo_key, runs)
-        result.repos[repo_key] = merged_repo
-        total_merged += len(merged_repo.rows)
-
-    result.total_rows_merged = total_merged
-
-    logger.info(
-        "cross_run_merge_completed",
-        merge_level=merge_level.value,
-        source_runs=len(all_run_ids),
-        repos_merged=len(result.repos),
-        total_rows_merged=total_merged,
-    )
-    return result
-
-
-def _merge_repo_row_level(
-    repo_key: str,
-    runs: list[RunInput],
-    *,
-    critique_enabled: bool = False,
-    critique_budget: CritiqueBudget | None = None,
-    judge_lm_name: str | None = None,
-    fallback_judge_lm_name: str | None = None,
-) -> MergedRepoResult:
-    """Merge rows for a single repo by cherry-picking best per row_id."""
-    source_runs = [r.run_id for r in runs]
-
-    # row_id -> (best_row_data, source_run_id)
-    best_by_row: dict[str, tuple[dict[str, Any], str]] = {}
-    row_indices: dict[str, int] = {}
-
-    for ri in runs:
-        for row in ri.rows:
-            row_id = _row_identity(row)
-            if not row_id:
-                continue
-
-            row_index = row.get("row_index")
-            if isinstance(row_index, int):
-                row_indices.setdefault(row_id, row_index)
-
-            existing = best_by_row.get(row_id)
-            if existing is None:
-                best_by_row[row_id] = (row, ri.run_id)
-                continue
-
-            existing_row, existing_run_id = existing
-
-            # DD-379: evaluate critique triggers independently before _is_better_row guard.
-            polar_conflict = _is_polar_conflict(existing_row, row)
-            quality_floor_conflict = _is_quality_floor_conflict(existing_row, row)
-            trigger_type = "polar_conflict" if polar_conflict else "quality_floor_conflict"
-
-            if critique_enabled and (polar_conflict or quality_floor_conflict):
-                budget = critique_budget
-                if budget is not None and not budget.can_invoke():
-                    budget.record_budget_exhausted()
-                else:
-                    if budget is not None:
-                        budget.record_invoked()
-                    requirement_text = str(row.get("requirement") or existing_row.get("requirement") or "")
-                    check_id = str(row.get("check_id") or existing_row.get("check_id") or row_id)
-                    critique = _invoke_cross_provider_critique(
-                        requirement_text=requirement_text,
-                        check_id=check_id,
-                        row_a=existing_row,
-                        row_b=row,
-                        run_id_a=existing_run_id,
-                        run_id_b=ri.run_id,
-                        trigger_type=trigger_type,
-                        judge_lm_name=judge_lm_name,
-                        fallback_judge_lm_name=fallback_judge_lm_name,
-                        timeout_seconds=budget.timeout_seconds if budget is not None else None,
-                    )
-                    if critique and critique.get("outcome") == "success":
-                        if budget is not None:
-                            budget.record_success()
-                        best_by_row[row_id] = (
-                            critique.get("row", row),
-                            str(critique.get("source_run_id") or ri.run_id),
-                        )
-                        continue
-                    if budget is not None:
-                        if critique and critique.get("outcome") == "timeout_cooldown":
-                            budget.record_timeout()
-                        else:
-                            budget.record_failure()
-
-            if _is_better_row(row, existing_row):
-                best_by_row[row_id] = (row, ri.run_id)
-
-    merged_rows, provenance = _build_merged_rows(best_by_row, row_indices)
-
-    return _build_repo_result(
-        repo_key=repo_key,
-        rows=merged_rows,
-        provenance=provenance,
-        source_runs=source_runs,
-        merge_level=MergeLevel.ROW,
-    )
-
-
-def _merge_repo_repo_level(repo_key: str, runs: list[RunInput]) -> MergedRepoResult:
-    """Select the single best run for a repo (DD-165 repo-level).
-
-    Selection: (1) fewest error rows, (2) highest score, (3) most recent.
-    """
-    if not runs:
-        return MergedRepoResult(repo_key=repo_key)
-
-    def _run_sort_key(ri: RunInput) -> tuple[int, float, str]:
-        error_count = sum(1 for r in ri.rows if str(r.get("status", "")).upper() == "ERROR")
-        score = ri.overall_score if ri.overall_score is not None else _weighted_run_score(ri.rows)
-        finished = ri.finished_at or ""
-        # Sort: fewest errors ASC, highest score DESC (negate), latest timestamp DESC
-        return (error_count, -score, finished)
-
-    # Sort and pick the best (lowest sort key, but we want latest timestamp
-    # as tiebreaker — reverse the finished_at comparison)
-    best_run = min(
-        runs,
-        key=lambda ri: (
-            _run_sort_key(ri)[0],  # fewest errors
-            _run_sort_key(ri)[1],  # highest score (negated)
-            # Negate timestamp for "most recent wins"
-            "" if not ri.finished_at else "".join(chr(0xFFFF - ord(c)) for c in ri.finished_at),
-        ),
-    )
-
-    source_runs = [r.run_id for r in runs]
-    row_indices: dict[str, int] = {}
-    best_by_row: dict[str, tuple[dict[str, Any], str]] = {}
-
-    for row in best_run.rows:
-        row_id = _row_identity(row)
-        if not row_id:
-            continue
-        row_index = row.get("row_index")
-        if isinstance(row_index, int):
-            row_indices[row_id] = row_index
-        best_by_row[row_id] = (row, best_run.run_id)
-
-    merged_rows, provenance = _build_merged_rows(best_by_row, row_indices)
-
-    return _build_repo_result(
-        repo_key=repo_key,
-        rows=merged_rows,
-        provenance=provenance,
-        source_runs=source_runs,
-        merge_level=MergeLevel.REPO,
-    )
-
-
-def _compute_run_score(rows: list[dict[str, Any]]) -> float:
-    """Compute aggregate score for a run's rows."""
-    applicable = [r for r in rows if str(r.get("status", "")).upper() not in {"N/A", "NA"}]
-    if not applicable:
-        return 0.0
-    return sum(_extract_score(r) for r in applicable) / len(applicable)
-
-
-def _weighted_run_score(run_rows: list[dict[str, Any]]) -> float:
-    """Compute weighted average matching _compute_weighted_score logic.
-
-    Uses weight_adjusted per row for non-N/A rows.  Falls back to simple
-    average when weight_adjusted is absent from all rows.  Returns 0.0
-    when all rows are N/A.
-    """
-    _na_statuses = {"N/A", "NA"}
-    applicable = [r for r in run_rows if str(r.get("status", "")).upper() not in _na_statuses]
-    if not applicable:
-        return 0.0
-    has_weights = any(isinstance(r.get("weight_adjusted"), (int, float)) for r in applicable)
-    if not has_weights:
-        return sum(_extract_score(r) for r in applicable) / len(applicable)
-    total_weight = sum(float(r.get("weight_adjusted") or 1.0) for r in applicable)
-    if total_weight <= 0:
-        return sum(_extract_score(r) for r in applicable) / len(applicable)
-    return sum(_extract_score(r) * float(r.get("weight_adjusted") or 1.0) for r in applicable) / total_weight
-
-
-def reset_critique_timeout_state() -> None:
-    """Reset critique timeout cooldown state.  Call in test teardown for isolation."""
-    global _CRITIQUE_TIMEOUT_POISONED_UNTIL
-    with _critique_timeout_lock:
-        _CRITIQUE_TIMEOUT_POISONED_UNTIL = 0.0
-
-
-def _build_merged_rows(
-    best_by_row: dict[str, tuple[dict[str, Any], str]],
-    row_indices: dict[str, int],
-) -> tuple[list[MergedRow], dict[str, str]]:
-    """Build sorted list of MergedRow and provenance map."""
-    merged_rows: list[MergedRow] = []
-    provenance: dict[str, str] = {}
-
-    for row_id, (row_data, source_run_id) in sorted(
-        best_by_row.items(),
-        key=lambda item: row_indices.get(item[0], 999999),
-    ):
-        status = str(row_data.get("status", "ERROR")).upper()
-        score = _extract_score(row_data)
-        idx = row_indices.get(row_id, 0)
-
-        merged_rows.append(
-            MergedRow(
-                row_id=row_id,
-                row_index=idx,
-                status=status,
-                score_percent=score,
-                source_run_id=source_run_id,
-                row_data=row_data,
-            )
-        )
-        provenance[row_id] = source_run_id
-
-    return merged_rows, provenance
-
-
-def _build_repo_result(
-    *,
-    repo_key: str,
-    rows: list[MergedRow],
-    provenance: dict[str, str],
-    source_runs: list[str],
-    merge_level: MergeLevel,
-) -> MergedRepoResult:
-    """Build MergedRepoResult with aggregate stats."""
-    return MergedRepoResult(
-        repo_key=repo_key,
-        rows=rows,
-        overall_score=_compute_weighted_score(rows),
-        source_runs=source_runs,
-        provenance=provenance,
-        error_count=sum(1 for r in rows if r.status == "ERROR"),
-        pass_count=sum(1 for r in rows if r.status == "PASS"),
-        fail_count=sum(1 for r in rows if r.status == "FAIL"),
-        merge_level=merge_level.value,
-    )
-
-
-def merge_targeted_with_prior(
-    *,
-    current_rows: list[dict[str, Any]],
-    prior_rows: list[dict[str, Any]],
-    current_run_id: str,
-    prior_run_id: str,
-    targeted_row_ids: set[str] | None = None,
-) -> list[dict[str, Any]]:
-    """Merge a targeted re-run with its prior run to produce a complete result set.
-
-    DD-182: One-directional merge — non-targeted rows from ``prior_run`` are
-    copied into the result with ``source_run_id`` metadata.  Targeted rows
-    use the current run's results.  The prior run is never modified.
-
-    Args:
-        current_rows: Row results from the targeted re-run.
-        prior_rows: Row results from the prior (complete) run.
-        current_run_id: Run ID of the current targeted run.
-        prior_run_id: Run ID of the prior run.
-        targeted_row_ids: Explicit set of row identity keys (row_key preferred, row_id fallback) that were targeted.
-            If None, all rows present in ``current_rows`` are treated as targeted.
-
-    Returns:
-        Complete list of merged row dicts, sorted by row_index.
-    """
-
-    def _with_source_run_metadata(row: dict[str, Any], source_run_id: str) -> dict[str, Any]:
-        enriched = dict(row)
-        enriched["source_run_id"] = source_run_id
-        provenance = enriched.get("provenance")
-        provenance_dict = dict(provenance) if isinstance(provenance, dict) else {}
-        provenance_dict["source_run_id"] = source_run_id
-        enriched["provenance"] = provenance_dict
-        payload = enriched.get("payload")
-        payload_dict = dict(payload) if isinstance(payload, dict) else {}
-        payload_provenance = payload_dict.get("provenance")
-        payload_provenance_dict = dict(payload_provenance) if isinstance(payload_provenance, dict) else {}
-        payload_provenance_dict["source_run_id"] = source_run_id
-        payload_dict["provenance"] = payload_provenance_dict
-        enriched["payload"] = payload_dict
-        return enriched
-
-    # Build lookup of current (targeted) rows by row_id
-    current_by_id: dict[str, dict[str, Any]] = {}
-    for row in current_rows:
-        row_id = _row_identity(row)
-        if row_id:
-            current_by_id[row_id] = row
-
-    if targeted_row_ids is None:
-        targeted_row_ids = set(current_by_id.keys())
-
-    # Build the merged result: targeted rows from current, everything else from prior
-    merged: dict[str, dict[str, Any]] = {}
-
-    # First, seed with all prior rows (non-targeted get source_run_id metadata)
-    for row in prior_rows:
-        row_id = _row_identity(row)
-        if not row_id:
-            continue
-        if row_id in targeted_row_ids and row_id in current_by_id:
-            # This row was re-evaluated — use current result
-            current_row = _with_source_run_metadata(current_by_id[row_id], current_run_id)
-            merged[row_id] = current_row
-        else:
-            # Non-targeted row — carry forward from prior with provenance
-            carried = _with_source_run_metadata(row, prior_run_id)
-            merged[row_id] = carried
-
-    # Add any current rows not in prior (shouldn't happen, but defensive)
-    for row_id, row in current_by_id.items():
-        if row_id not in merged:
-            enriched = _with_source_run_metadata(row, current_run_id)
-            merged[row_id] = enriched
-
-    # Sort by row_index
-    result = sorted(
-        merged.values(),
-        key=lambda r: int(r.get("row_index", 0) or 0),
-    )
-
-    logger.info(
-        "targeted_auto_merge_completed",
-        current_run_id=current_run_id,
-        prior_run_id=prior_run_id,
-        targeted_count=len(targeted_row_ids),
-        prior_count=len(prior_rows),
-        current_count=len(current_rows),
-        merged_count=len(result),
-        carried_from_prior=sum(1 for r in result if r.get("source_run_id") == prior_run_id),
-    )
-    return result