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

scripts/run_crca_core_benchmarks.py

@@ -0,0 +1,163 @@
+"""Run `crca_core` synthetic benchmarks and emit structured JSON.
+
+This is a technical harness (not marketing). It should be runnable in CI/CD or
+locally and produce machine-parseable outputs with provenance.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+from crca_core.benchmarks.synthetic_scm import (
+    generate_latent_confounder_graph,
+    generate_lagged_timeseries,
+    generate_linear_gaussian_chain,
+)
+from crca_core.discovery import TabularDiscoveryConfig, discover_tabular
+from crca_core.identify import identify_effect
+from crca_core.core.lifecycle import lock_spec
+from crca_core.models.spec import CausalGraphSpec, DraftSpec, EdgeSpec, NodeSpec, RoleSpec
+from crca_core.timeseries import PCMCIConfig, discover_timeseries_pcmci
+from crca_core.models.provenance import ProvenanceManifest
+from crca_core.scm import LinearGaussianSCM
+from utils.canonical import stable_hash
+
+
+def run_linear_gaussian_chain() -> Dict[str, Any]:
+    spec, factual, noise = generate_linear_gaussian_chain(n_vars=4, beta=0.9, seed=1)
+    scm = LinearGaussianSCM.from_spec(spec)
+
+    abduced = scm.abduce_noise(factual)
+    max_abs_err = max(abs(abduced[k] - noise[k]) for k in noise.keys())
+
+    cf = scm.counterfactual(factual, interventions={"X0": factual["X0"] + 1.0})
+
+    prov = ProvenanceManifest.minimal(
+        spec_hash=stable_hash(
+            {
+                "benchmark": "linear_gaussian_chain",
+                "generator": {"n_vars": 4, "beta": 0.9, "seed": 1},
+                "scm_type": "linear_gaussian",
+            }
+        ),
+        algorithm_config={"benchmark": "linear_gaussian_chain"},
+        random_seeds={"numpy": 1},
+    )
+
+    return {
+        "result_type": "BenchmarkResult",
+        "benchmark": "linear_gaussian_chain",
+        "provenance": prov.model_dump(),
+        "metrics": {"abduction_max_abs_error": float(max_abs_err)},
+        "artifacts": {
+            "factual": factual,
+            "counterfactual": cf,
+            "notes": [
+                "This benchmark checks abduction correctness (noise recovery) under full observability.",
+                "Counterfactual uses abduction–action–prediction with fixed exogenous noise.",
+            ],
+        },
+    }
+
+
+def run_identification_benchmarks() -> Dict[str, Any]:
+    # Identifiable (simple chain)
+    draft = DraftSpec(
+        graph=CausalGraphSpec(
+            nodes=[NodeSpec(name="X"), NodeSpec(name="Y")],
+            edges=[EdgeSpec(source="X", target="Y")],
+        ),
+        roles=RoleSpec(treatments=["X"], outcomes=["Y"]),
+    )
+    locked = lock_spec(draft, approvals=["human"])
+    ident_simple = identify_effect(locked_spec=locked, treatment="X", outcome="Y")
+
+    # Latent confounder (non-identifiable in conservative ID)
+    latent_graph = generate_latent_confounder_graph()
+    draft_latent = DraftSpec(
+        graph=latent_graph,
+        roles=RoleSpec(treatments=["X"], outcomes=["Y"]),
+    )
+    locked_latent = lock_spec(draft_latent, approvals=["human"])
+    ident_latent = identify_effect(locked_spec=locked_latent, treatment="X", outcome="Y")
+
+    def _dump(obj: Any) -> Dict[str, Any]:
+        return obj.model_dump() if hasattr(obj, "model_dump") else {"value": str(obj)}
+
+    return {
+        "result_type": "BenchmarkResult",
+        "benchmark": "identification",
+        "provenance": ProvenanceManifest.minimal(
+            spec_hash=stable_hash({"benchmark": "identification"})
+        ).model_dump(),
+        "metrics": {},
+        "artifacts": {
+            "identifiable_case": _dump(ident_simple),
+            "latent_confounder_case": _dump(ident_latent),
+        },
+    }
+
+
+def run_discovery_benchmarks() -> Dict[str, Any]:
+    # Tabular discovery
+    import pandas as pd
+    import numpy as np
+
+    rng = np.random.default_rng(0)
+    n = 200
+    x = rng.normal(size=n)
+    y = 2.0 * x + rng.normal(size=n)
+    df = pd.DataFrame({"X": x, "Y": y})
+    tabular = discover_tabular(df, TabularDiscoveryConfig(algorithm="pc", alpha=0.05))
+
+    # Time-series discovery
+    ts, cols = generate_lagged_timeseries(n_steps=200, seed=1)
+    ts_df = pd.DataFrame(ts, columns=cols)
+    ts_res = discover_timeseries_pcmci(
+        ts_df, PCMCIConfig(max_lag=3, alpha=0.05, assume_sorted=True)
+    )
+
+    def _dump(obj: Any) -> Dict[str, Any]:
+        return obj.model_dump() if hasattr(obj, "model_dump") else {"value": str(obj)}
+
+    return {
+        "result_type": "BenchmarkResult",
+        "benchmark": "discovery",
+        "provenance": ProvenanceManifest.minimal(
+            spec_hash=stable_hash({"benchmark": "discovery"})
+        ).model_dump(),
+        "metrics": {},
+        "artifacts": {
+            "tabular": _dump(tabular),
+            "timeseries": _dump(ts_res),
+        },
+    }
+
+
+def main() -> None:
+    results = {
+        "benchmarks": [
+            run_linear_gaussian_chain(),
+            run_identification_benchmarks(),
+            run_discovery_benchmarks(),
+        ]
+    }
+
+    out_dir = REPO_ROOT / "benchmark_results"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_path = out_dir / "crca_core_benchmarks.json"
+    out_path.write_text(json.dumps(results, indent=2), encoding="utf-8")
+
+    print(str(out_path))
+
+
+if __name__ == "__main__":
+    main()
+

scripts/run_full_finetune.py

@@ -0,0 +1,198 @@
+"""Run full finetune for Qwen2.5 models with CRCA-optimized configurations."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+from training.finetune import (
+    FinetuneConfig,
+    full_finetune_qwen25_0_5b_config,
+    full_finetune_qwen25_0_5b_config_cloud,
+    full_finetune_qwen25_1_5b_config,
+    full_finetune_qwen25_7b_config,
+    full_finetune_qwen25_14b_config,
+    run_finetune,
+)
+
+
+def _infer_model_key(base_model: str) -> str:
+    model = base_model.lower()
+    if "14b" in model:
+        return "14b"
+    if "7b" in model:
+        return "7b"
+    if "1.5b" in model:
+        return "1.5b"
+    if "0.5b" in model:
+        return "0.5b"
+    return "unknown"
+
+
+def _apply_auto_config(cfg: FinetuneConfig, args: argparse.Namespace) -> None:
+    if getattr(args, "no_auto_config", False):
+        return
+    try:
+        import torch
+    except Exception:
+        return
+
+    if not torch.cuda.is_available():
+        return
+
+    device_count = torch.cuda.device_count()
+    device_name = torch.cuda.get_device_name(0)
+    total_mem_gb = torch.cuda.get_device_properties(0).total_memory / (1024**3)
+    bf16_supported = torch.cuda.is_bf16_supported()
+
+    if bf16_supported:
+        cfg.bf16 = True
+        cfg.fp16 = False
+
+    # DeepSpeed config selection for multi-GPU NVIDIA setups
+    if device_count > 1 and args.deepspeed_config is None:
+        if total_mem_gb >= 60:
+            cfg.deepspeed_config = str((REPO_ROOT / "training" / "deepspeed_zero3_h100_3gpu.json").resolve())
+        else:
+            cfg.deepspeed_config = str((REPO_ROOT / "training" / "deepspeed_zero3_offload.json").resolve())
+
+    # Batch/grad/seq tuning for high-memory NVIDIA GPUs
+    model_key = _infer_model_key(cfg.base_model)
+    if total_mem_gb >= 60 and model_key != "unknown":
+        if model_key == "1.5b":
+            cfg.per_device_batch_size = 16
+            if args.grad_accum is None:
+                cfg.gradient_accumulation_steps = 8
+            cfg.max_seq_length = 8192
+        elif model_key == "7b":
+            cfg.per_device_batch_size = 8
+            if args.grad_accum is None:
+                cfg.gradient_accumulation_steps = 16
+            cfg.max_seq_length = 4096
+        elif model_key == "14b":
+            cfg.per_device_batch_size = 4
+            if args.grad_accum is None:
+                cfg.gradient_accumulation_steps = 32
+            cfg.max_seq_length = 2048
+        elif model_key == "0.5b":
+            cfg.per_device_batch_size = 32
+            if args.grad_accum is None:
+                cfg.gradient_accumulation_steps = 4
+            cfg.max_seq_length = 4096
+
+    print(
+        f"Auto-config: gpu={device_name}, count={device_count}, mem={total_mem_gb:.0f}GB, "
+        f"bf16={'on' if cfg.bf16 else 'off'}, ds={'on' if cfg.deepspeed_config else 'off'}"
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Run full finetune for Qwen2.5 models (1.5B, 7B, 14B) with CRCA-optimized configurations."
+    )
+    parser.add_argument("--train-file", type=str, required=True, help="Path to training JSONL.")
+    parser.add_argument("--eval-file", type=str, default=None, help="Optional eval JSONL.")
+    parser.add_argument("--output-dir", type=str, default=None, help="Output directory.")
+    parser.add_argument("--epochs", type=int, default=None, help="Override num_train_epochs.")
+    parser.add_argument("--grad-accum", type=int, default=None, help="Override gradient accumulation.")
+    parser.add_argument(
+        "--model-size",
+        type=str,
+        choices=["0.5b", "1.5b", "7b", "14b"],
+        default="0.5b",
+        help="Model size to finetune: 0.5b, 1.5b, 7b, or 14b. Default: 0.5b",
+    )
+    parser.add_argument(
+        "--cloud",
+        action="store_true",
+        help="Use cloud-optimized config (only for 0.5B model). For other sizes, configs are already cloud-optimized.",
+    )
+    parser.add_argument(
+        "--model-id",
+        type=str,
+        default=None,
+        help="Override base model ID (e.g. google/switch-base-8 for MoE Seq2Seq training).",
+    )
+    parser.add_argument(
+        "--deepspeed-config",
+        type=str,
+        default=None,
+        help="Override DeepSpeed config path (e.g. training/deepspeed_zero3_h100_3gpu.json for 3x H100 ZeRO-3).",
+    )
+    parser.add_argument(
+        "--local-rank",
+        "--local_rank",
+        type=int,
+        default=-1,
+        dest="local_rank",
+        help="Local rank for distributed training (set by DeepSpeed launcher).",
+    )
+    parser.add_argument(
+        "--no-auto-config",
+        action="store_true",
+        help="Disable automatic GPU-based configuration tuning.",
+    )
+    args = parser.parse_args()
+
+    # Map model sizes to config functions
+    config_map = {
+        "0.5b": full_finetune_qwen25_0_5b_config_cloud if args.cloud else full_finetune_qwen25_0_5b_config,
+        "1.5b": full_finetune_qwen25_1_5b_config,
+        "7b": full_finetune_qwen25_7b_config,
+        "14b": full_finetune_qwen25_14b_config,
+    }
+    
+    # Get the appropriate config function
+    config_func = config_map.get(args.model_size.lower())
+    if config_func is None:
+        raise ValueError(f"Invalid model size: {args.model_size}. Choose from: 0.5b, 1.5b, 7b, 14b")
+    
+    cfg = config_func()
+    if args.model_id:
+        cfg.base_model = args.model_id
+    cfg.train_file = args.train_file
+    # Only set eval_file if explicitly provided and file exists
+    if args.eval_file:
+        if not Path(args.eval_file).exists():
+            raise FileNotFoundError(f"Eval file not found: {args.eval_file}")
+        cfg.eval_file = args.eval_file
+    if args.output_dir:
+        cfg.output_dir = args.output_dir
+    if args.epochs is not None:
+        cfg.num_train_epochs = args.epochs
+    if args.grad_accum is not None:
+        cfg.gradient_accumulation_steps = args.grad_accum
+    _apply_auto_config(cfg, args)
+    if args.deepspeed_config is None and cfg.deepspeed_config:
+        args.deepspeed_config = cfg.deepspeed_config
+    if args.deepspeed_config:
+        ds_path = Path(args.deepspeed_config)
+        if not ds_path.is_absolute():
+            ds_path = REPO_ROOT / ds_path
+        if not ds_path.exists():
+            raise FileNotFoundError(f"DeepSpeed config not found: {args.deepspeed_config}")
+        cfg.deepspeed_config = str(ds_path.resolve())
+        try:
+            ds_config = json.loads(Path(cfg.deepspeed_config).read_text())
+            bf16_enabled = bool(ds_config.get("bf16", {}).get("enabled", False))
+            fp16_enabled = bool(ds_config.get("fp16", {}).get("enabled", False))
+            if bf16_enabled and not fp16_enabled:
+                cfg.bf16 = True
+                cfg.fp16 = False
+        except Exception:
+            pass
+
+    if cfg.deepspeed_config and not Path(cfg.deepspeed_config).exists():
+        raise FileNotFoundError(f"Missing deepspeed config: {cfg.deepspeed_config}")
+
+    run_finetune(cfg)
+
+
+if __name__ == "__main__":
+    main()

