logitgate 0.2.0__py3-none-any.whl

logitgate/backends/recurrent.py

@@ -0,0 +1,245 @@
+"""
+PyTorch & HuggingFace backend with elastic recurrent layer-looping support.
+
+Designed for architectures like NVIDIA-Nemotron-Labs Dory-4B and Universal Transformers
+that support dynamic layer looping (`num_loops`) to perform latent reasoning in hidden
+state space before producing first-token logits.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+from logitgate.backends.base import GenerativeBackend, LogitBackend
+
+
+class RecurrentPyTorchBackend(LogitBackend, GenerativeBackend):
+    """
+    Inference backend for PyTorch/Transformers models with elastic recurrent layer looping.
+
+    Supports architectures like NVIDIA's Dory (e.g. ``nvidia/NVIDIA-Nemotron-Labs-Dory1.0-4B-BF16``)
+    where hidden states are recirculated through a recurrent layer block for ``num_loops`` iterations
+    before computing first-token logits.
+
+    Parameters
+    ----------
+    model_name : str
+        HuggingFace model ID or local directory (default: ``"nvidia/NVIDIA-Nemotron-Labs-Dory1.0-4B-BF16"``).
+    num_loops : int
+        Number of internal recurrent loops to execute per token (default: 2; recommended: 1 to 4).
+        Higher values increase latent reasoning depth at the cost of ~30-60% prefill compute.
+    device : str
+        Target compute device (``"cuda"``, ``"cpu"``, or ``"auto"``).
+    model : Any, optional
+        Pre-instantiated model instance (useful for testing or shared memory pipelines).
+    tokenizer : Any, optional
+        Pre-instantiated tokenizer instance.
+    torch_dtype : Any, optional
+        PyTorch dtype (e.g. ``torch.bfloat16``).
+    """
+
+    def __init__(
+        self,
+        model_name: str = "nvidia/NVIDIA-Nemotron-Labs-Dory1.0-4B-BF16",
+        num_loops: int = 2,
+        device: str = "cuda",
+        model: Any = None,
+        tokenizer: Any = None,
+        torch_dtype: Any = None,
+    ) -> None:
+        if num_loops < 1:
+            raise ValueError(f"num_loops must be >= 1, got {num_loops}")
+
+        self.model_name = model_name
+        self.num_loops = num_loops
+        self.device = device
+        self._model = model
+        self._tokenizer = tokenizer
+        self.torch_dtype = torch_dtype
+
+    def __repr__(self) -> str:
+        return f"RecurrentPyTorchBackend(model='{self.model_name}', num_loops={self.num_loops}, device='{self.device}')"
+
+    def _ensure_loaded(self) -> tuple[Any, Any]:
+        """Lazy-loads model and tokenizer if not already provided."""
+        if self._model is not None and self._tokenizer is not None:
+            return self._model, self._tokenizer
+
+        try:
+            import torch
+            from transformers import AutoModelForCausalLM, AutoTokenizer
+        except ImportError as err:
+            raise ImportError(
+                "PyTorch and Transformers are required for RecurrentPyTorchBackend. "
+                "Install them via `pip install logitgate[recurrent]` or `pip install torch transformers`."
+            ) from err
+
+        if self._tokenizer is None:
+            self._tokenizer = AutoTokenizer.from_pretrained(self.model_name, trust_remote_code=True)
+
+        if self._model is None:
+            target_dtype = self.torch_dtype or (torch.bfloat16 if torch.cuda.is_available() else torch.float32)
+            if "dory" in self.model_name.lower():
+                from logitgate.backends.dory_pytorch import load_dory_model
+
+                self._model = load_dory_model(
+                    model_name_or_path=self.model_name,
+                    device=self.device if self.device != "auto" else ("cuda:0" if torch.cuda.is_available() else "cpu"),
+                    num_loops=self.num_loops,
+                    torch_dtype=target_dtype,
+                )
+            else:
+                self._model = AutoModelForCausalLM.from_pretrained(
+                    self.model_name,
+                    torch_dtype=target_dtype,
+                    trust_remote_code=True,
+                    device_map=self.device if self.device != "auto" else "auto",
+                )
+                if self.device not in ("auto", "cuda") and hasattr(self._model, "to"):
+                    self._model = self._model.to(self.device)
+
+        return self._model, self._tokenizer
+
+    def query_top_logprobs(
+        self,
+        prompt: str,
+        top_k: int = 10,
+        allowed_tokens: list[str] | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Executes a forward pass with ``num_loops`` latent recurrence and extracts first-token logprobs.
+        """
+        model, tokenizer = self._ensure_loaded()
+
+        # Tokenize prompt
+        inputs = tokenizer(prompt, return_tensors="pt")
+        if hasattr(inputs, "to") and self.device not in ("auto",):
+            inputs = inputs.to(model.device if hasattr(model, "device") else self.device)
+
+        # Forward pass passing num_loops if supported by model signature
+        import inspect
+
+        kwargs: dict[str, Any] = {}
+        try:
+            fn = model.forward if hasattr(model, "forward") else model
+            sig = inspect.signature(fn)
+            if "num_loops" in sig.parameters or any(
+                p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()
+            ):
+                kwargs["num_loops"] = self.num_loops
+        except (ValueError, TypeError):
+            kwargs["num_loops"] = self.num_loops
+
+        try:
+            import torch
+            no_grad_ctx = torch.no_grad()
+        except ImportError:
+            from contextlib import nullcontext
+            no_grad_ctx = nullcontext()
+
+        with no_grad_ctx:
+            outputs = model(**inputs, **kwargs)
+        if hasattr(outputs, "logits"):
+            if hasattr(outputs.logits, "ndim"):
+                logits = outputs.logits[0, -1, :]
+            else:
+                logits = outputs.logits[0][-1]
+        elif hasattr(outputs, "ndim"):
+            logits = outputs[0, -1, :]
+        else:
+            logits = outputs[0][-1]
+
+        # Compute log_softmax
+        try:
+            import torch
+
+            log_probs = torch.nn.functional.log_softmax(logits, dim=-1)
+        except (ImportError, AttributeError, TypeError, ValueError):
+            # Fallback numpy log_softmax if torch is mocked or unavailable
+            max_l = float(max(logits))
+            exp_l = [math.exp(float(x) - max_l) for x in logits]
+            sum_exp = sum(exp_l)
+            log_probs = [float(x) - max_l - math.log(sum_exp) for x in logits]
+
+        results: list[dict[str, Any]] = []
+
+        if allowed_tokens:
+            for tok_str in allowed_tokens:
+                # Tokenize variant (both raw and leading-space)
+                token_ids = tokenizer.encode(tok_str, add_special_tokens=False)
+                if token_ids:
+                    tid = token_ids[-1]
+                    lp = float(log_probs[tid])
+                    results.append({"token": tok_str, "logprob": lp})
+            if results:
+                return results
+
+        # General top_k
+        top_k_count = max(top_k, 50)
+        try:
+            import torch
+
+            if isinstance(log_probs, torch.Tensor):
+                top_vals, top_indices = torch.topk(log_probs, min(top_k_count, log_probs.size(-1)))
+                seen_indices = set(top_indices.tolist())
+                for lp, idx in zip(top_vals.tolist(), top_indices.tolist()):
+                    token_str = tokenizer.decode([idx])
+                    results.append({"token": token_str, "logprob": float(lp)})
+
+                # Always guarantee standard candidate tokens are present so extract_token_logprob never misses them
+                guaranteed = ["A", "B", " A", " B", "1", "2", "3", "4", "5", " 1", " 2", " 3", " 4", " 5"]
+                if allowed_tokens:
+                    guaranteed.extend(allowed_tokens)
+                for g_tok in guaranteed:
+                    ids = tokenizer.encode(g_tok, add_special_tokens=False)
+                    if ids:
+                        tid = ids[-1]
+                        if tid not in seen_indices:
+                            seen_indices.add(tid)
+                            lp = float(log_probs[tid])
+                            results.append({"token": g_tok, "logprob": lp})
+                return results
+        except (ImportError, AttributeError, TypeError, ValueError):
+            pass
+
+        # Fallback list sorting
+        indexed = sorted(enumerate(log_probs), key=lambda x: float(x[1]), reverse=True)
+        for idx, lp in indexed[:top_k]:
+            token_str = tokenizer.decode([idx]) if hasattr(tokenizer, "decode") else str(idx)
+            results.append({"token": token_str, "logprob": float(lp)})
+
+        return results
+
+    def generate(self, prompt: str, max_tokens: int | None = None, **kwargs: Any) -> tuple[str, int]:
+        """Autoregressive generation with num_loops recurrent reasoning."""
+        model, tokenizer = self._ensure_loaded()
+        inputs = tokenizer(prompt, return_tensors="pt")
+        if hasattr(inputs, "to") and self.device not in ("auto",):
+            inputs = inputs.to(model.device if hasattr(model, "device") else self.device)
+
+        gen_kwargs: dict[str, Any] = {
+            "max_new_tokens": max_tokens or 256,
+            "do_sample": False,
+        }
+        import inspect
+
+        try:
+            sig = inspect.signature(model.generate)
+            if "num_loops" in sig.parameters or any(
+                p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()
+            ):
+                gen_kwargs["num_loops"] = self.num_loops
+        except (ValueError, TypeError):
+            gen_kwargs["num_loops"] = self.num_loops
+
+        if hasattr(inputs, "__getitem__") and "input_ids" in inputs:
+            input_tensor = inputs["input_ids"]
+        else:
+            input_tensor = inputs
+
+        outputs = model.generate(input_tensor, **gen_kwargs)
+        input_len = input_tensor.shape[-1]
+        generated_ids = outputs[0][input_len:]
+        text = tokenizer.decode(generated_ids, skip_special_tokens=True)
+        return text, len(generated_ids)

