crca 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

crca_core/timeseries/pcmci.py

@@ -0,0 +1,181 @@
+"""Time-series causal discovery via Tigramite PCMCI/PCMCI+ (wrap-first).
+
+If Tigramite is not installed, this module returns a structured refusal.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import BaseModel, Field
+
+from crca_core.models.provenance import ProvenanceManifest
+from crca_core.models.refusal import RefusalChecklistItem, RefusalReasonCode, RefusalResult
+from crca_core.models.result import DiscoveryHypothesisResult
+from utils.canonical import stable_hash
+
+
+class PCMCIConfig(BaseModel):
+    max_lag: int = Field(default=5, ge=1)
+    alpha: float = Field(default=0.05, gt=0.0, lt=1.0)
+    variant: Literal["pcmci", "pcmci_plus"] = "pcmci"
+    time_index_column: Optional[str] = None
+    assume_sorted: bool = False
+    min_samples: int = Field(default=200, ge=20)
+    notes: Optional[str] = None
+
+
+def _tigramite_available() -> bool:
+    try:
+        import importlib.util
+
+        return importlib.util.find_spec("tigramite") is not None
+    except Exception:
+        return False
+
+
+def discover_timeseries_pcmci(
+    data: Any,
+    config: Optional[PCMCIConfig] = None,
+    assumptions: Optional[List[str]] = None,
+) -> DiscoveryHypothesisResult | RefusalResult:
+    cfg = config or PCMCIConfig()
+    assumptions = assumptions or []
+
+    # Schema-only signature for provenance (no raw data hashing by default).
+    schema_sig: Dict[str, Any] = {}
+    try:
+        import pandas as pd  # type: ignore
+
+        if isinstance(data, pd.DataFrame):
+            schema_sig = {c: str(t) for c, t in data.dtypes.items()}
+        else:
+            schema_sig = {"type": str(type(data))}
+    except Exception:
+        schema_sig = {"type": str(type(data))}
+
+    spec_hash = stable_hash({"discovery": "pcmci", "config": cfg.model_dump(), "schema": schema_sig})
+    prov = ProvenanceManifest.minimal(
+        spec_hash=spec_hash,
+        data_hash=stable_hash(schema_sig),
+        algorithm_config=cfg.model_dump(),
+    )
+
+    if not _tigramite_available():
+        return RefusalResult(
+            message="Time-series causal discovery backend (tigramite) not available.",
+            reason_codes=[RefusalReasonCode.UNSUPPORTED_OPERATION],
+            checklist=[
+                RefusalChecklistItem(
+                    item="Install tigramite",
+                    rationale="PCMCI/PCMCI+ discovery is wrap-first; we refuse rather than run unvalidated heuristics.",
+                )
+            ],
+            suggested_next_steps=["pip install tigramite"],
+        )
+
+    try:
+        import pandas as pd  # type: ignore
+        import numpy as np  # type: ignore
+        from tigramite import data_processing as pp  # type: ignore
+        from tigramite.pcmci import PCMCI  # type: ignore
+        from tigramite.independence_tests import ParCorr  # type: ignore
+    except Exception as e:
+        return RefusalResult(
+            message=f"Failed to import tigramite: {e}",
+            reason_codes=[RefusalReasonCode.UNSUPPORTED_OPERATION],
+            checklist=[
+                RefusalChecklistItem(
+                    item="Install tigramite",
+                    rationale="PCMCI/PCMCI+ discovery requires tigramite backend.",
+                )
+            ],
+            suggested_next_steps=["pip install tigramite"],
+        )
+
+    if not isinstance(data, pd.DataFrame):
+        return RefusalResult(
+            message="PCMCI requires pandas DataFrame input.",
+            reason_codes=[RefusalReasonCode.INPUT_INVALID],
+            checklist=[
+                RefusalChecklistItem(
+                    item="Provide pandas DataFrame",
+                    rationale="Tigramite expects tabular time-indexed data.",
+                )
+            ],
+            suggested_next_steps=["Convert your data to pandas.DataFrame and retry."],
+        )
+
+    df = data.copy()
+    if cfg.time_index_column:
+        if cfg.time_index_column not in df.columns:
+            return RefusalResult(
+                message="time_index_column not found in data.",
+                reason_codes=[RefusalReasonCode.TIME_INDEX_INVALID],
+                checklist=[
+                    RefusalChecklistItem(
+                        item="Provide valid time index column",
+                        rationale="PCMCI requires a consistent time index.",
+                    )
+                ],
+                suggested_next_steps=["Set PCMCIConfig.time_index_column to a valid column."],
+            )
+        df = df.sort_values(cfg.time_index_column)
+    elif not cfg.assume_sorted:
+        # If no column specified, require index monotonicity
+        try:
+            if not df.index.is_monotonic_increasing:
+                return RefusalResult(
+                    message="DataFrame index is not monotonic; provide a time index column or sort data.",
+                    reason_codes=[RefusalReasonCode.TIME_INDEX_INVALID],
+                    checklist=[
+                        RefusalChecklistItem(
+                            item="Provide time index or sorted data",
+                            rationale="PCMCI requires time-ordered samples.",
+                        )
+                    ],
+                    suggested_next_steps=["Sort by time or set PCMCIConfig.time_index_column."],
+                )
+        except Exception:
+            pass
+
+    values = df.to_numpy(dtype=float)
+    if values.shape[0] < cfg.min_samples:
+        return RefusalResult(
+            message="Insufficient samples for PCMCI discovery.",
+            reason_codes=[RefusalReasonCode.INPUT_INVALID],
+            checklist=[
+                RefusalChecklistItem(
+                    item="Increase sample size",
+                    rationale=f"Need at least {cfg.min_samples} rows for stable lagged discovery.",
+                )
+            ],
+            suggested_next_steps=["Collect more samples or lower min_samples (not recommended)."],
+        )
+    dataframe = pp.DataFrame(values)
+    pcmci = PCMCI(dataframe=dataframe, cond_ind_test=ParCorr())
+
+    if cfg.variant == "pcmci_plus":
+        results = pcmci.run_pcmciplus(tau_max=cfg.max_lag, pc_alpha=cfg.alpha)
+    else:
+        results = pcmci.run_pcmci(tau_max=cfg.max_lag, pc_alpha=cfg.alpha)
+
+    graph_hypothesis = {
+        "graph_type": "pcmci",
+        "method": cfg.variant,
+        "max_lag": cfg.max_lag,
+        "graph": results.get("graph"),
+        "val_matrix": results.get("val_matrix"),
+    }
+
+    return DiscoveryHypothesisResult(
+        provenance=prov,
+        assumptions=assumptions,
+        limitations=[
+            "Time-series discovery is hypothesis generation under explicit assumptions (stationarity, lag sufficiency, no hidden confounding, etc.).",
+            "Returned graph depends on CI test assumptions and lag selection.",
+        ],
+        graph_hypothesis=graph_hypothesis,
+        stability_report={"alpha": cfg.alpha},
+    )
+

crca_llm/__init__.py

@@ -0,0 +1,12 @@
+"""crca_llm: non-authoritative LLM coauthor layer.
+
+This package is intentionally optional and must never emit numeric causal
+outputs on its own. It drafts specs and checklists only.
+"""
+
+from crca_llm.coauthor import CoauthorConfig, DraftBundle, LLMCoauthor
+from crca_llm.orchestrator import LLMOrchestrator
+from crca_llm.types import LLMRunResult
+
+__all__ = ["CoauthorConfig", "DraftBundle", "LLMCoauthor", "LLMOrchestrator", "LLMRunResult"]
+

crca_llm/client.py

@@ -0,0 +1,85 @@
+"""OpenAI-compatible client for crca_llm (chat completions only)."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+import time
+import random
+from loguru import logger
+from typing import Any, Dict, List, Optional
+
+import requests
+
+
+class MissingApiKeyError(RuntimeError):
+    pass
+
+
+@dataclass
+class OpenAIClient:
+    base_url: str = "https://api.openai.com"
+    api_key: Optional[str] = None
+    default_model: str = "gpt-4o-mini"
+    max_retries: int = 3
+    timeout_seconds: int = 60
+    enable_audit_log: bool = True
+
+    @classmethod
+    def from_env(cls) -> "OpenAIClient":
+        base_url = os.environ.get("OPENAI_BASE_URL", "https://api.openai.com")
+        api_key = os.environ.get("OPENAI_API_KEY")
+        model = os.environ.get("OPENAI_MODEL", "gpt-4o-mini")
+        return cls(base_url=base_url, api_key=api_key, default_model=model)
+
+    def _require_key(self) -> None:
+        if not self.api_key:
+            raise MissingApiKeyError("OPENAI_API_KEY is required for LLM calls.")
+
+    def chat_completion(
+        self,
+        *,
+        messages: List[Dict[str, Any]],
+        model: Optional[str] = None,
+        temperature: float = 0.0,
+        max_tokens: int = 800,
+        response_format: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """Send a chat completion request and return the text response."""
+        self._require_key()
+        url = self.base_url.rstrip("/") + "/v1/chat/completions"
+        payload: Dict[str, Any] = {
+            "model": model or self.default_model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        if response_format is not None:
+            payload["response_format"] = response_format
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+        attempt = 0
+        while True:
+            try:
+                if self.enable_audit_log:
+                    logger.info(
+                        "LLM request model={} tokens={} messages={}",
+                        payload["model"],
+                        max_tokens,
+                        len(messages),
+                    )
+                resp = requests.post(url, json=payload, headers=headers, timeout=self.timeout_seconds)
+                resp.raise_for_status()
+                data = resp.json()
+                return data["choices"][0]["message"]["content"]
+            except requests.RequestException as exc:
+                attempt += 1
+                if attempt > self.max_retries:
+                    raise
+                # exponential backoff with jitter
+                sleep_s = (2 ** (attempt - 1)) + random.uniform(0, 0.5)
+                time.sleep(sleep_s)
+

crca_llm/coauthor.py

@@ -0,0 +1,118 @@
+"""Non-authoritative LLM coauthor layer.
+
+This module is deliberately constrained:
+- It may draft candidate `DraftSpec` objects and review checklists.
+- It must never produce numeric causal outputs.
+- It must never create `LockedSpec` objects.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Sequence
+
+from pydantic import BaseModel, Field
+
+from crca_core.models.spec import (
+    AssumptionItem,
+    AssumptionSpec,
+    AssumptionStatus,
+    CausalGraphSpec,
+    DataColumnSpec,
+    DataSpec,
+    DraftSpec,
+    NodeSpec,
+    RoleSpec,
+)
+
+
+class CoauthorConfig(BaseModel):
+    model: str = Field(default="gpt-4o-mini")
+    n_candidates: int = Field(default=3, ge=1, le=5)
+
+
+class DraftBundle(BaseModel):
+    """LLM coauthor output: draft specs + checklists (no numbers)."""
+
+    drafts: List[DraftSpec]
+    review_checklist: List[str] = Field(default_factory=list)
+    disclaimers: List[str] = Field(
+        default_factory=lambda: [
+            "DRAFT-NON-AUTHORITATIVE: This spec is a hypothesis and must be reviewed/locked by a human.",
+            "No numeric causal claims are produced by the coauthor layer.",
+        ]
+    )
+
+
+def _default_checklist() -> List[str]:
+    return [
+        "Define treatment and outcome variables explicitly.",
+        "Confirm time ordering (what can cause what).",
+        "List plausible confounders and whether they are measured.",
+        "Check for collider variables that must not be adjusted for.",
+        "Define intervention semantics (set vs shift vs mechanism-change) if counterfactuals are needed.",
+        "State discovery assumptions if running causal discovery (faithfulness, causal sufficiency/latent confounding).",
+    ]
+
+
+def _offline_draft(user_text: str, observed_columns: Optional[Sequence[str]], n: int) -> DraftBundle:
+    cols = list(observed_columns or [])
+    data_spec = DataSpec(
+        columns=[DataColumnSpec(name=c, dtype="unknown") for c in cols],
+        measurement_error_notes="unknown",
+    )
+
+    # Minimal placeholder graph: nodes from observed columns (no edges).
+    graph = CausalGraphSpec(nodes=[NodeSpec(name=c) for c in cols], edges=[])
+
+    assumptions = AssumptionSpec(
+        items=[
+            AssumptionItem(
+                name="DRAFT_ONLY",
+                status=AssumptionStatus.unknown,
+                description="This spec was generated offline without LLM; treat as a template only.",
+            )
+        ],
+        falsification_plan=[
+            "Collect domain constraints/time ordering and re-run drafting with an LLM (optional).",
+        ],
+    )
+
+    drafts = [
+        DraftSpec(
+            data=data_spec,
+            graph=graph,
+            roles=RoleSpec(),
+            assumptions=assumptions,
+            draft_notes=f"Offline draft template generated from observed columns. User text: {user_text[:200]}",
+        )
+        for _ in range(n)
+    ]
+    return DraftBundle(drafts=drafts, review_checklist=_default_checklist())
+
+
+@dataclass
+class LLMCoauthor:
+    """Coauthor that can draft candidate specs, but is never authoritative."""
+
+    config: CoauthorConfig = field(default_factory=CoauthorConfig)
+
+    def draft_specs(
+        self,
+        *,
+        user_text: str,
+        observed_columns: Optional[Sequence[str]] = None,
+    ) -> DraftBundle:
+        """Draft multiple candidate DraftSpec objects.
+
+        If no OpenAI API key is configured, returns an offline template bundle.
+        """
+
+        if os.environ.get("OPENAI_API_KEY") is None:
+            return _offline_draft(user_text, observed_columns, self.config.n_candidates)
+
+        # Online LLM drafting is intentionally not implemented yet in this repo’s default test environment.
+        # We return offline drafts to preserve deterministic behavior and avoid accidental numeric leakage.
+        return _offline_draft(user_text, observed_columns, self.config.n_candidates)
+

crca_llm/orchestrator.py

@@ -0,0 +1,289 @@
+"""LLM tool orchestration (DraftSpec-only + gated core calls)."""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Sequence
+
+from crca_core.core.api import (
+    EstimatorConfig,
+    FeasibilityConstraints,
+    PCMCIConfig,
+    TabularDiscoveryConfig,
+    TargetQuery,
+    discover_tabular,
+    discover_timeseries_pcmci,
+    design_intervention,
+    identify_effect,
+    estimate_effect_dowhy,
+    simulate_counterfactual,
+)
+from crca_core.models.refusal import RefusalChecklistItem, RefusalReasonCode, RefusalResult
+from crca_core.models.result import AnyResult, IdentificationResult
+from crca_core.models.spec import (
+    AssumptionItem,
+    AssumptionSpec,
+    AssumptionStatus,
+    CausalGraphSpec,
+    DataColumnSpec,
+    DataSpec,
+    DraftSpec,
+    EdgeSpec,
+    LockedSpec,
+    NodeSpec,
+    RoleSpec,
+)
+from crca_llm.client import MissingApiKeyError, OpenAIClient
+from crca_llm.coauthor import DraftBundle
+from crca_llm.types import LLMRunResult
+
+
+def _fallback_bundle(user_text: str, observed_columns: Optional[Sequence[str]]) -> DraftBundle:
+    cols = list(observed_columns or [])
+    data_spec = DataSpec(
+        columns=[DataColumnSpec(name=c, dtype="unknown") for c in cols],
+        measurement_error_notes="unknown",
+    )
+    graph = CausalGraphSpec(nodes=[NodeSpec(name=c) for c in cols], edges=[])
+    assumptions = AssumptionSpec(
+        items=[
+            AssumptionItem(
+                name="DRAFT_ONLY",
+                status=AssumptionStatus.unknown,
+                description="Fallback draft used due to LLM parse failure.",
+            )
+        ],
+        falsification_plan=["Collect domain constraints/time ordering and re-run drafting."],
+    )
+    drafts = [
+        DraftSpec(
+            data=data_spec,
+            graph=graph,
+            roles=RoleSpec(),
+            assumptions=assumptions,
+            draft_notes=f"Fallback draft from observed columns. User text: {user_text[:200]}",
+        )
+    ]
+    return DraftBundle(drafts=drafts, review_checklist=[])
+
+
+def _parse_llm_drafts(payload: dict) -> DraftBundle:
+    drafts_payload = payload.get("drafts", [])
+    drafts: List[DraftSpec] = []
+    for item in drafts_payload:
+        nodes = [NodeSpec(name=n) for n in item.get("nodes", [])]
+        edges = [EdgeSpec(source=a, target=b) for a, b in item.get("edges", [])]
+        graph = CausalGraphSpec(nodes=nodes, edges=edges)
+        roles = RoleSpec(
+            treatments=item.get("treatments", []),
+            outcomes=item.get("outcomes", []),
+            mediators=item.get("mediators", []),
+            instruments=item.get("instruments", []),
+            adjustment_candidates=item.get("adjustment_candidates", []),
+            prohibited_controls=item.get("prohibited_controls", []),
+        )
+        data_spec = DataSpec(
+            columns=[DataColumnSpec(name=c, dtype="unknown") for c in item.get("columns", [])],
+            measurement_error_notes="unknown",
+        )
+        assumptions = AssumptionSpec(items=[], falsification_plan=[])
+        drafts.append(DraftSpec(data=data_spec, graph=graph, roles=roles, assumptions=assumptions))
+    checklist = payload.get("review_checklist", [])
+    return DraftBundle(drafts=drafts, review_checklist=checklist)
+
+
+@dataclass
+class LLMOrchestrator:
+    client: Optional[OpenAIClient] = None
+    default_model: str = "gpt-4o-mini"
+    enable_audit_log: bool = True
+
+    def __post_init__(self) -> None:
+        env_model = os.getenv("CRCA_MOE_MODEL") or os.getenv("CRCA_LLM_MODEL")
+        if env_model:
+            self.default_model = env_model
+
+    def _draft_with_llm(self, user_text: str, observed_columns: Optional[Sequence[str]]) -> DraftBundle:
+        client = self.client or OpenAIClient.from_env()
+        client.enable_audit_log = self.enable_audit_log
+        prompt = {
+            "role": "user",
+            "content": (
+                "You are drafting causal specs. Return JSON with keys: "
+                "`drafts` (list), `review_checklist` (list). Each draft has: "
+                "`nodes` (list of strings), `edges` (list of [source,target]), "
+                "`treatments`, `outcomes`, `mediators`, `instruments`, "
+                "`adjustment_candidates`, `prohibited_controls`, `columns`.\n"
+                f"User text: {user_text}\n"
+                f"Observed columns: {list(observed_columns or [])}\n"
+                "Return JSON only."
+            ),
+        }
+        try:
+            content = client.chat_completion(
+                messages=[prompt],
+                model=self.default_model,
+                response_format={"type": "json_object"},
+            )
+        except MissingApiKeyError as exc:
+            raise
+
+        try:
+            payload = json.loads(content)
+            return _parse_llm_drafts(payload)
+        except Exception:
+            return _fallback_bundle(user_text, observed_columns)
+
+    def run(
+        self,
+        *,
+        user_text: str,
+        observed_columns: Optional[Sequence[str]] = None,
+        locked_spec: Optional[LockedSpec] = None,
+        data: Optional[Any] = None,
+        actions: Optional[Sequence[str]] = None,
+        target_query: Optional[TargetQuery] = None,
+        constraints: Optional[FeasibilityConstraints] = None,
+        factual_observation: Optional[Dict[str, float]] = None,
+        intervention: Optional[Dict[str, float]] = None,
+    ) -> LLMRunResult:
+        actions = list(actions or [])
+        refusals: List[RefusalResult] = []
+        core_results: List[AnyResult] = []
+
+        # Drafting is mandatory and requires API key.
+        try:
+            draft_bundle = self._draft_with_llm(user_text, observed_columns)
+        except MissingApiKeyError as exc:
+            refusal = RefusalResult(
+                message=str(exc),
+                reason_codes=[RefusalReasonCode.INPUT_INVALID],
+                checklist=[
+                    RefusalChecklistItem(
+                        item="Set OPENAI_API_KEY",
+                        rationale="LLM orchestration requires an API key.",
+                    )
+                ],
+                suggested_next_steps=["Export OPENAI_API_KEY and retry."],
+            )
+            return LLMRunResult(draft_bundle=DraftBundle(drafts=[], review_checklist=[]), refusals=[refusal])
+
+        if actions and locked_spec is None:
+            refusal = RefusalResult(
+                message="LockedSpec is required to run core tools.",
+                reason_codes=[RefusalReasonCode.SPEC_NOT_LOCKED],
+                checklist=[RefusalChecklistItem(item="Provide LockedSpec", rationale="Core tools are gated.")],
+                suggested_next_steps=["Lock a spec first, then re-run with locked_spec."],
+            )
+            refusals.append(refusal)
+            return LLMRunResult(draft_bundle=draft_bundle, refusals=refusals)
+
+        identification_result: IdentificationResult | None = None
+
+        for action in actions:
+            if action == "discover_tabular":
+                if data is None:
+                    refusals.append(
+                        RefusalResult(
+                            message="Tabular discovery requires data.",
+                            reason_codes=[RefusalReasonCode.INPUT_INVALID],
+                            checklist=[RefusalChecklistItem(item="Provide data", rationale="Missing DataFrame.")],
+                        )
+                    )
+                    continue
+                result = discover_tabular(data, TabularDiscoveryConfig())
+                core_results.append(result)
+                if isinstance(result, RefusalResult):
+                    refusals.append(result)
+            elif action == "discover_timeseries":
+                if data is None:
+                    refusals.append(
+                        RefusalResult(
+                            message="Time-series discovery requires data.",
+                            reason_codes=[RefusalReasonCode.INPUT_INVALID],
+                            checklist=[RefusalChecklistItem(item="Provide data", rationale="Missing DataFrame.")],
+                        )
+                    )
+                    continue
+                result = discover_timeseries_pcmci(data, PCMCIConfig())
+                core_results.append(result)
+                if isinstance(result, RefusalResult):
+                    refusals.append(result)
+            elif action == "design_intervention":
+                if target_query is None:
+                    refusals.append(
+                        RefusalResult(
+                            message="Intervention design requires TargetQuery.",
+                            reason_codes=[RefusalReasonCode.INPUT_INVALID],
+                            checklist=[RefusalChecklistItem(item="Provide TargetQuery", rationale="Missing target query.")],
+                        )
+                    )
+                    continue
+                result = design_intervention(
+                    locked_spec=locked_spec,
+                    target_query=target_query,
+                    constraints=constraints or FeasibilityConstraints(),
+                )
+                core_results.append(result)
+            elif action == "identify":
+                result = identify_effect(
+                    locked_spec=locked_spec,
+                    treatment=locked_spec.roles.treatments[0] if locked_spec.roles.treatments else "",
+                    outcome=locked_spec.roles.outcomes[0] if locked_spec.roles.outcomes else "",
+                )
+                core_results.append(result)
+                if isinstance(result, RefusalResult):
+                    refusals.append(result)
+                else:
+                    identification_result = result
+            elif action == "estimate":
+                if data is None:
+                    refusals.append(
+                        RefusalResult(
+                            message="Estimation requires data.",
+                            reason_codes=[RefusalReasonCode.INPUT_INVALID],
+                            checklist=[RefusalChecklistItem(item="Provide data", rationale="Missing DataFrame.")],
+                        )
+                    )
+                    continue
+                result = estimate_effect_dowhy(
+                    data=data,
+                    locked_spec=locked_spec,
+                    treatment=locked_spec.roles.treatments[0] if locked_spec.roles.treatments else "",
+                    outcome=locked_spec.roles.outcomes[0] if locked_spec.roles.outcomes else "",
+                    identification_result=identification_result,
+                    config=EstimatorConfig(),
+                )
+                core_results.append(result)
+                if isinstance(result, RefusalResult):
+                    refusals.append(result)
+            elif action == "counterfactual":
+                if factual_observation is None or intervention is None:
+                    refusals.append(
+                        RefusalResult(
+                            message="Counterfactual requires factual_observation and intervention.",
+                            reason_codes=[RefusalReasonCode.INPUT_INVALID],
+                            checklist=[
+                                RefusalChecklistItem(item="Provide factual_observation", rationale="Missing factual data."),
+                                RefusalChecklistItem(item="Provide intervention", rationale="Missing intervention."),
+                            ],
+                        )
+                    )
+                    continue
+                result = simulate_counterfactual(
+                    locked_spec=locked_spec,
+                    factual_observation=factual_observation,
+                    intervention=intervention,
+                )
+                core_results.append(result)
+                if isinstance(result, RefusalResult):
+                    refusals.append(result)
+
+        return LLMRunResult(
+            draft_bundle=draft_bundle,
+            core_results=core_results,
+            refusals=refusals,
+        )
+