scripts/run_lrm_eval.py

@@ -0,0 +1,31 @@
+"""Run LRM evaluation on trace files."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+from training.datasets import load_plan_results
+from training.eval import EvalConfig, run_eval
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run LRM eval on trace JSON/JSONL.")
+    parser.add_argument("--trace", action="append", default=[], help="Path to trace JSON or JSONL.")
+    parser.add_argument("--output", type=str, default="eval_results/lrm_eval.json")
+    args = parser.parse_args()
+
+    if not args.trace:
+        raise ValueError("At least one --trace file is required.")
+
+    plans = load_plan_results([Path(p) for p in args.trace])
+    run_eval(plans, EvalConfig(output_path=args.output))
+
+
+if __name__ == "__main__":
+    main()

templates/graph_management.py

@@ -439,4 +439,33 @@ class GraphManager:
         """
         for u, v in edges:
             self.add_relationship(u, v, **default_metadata)
+    
+    def temporal_topological_sort(self) -> List[str]:
+        """
+        Perform topological sort respecting temporal ordering.
+        
+        Temporal edges (BEFORE, AFTER, DELAYED) are respected in ordering.
+        
+        Returns:
+            List of nodes in temporal topological order
+        """
+        # For now, use standard topological sort
+        # In future, can be enhanced to respect temporal edge types
+        return self.topological_sort()
+    
+    def get_temporal_edges(self) -> List[Tuple[str, str, Dict[str, Any]]]:
+        """
+        Get all edges with temporal metadata.
+        
+        Returns:
+            List of (source, target, metadata) tuples for temporal edges
+        """
+        temporal_edges = []
+        for source, targets in self.graph.items():
+            for target, meta in targets.items():
+                if isinstance(meta, dict):
+                    temporal_type = meta.get("temporal_type")
+                    if temporal_type and temporal_type != "immediate":
+                        temporal_edges.append((source, target, meta))
+        return temporal_edges
 