logitgate/cascade.py

@@ -0,0 +1,394 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Sequence
+from typing import Any
+
+from logitgate.gates.ast_gate import ASTGate, ContractGate
+from logitgate.gates.base import BaseGate
+from logitgate.gates.judge_gate import JudgeGate
+from logitgate.gates.logit_gate import LogitGate
+from logitgate.models import DecisionStatus, LayerTrace, Verdict
+
+
+class Cascade(BaseGate):
+    """3-Layer Cascaded Router pipeline.
+
+    Orchestrates sequential execution of gates:
+    - Layer 0 (ASTGate): Sub-millisecond deterministic syntax, contract, and DAG checks.
+    - Layer 1 (LogitGate): Fast (40–120ms) debiased first-token logit gate (`max_tokens=1`).
+    - Layer 2 (JudgeGate): Diagnostic generative critique triggered only on ambiguous or failing artifacts.
+
+    Fast-path passes at Layer 1 short-circuit Layer 2 entirely, avoiding multi-token
+    Chain-of-Thought generation for non-ambiguous requests.
+
+    Args:
+        gates: Ordered sequence of gate instances to execute sequentially.
+        name: Identifier for this cascade pipeline.
+
+    Raises:
+        ValueError: If gates sequence is empty.
+    """
+
+    def __init__(self, gates: Sequence[BaseGate], name: str = "Cascade") -> None:
+        if not gates:
+            raise ValueError("Cascade requires at least one gate")
+        self.gates = list(gates)
+        self.name = name
+
+    def __repr__(self) -> str:
+        pipeline_repr = " >> ".join(repr(g) for g in self.gates)
+        return f"Cascade([{pipeline_repr}])"
+
+    def _handle_failure_snapshot(
+        self, candidate: Any, verdict: Verdict, current_rubric: str | None = None, **kwargs: Any
+    ) -> Verdict:
+        if verdict.passed:
+            return verdict
+
+        save_on_fail = kwargs.get("save_on_fail")
+        from logitgate.config import get_default_save_failures
+        should_save = save_on_fail if save_on_fail is not None else get_default_save_failures()
+        if not should_save:
+            return verdict
+
+        if verdict.traces and "snapshot_path" in verdict.traces[-1].metadata:
+            return verdict
+
+        from logitgate.backends.base import infer_backend_spec
+        from logitgate.snapshot import VerdictSnapshot
+        rubric = current_rubric or getattr(self.gates[0], "rubric", None) or "Cascade evaluation"
+        gate_config: dict[str, Any] = {"cascade_gates": [g.name for g in self.gates]}
+        for g in self.gates:
+            if isinstance(g, LogitGate):
+                gate_config.update({
+                    "rubric": g.rubric,
+                    "backend": infer_backend_spec(g.backend),
+                    "pass_threshold": g.pass_threshold,
+                    "fail_threshold": g.fail_threshold,
+                    "symmetric_debiasing": g.symmetric_debiasing,
+                    "logit_temperature": g.logit_temperature,
+                })
+                if g.model:
+                    gate_config["model"] = g.model
+                break
+
+        test_name = kwargs.get("test_name")
+        snapshot = VerdictSnapshot.from_verdict(
+            verdict=verdict,
+            rubric=rubric,
+            candidate=candidate,
+            test_name=test_name,
+            gate_config=gate_config,
+        )
+        saved_path = snapshot.save(directory=kwargs.get("snapshot_dir"))
+        if verdict.traces:
+            verdict.traces[-1].metadata["snapshot_path"] = str(saved_path)
+        return verdict
+
+    def evaluate(self, candidate: Any, **kwargs: Any) -> Verdict:
+        t0 = time.perf_counter()
+        all_traces: list[LayerTrace] = []
+        total_tokens = 0
+        current_rubric = None
+        last_verdict: Verdict | None = None
+        gate_kwargs = dict(kwargs)
+        gate_kwargs["save_on_fail"] = False
+
+        for i, gate in enumerate(self.gates):
+            # 1. Deterministic Layer 0 Gate
+            if isinstance(gate, (ASTGate, ContractGate)):
+                verdict = gate.evaluate(candidate, **gate_kwargs)
+                all_traces.extend(verdict.traces)
+                total_tokens += verdict.total_tokens_generated
+                last_verdict = verdict
+
+                if not verdict.passed:
+                    total_latency = (time.perf_counter() - t0) * 1000.0
+                    final_v = Verdict(
+                        passed=False,
+                        status=DecisionStatus.FAILED,
+                        triggered_layer=gate.name,
+                        total_latency_ms=total_latency,
+                        total_tokens_generated=total_tokens,
+                        reason=verdict.reason,
+                        traces=all_traces,
+                    )
+                    return self._handle_failure_snapshot(candidate, final_v, current_rubric, **kwargs)
+
+            # 2. First-Token Logit Gate Layer 1
+            elif isinstance(gate, LogitGate):
+                current_rubric = gate.rubric
+                verdict = gate.evaluate(candidate, **gate_kwargs)
+                all_traces.extend(verdict.traces)
+                total_tokens += verdict.total_tokens_generated
+                last_verdict = verdict
+
+                if verdict.status == DecisionStatus.PASSED:
+                    # Fast-path pass: short-circuit Layer 2 entirely!
+                    total_latency = (time.perf_counter() - t0) * 1000.0
+                    return Verdict(
+                        passed=True,
+                        status=DecisionStatus.PASSED,
+                        probability=verdict.probability,
+                        triggered_layer=gate.name,
+                        total_latency_ms=total_latency,
+                        total_tokens_generated=total_tokens,
+                        reason=f"Fast-path pass at {gate.name}: P={verdict.probability:.4f}",
+                        traces=all_traces,
+                    )
+
+                # Check lookahead to next JudgeGate
+                if i + 1 < len(self.gates):
+                    next_judge = self.gates[i + 1]
+                    if isinstance(next_judge, JudgeGate):
+                        if verdict.status == DecisionStatus.FAILED and next_judge.trigger == "on_ambiguous_only":
+                            total_latency = (time.perf_counter() - t0) * 1000.0
+                            final_v = Verdict(
+                                passed=False,
+                                status=DecisionStatus.FAILED,
+                                probability=verdict.probability,
+                                triggered_layer=gate.name,
+                                total_latency_ms=total_latency,
+                                total_tokens_generated=total_tokens,
+                                reason=f"Decisive failure at {gate.name}: P={verdict.probability:.4f}",
+                                traces=all_traces,
+                            )
+                            return self._handle_failure_snapshot(candidate, final_v, current_rubric, **kwargs)
+                        # Escalate to JudgeGate
+                        continue
+
+            # 3. Generative Reasoning Judge Layer 2
+            elif isinstance(gate, JudgeGate):
+                prev_prob = None
+                prev_status = None
+                for tr in reversed(all_traces):
+                    if tr.calibrated_prob is not None:
+                        prev_prob = tr.calibrated_prob
+                        prev_status = tr.status
+                        break
+
+                verdict = gate.evaluate(candidate, rubric_override=current_rubric, **gate_kwargs)
+                all_traces.extend(verdict.traces)
+                total_tokens += verdict.total_tokens_generated
+                last_verdict = verdict
+
+                total_latency = (time.perf_counter() - t0) * 1000.0
+                if prev_status == DecisionStatus.FAILED and gate.trigger == "on_ambiguous_or_fail":
+                    final_passed = False
+                    final_status = DecisionStatus.FAILED
+                else:
+                    final_passed = verdict.passed
+                    final_status = verdict.status
+
+                final_v = Verdict(
+                    passed=final_passed,
+                    status=final_status,
+                    probability=prev_prob,
+                    score=verdict.score,
+                    triggered_layer=gate.name,
+                    total_latency_ms=total_latency,
+                    total_tokens_generated=total_tokens,
+                    reason=verdict.reason,
+                    traces=all_traces,
+                )
+                return self._handle_failure_snapshot(candidate, final_v, current_rubric, **kwargs)
+
+            # 4. Generic Gate
+            else:
+                verdict = gate.evaluate(candidate, **gate_kwargs)
+                all_traces.extend(verdict.traces)
+                total_tokens += verdict.total_tokens_generated
+                last_verdict = verdict
+                if not verdict.passed and i == len(self.gates) - 1:
+                    total_latency = (time.perf_counter() - t0) * 1000.0
+                    final_v = Verdict(
+                        passed=False,
+                        status=verdict.status,
+                        probability=verdict.probability,
+                        score=verdict.score,
+                        choice=verdict.choice,
+                        choice_probabilities=verdict.choice_probabilities,
+                        triggered_layer=gate.name,
+                        total_latency_ms=total_latency,
+                        total_tokens_generated=total_tokens,
+                        reason=verdict.reason,
+                        traces=all_traces,
+                    )
+                    return self._handle_failure_snapshot(candidate, final_v, current_rubric, **kwargs)
+
+        total_latency = (time.perf_counter() - t0) * 1000.0
+        if last_verdict is not None:
+            final_v = Verdict(
+                passed=last_verdict.passed,
+                status=last_verdict.status,
+                probability=last_verdict.probability,
+                score=last_verdict.score,
+                choice=last_verdict.choice,
+                choice_probabilities=last_verdict.choice_probabilities,
+                triggered_layer=last_verdict.triggered_layer,
+                total_latency_ms=total_latency,
+                total_tokens_generated=total_tokens,
+                reason=last_verdict.reason,
+                traces=all_traces,
+            )
+            return self._handle_failure_snapshot(candidate, final_v, current_rubric, **kwargs)
+
+        return Verdict(
+            passed=True,
+            status=DecisionStatus.PASSED,
+            triggered_layer=self.name,
+            total_latency_ms=total_latency,
+            total_tokens_generated=total_tokens,
+            traces=all_traces,
+        )
+
+    async def aevaluate(self, candidate: Any, **kwargs: Any) -> Verdict:
+        t0 = time.perf_counter()
+        all_traces: list[LayerTrace] = []
+        total_tokens = 0
+        current_rubric = None
+        last_verdict: Verdict | None = None
+        gate_kwargs = dict(kwargs)
+        gate_kwargs["save_on_fail"] = False
+
+        for i, gate in enumerate(self.gates):
+            if isinstance(gate, (ASTGate, ContractGate)):
+                verdict = await gate.aevaluate(candidate, **gate_kwargs)
+                all_traces.extend(verdict.traces)
+                total_tokens += verdict.total_tokens_generated
+                last_verdict = verdict
+
+                if not verdict.passed:
+                    total_latency = (time.perf_counter() - t0) * 1000.0
+                    final_v = Verdict(
+                        passed=False,
+                        status=DecisionStatus.FAILED,
+                        triggered_layer=gate.name,
+                        total_latency_ms=total_latency,
+                        total_tokens_generated=total_tokens,
+                        reason=verdict.reason,
+                        traces=all_traces,
+                    )
+                    return self._handle_failure_snapshot(candidate, final_v, current_rubric, **kwargs)
+
+            elif isinstance(gate, LogitGate):
+                current_rubric = gate.rubric
+                verdict = await gate.aevaluate(candidate, **gate_kwargs)
+                all_traces.extend(verdict.traces)
+                total_tokens += verdict.total_tokens_generated
+                last_verdict = verdict
+
+                if verdict.status == DecisionStatus.PASSED:
+                    total_latency = (time.perf_counter() - t0) * 1000.0
+                    return Verdict(
+                        passed=True,
+                        status=DecisionStatus.PASSED,
+                        probability=verdict.probability,
+                        triggered_layer=gate.name,
+                        total_latency_ms=total_latency,
+                        total_tokens_generated=total_tokens,
+                        reason=f"Fast-path pass at {gate.name}: P={verdict.probability:.4f}",
+                        traces=all_traces,
+                    )
+
+                if i + 1 < len(self.gates):
+                    next_judge = self.gates[i + 1]
+                    if isinstance(next_judge, JudgeGate):
+                        if verdict.status == DecisionStatus.FAILED and next_judge.trigger == "on_ambiguous_only":
+                            total_latency = (time.perf_counter() - t0) * 1000.0
+                            final_v = Verdict(
+                                passed=False,
+                                status=DecisionStatus.FAILED,
+                                probability=verdict.probability,
+                                triggered_layer=gate.name,
+                                total_latency_ms=total_latency,
+                                total_tokens_generated=total_tokens,
+                                reason=f"Decisive failure at {gate.name}: P={verdict.probability:.4f}",
+                                traces=all_traces,
+                            )
+                            return self._handle_failure_snapshot(candidate, final_v, current_rubric, **kwargs)
+                        continue
+
+            elif isinstance(gate, JudgeGate):
+                prev_prob = None
+                prev_status = None
+                for tr in reversed(all_traces):
+                    if tr.calibrated_prob is not None:
+                        prev_prob = tr.calibrated_prob
+                        prev_status = tr.status
+                        break
+
+                verdict = await gate.aevaluate(candidate, rubric_override=current_rubric, **gate_kwargs)
+                all_traces.extend(verdict.traces)
+                total_tokens += verdict.total_tokens_generated
+                last_verdict = verdict
+
+                total_latency = (time.perf_counter() - t0) * 1000.0
+                if prev_status == DecisionStatus.FAILED and gate.trigger == "on_ambiguous_or_fail":
+                    final_passed = False
+                    final_status = DecisionStatus.FAILED
+                else:
+                    final_passed = verdict.passed
+                    final_status = verdict.status
+
+                final_v = Verdict(
+                    passed=final_passed,
+                    status=final_status,
+                    probability=prev_prob,
+                    score=verdict.score,
+                    triggered_layer=gate.name,
+                    total_latency_ms=total_latency,
+                    total_tokens_generated=total_tokens,
+                    reason=verdict.reason,
+                    traces=all_traces,
+                )
+                return self._handle_failure_snapshot(candidate, final_v, current_rubric, **kwargs)
+
+            else:
+                verdict = await gate.aevaluate(candidate, **gate_kwargs)
+                all_traces.extend(verdict.traces)
+                total_tokens += verdict.total_tokens_generated
+                last_verdict = verdict
+                if not verdict.passed and i == len(self.gates) - 1:
+                    total_latency = (time.perf_counter() - t0) * 1000.0
+                    final_v = Verdict(
+                        passed=False,
+                        status=verdict.status,
+                        probability=verdict.probability,
+                        score=verdict.score,
+                        choice=verdict.choice,
+                        choice_probabilities=verdict.choice_probabilities,
+                        triggered_layer=gate.name,
+                        total_latency_ms=total_latency,
+                        total_tokens_generated=total_tokens,
+                        reason=verdict.reason,
+                        traces=all_traces,
+                    )
+                    return self._handle_failure_snapshot(candidate, final_v, current_rubric, **kwargs)
+
+        total_latency = (time.perf_counter() - t0) * 1000.0
+        if last_verdict is not None:
+            final_v = Verdict(
+                passed=last_verdict.passed,
+                status=last_verdict.status,
+                probability=last_verdict.probability,
+                score=last_verdict.score,
+                choice=last_verdict.choice,
+                choice_probabilities=last_verdict.choice_probabilities,
+                triggered_layer=last_verdict.triggered_layer,
+                total_latency_ms=total_latency,
+                total_tokens_generated=total_tokens,
+                reason=last_verdict.reason,
+                traces=all_traces,
+            )
+            return self._handle_failure_snapshot(candidate, final_v, current_rubric, **kwargs)
+
+        return Verdict(
+            passed=True,
+            status=DecisionStatus.PASSED,
+            triggered_layer=self.name,
+            total_latency_ms=total_latency,
+            total_tokens_generated=total_tokens,
+            traces=all_traces,
+        )