tests/conftest.py

@@ -0,0 +1,9 @@
+import sys
+from pathlib import Path
+
+
+# Ensure repository root is importable when running pytest from any cwd.
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+

tests/test_core.py

@@ -4,9 +4,8 @@ import importlib.util
 
 def load_crca_module():
     repo_root = os.path.dirname(os.path.dirname(__file__))
-    # CRCA.py lives inside the ceca_lite package directory
-    # In this repository layout the implementation file is `CRCA.py` under CR-CA
-    target = os.path.join(repo_root, "CR-CA", "CRCA.py")
+    # In this repository layout the implementation file is `CRCA.py` at repo root.
+    target = os.path.join(repo_root, "CRCA.py")
     spec = importlib.util.spec_from_file_location("crca_module", target)
     mod = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(mod)

tests/test_crca_core_discovery_tabular.py

@@ -0,0 +1,15 @@
+import pandas as pd
+
+from crca_core.discovery import TabularDiscoveryConfig, discover_tabular
+from crca_core.models.refusal import RefusalResult, RefusalReasonCode
+from crca_core.models.result import DiscoveryHypothesisResult
+
+
+def test_discover_tabular_refuses_when_backend_missing() -> None:
+    df = pd.DataFrame({"x": [1, 2, 3], "y": [0, 1, 0]})
+    res = discover_tabular(df, TabularDiscoveryConfig(algorithm="pc"))
+    if isinstance(res, RefusalResult):
+        assert RefusalReasonCode.UNSUPPORTED_OPERATION in res.reason_codes
+    else:
+        assert isinstance(res, DiscoveryHypothesisResult)
+

tests/test_crca_core_estimate_dowhy.py

@@ -0,0 +1,36 @@
+import numpy as np
+import pandas as pd
+
+from crca_core import DraftSpec, EstimatorConfig, estimate_effect_dowhy, lock_spec
+from crca_core.identify import identify_effect
+from crca_core.models.spec import CausalGraphSpec, EdgeSpec, NodeSpec, RoleSpec
+from crca_core.models.result import EstimateResult
+
+
+def test_estimate_effect_dowhy_runs_on_simple_linear_model() -> None:
+    # Generate data: Y = 3*X + noise
+    rng = np.random.default_rng(0)
+    n = 200
+    X = rng.normal(0, 1, size=n)
+    Y = 3.0 * X + rng.normal(0, 1, size=n)
+    df = pd.DataFrame({"X": X, "Y": Y})
+
+    draft = DraftSpec(
+        graph=CausalGraphSpec(nodes=[NodeSpec(name="X"), NodeSpec(name="Y")], edges=[EdgeSpec(source="X", target="Y")]),
+        roles=RoleSpec(treatments=["X"], outcomes=["Y"]),
+    )
+    locked = lock_spec(draft, approvals=["human"])
+
+    ident = identify_effect(locked_spec=locked, treatment="X", outcome="Y")
+    res = estimate_effect_dowhy(
+        data=df,
+        locked_spec=locked,
+        treatment="X",
+        outcome="Y",
+        identification_result=ident,
+        config=EstimatorConfig(method_name="backdoor.linear_regression"),
+    )
+    assert isinstance(res, EstimateResult)
+    assert "value" in res.estimate
+    assert np.isfinite(res.estimate["value"])
+

tests/test_crca_core_identify.py

@@ -0,0 +1,18 @@
+from crca_core.identify import identify_effect
+from crca_core.core.lifecycle import lock_spec
+from crca_core.models.result import IdentificationResult
+from crca_core.models.spec import CausalGraphSpec, DraftSpec, EdgeSpec, NodeSpec, RoleSpec
+
+
+def test_identify_backdoor_empty_set_for_simple_chain() -> None:
+    draft = DraftSpec(
+        graph=CausalGraphSpec(
+            nodes=[NodeSpec(name="X"), NodeSpec(name="Y")],
+            edges=[EdgeSpec(source="X", target="Y")],
+        ),
+        roles=RoleSpec(treatments=["X"], outcomes=["Y"]),
+    )
+    locked = lock_spec(draft, approvals=["human"])
+    res = identify_effect(locked_spec=locked, treatment="X", outcome="Y")
+    assert isinstance(res, IdentificationResult)
+    assert res.method == "backdoor"

tests/test_crca_core_intervention_design.py

@@ -0,0 +1,36 @@
+from crca_core.core.intervention_design import FeasibilityConstraints, TargetQuery, design_intervention
+from crca_core.core.lifecycle import lock_spec
+from crca_core.models.spec import DraftSpec, CausalGraphSpec, EdgeSpec, NodeSpec, RoleSpec
+
+
+def test_design_intervention_randomize_when_manipulable() -> None:
+    draft = DraftSpec(
+        graph=CausalGraphSpec(nodes=[NodeSpec(name="X"), NodeSpec(name="Y")], edges=[EdgeSpec(source="X", target="Y")]),
+        roles=RoleSpec(treatments=["X"], outcomes=["Y"]),
+    )
+    locked = lock_spec(draft, approvals=["human"])
+    res = design_intervention(
+        locked_spec=locked,
+        target_query=TargetQuery(query_type="identify_effect", treatment="X", outcome="Y"),
+        constraints=FeasibilityConstraints(manipulable_variables=["X"]),
+    )
+    assert res.result_type == "InterventionDesign"
+    assert any(d["design_type"] == "randomize_treatment" for d in res.designs)
+
+
+def test_design_intervention_measure_parents_of_treatment() -> None:
+    draft = DraftSpec(
+        graph=CausalGraphSpec(
+            nodes=[NodeSpec(name="Z"), NodeSpec(name="X"), NodeSpec(name="Y")],
+            edges=[EdgeSpec(source="Z", target="X"), EdgeSpec(source="X", target="Y")],
+        ),
+        roles=RoleSpec(treatments=["X"], outcomes=["Y"]),
+    )
+    locked = lock_spec(draft, approvals=["human"])
+    res = design_intervention(
+        locked_spec=locked,
+        target_query=TargetQuery(query_type="identify_effect", treatment="X", outcome="Y"),
+        constraints=FeasibilityConstraints(manipulable_variables=[]),
+    )
+    assert any(d["design_type"] == "measure_confounder_candidates" for d in res.designs)
+

tests/test_crca_core_linear_gaussian_scm.py

@@ -0,0 +1,69 @@
+import numpy as np
+
+from crca_core.scm import LinearGaussianSCM
+from crca_core.models.spec import NoiseSpec, SCMSpec, StructuralEquationSpec
+
+
+def test_linear_gaussian_scm_counterfactual_simple_chain() -> None:
+    # X := Ux
+    # Y := 2*X + Uy
+    spec = SCMSpec(
+        scm_type="linear_gaussian",
+        equations=[
+            StructuralEquationSpec(
+                variable="X",
+                parents=[],
+                coefficients={},
+                intercept=0.0,
+                noise=NoiseSpec(distribution="gaussian", params={"mean": 0.0, "std": 1.0}),
+            ),
+            StructuralEquationSpec(
+                variable="Y",
+                parents=["X"],
+                coefficients={"X": 2.0},
+                intercept=0.0,
+                noise=NoiseSpec(distribution="gaussian", params={"mean": 0.0, "std": 1.0}),
+            ),
+        ],
+    )
+    scm = LinearGaussianSCM.from_spec(spec)
+
+    factual = {"X": 1.0, "Y": 3.0}  # implies Uy = 1
+    cf = scm.counterfactual(factual, interventions={"X": 2.0})
+    assert cf["X"] == 2.0
+    assert cf["Y"] == 5.0
+
+
+def test_linear_gaussian_scm_abduction_action_prediction_matches_manual() -> None:
+    rng = np.random.default_rng(0)
+    # Chain: A -> B -> C
+    beta_ab = 0.7
+    beta_bc = -1.3
+    spec = SCMSpec(
+        scm_type="linear_gaussian",
+        equations=[
+            StructuralEquationSpec(variable="A", parents=[], coefficients={}, intercept=0.2),
+            StructuralEquationSpec(variable="B", parents=["A"], coefficients={"A": beta_ab}, intercept=-0.1),
+            StructuralEquationSpec(variable="C", parents=["B"], coefficients={"B": beta_bc}, intercept=0.0),
+        ],
+    )
+    scm = LinearGaussianSCM.from_spec(spec)
+
+    # Sample one factual realization
+    uA, uB, uC = rng.normal(0, 1, size=3)
+    A = 0.2 + uA
+    B = -0.1 + beta_ab * A + uB
+    C = 0.0 + beta_bc * B + uC
+    factual = {"A": float(A), "B": float(B), "C": float(C)}
+
+    # Counterfactual intervention on A
+    A_do = float(A + 1.0)
+    cf = scm.counterfactual(factual, interventions={"A": A_do})
+
+    # Manual AAP with same u's
+    B_do = -0.1 + beta_ab * A_do + uB
+    C_do = 0.0 + beta_bc * B_do + uC
+
+    assert np.isclose(cf["B"], B_do)
+    assert np.isclose(cf["C"], C_do)
+

tests/test_crca_core_spec.py

@@ -0,0 +1,25 @@
+from crca_core import DraftSpec, lock_spec, validate_spec
+
+
+def test_draft_spec_validates() -> None:
+    draft = DraftSpec()
+    report = validate_spec(draft)
+    assert report.ok is True
+    assert report.errors == []
+
+
+def test_lock_spec_requires_approvals() -> None:
+    draft = DraftSpec()
+    try:
+        lock_spec(draft, approvals=[])
+        assert False, "Expected ValueError"
+    except ValueError:
+        pass
+
+
+def test_lock_spec_produces_hash() -> None:
+    draft = DraftSpec()
+    locked = lock_spec(draft, approvals=["human"])
+    assert locked.spec_hash
+    assert locked.status.value == "locked"
+

tests/test_crca_core_timeseries_pcmci.py

@@ -0,0 +1,15 @@
+import pandas as pd
+
+from crca_core.models.refusal import RefusalReasonCode, RefusalResult
+from crca_core.models.result import DiscoveryHypothesisResult
+from crca_core.timeseries import PCMCIConfig, discover_timeseries_pcmci
+
+
+def test_discover_timeseries_pcmci_refuses_when_backend_missing() -> None:
+    df = pd.DataFrame({"x": [1, 2, 3], "y": [0, 1, 0]})
+    res = discover_timeseries_pcmci(df, PCMCIConfig(max_lag=2))
+    if isinstance(res, RefusalResult):
+        assert RefusalReasonCode.UNSUPPORTED_OPERATION in res.reason_codes
+    else:
+        assert isinstance(res, DiscoveryHypothesisResult)
+