feat: achieve 1:1 scientific rigor parity with main.py across all layers

Inference (MCP + Python API):
- Replace weak MCP confounder detection (adj==1 only) with offline.identify_confounders (1/3/4 confirmed, 2 potential)
- Replace naive MCP auto-select (binary→matching) with offline.select_estimation_method (full decision tree)
- Pass is_linear/treatment_kind to DML/DRL for proper variant selection (LinearDML/SparseLinearDML/CausalForestDML)
- Select MetaLearner variant based on linearity (TLearner for linear, XLearner for nonlinear)
- Add SHAP-benchmarked partial-R2 sensitivity analysis to MCP refute_estimate
- Add treatment_kind and algo to MCP result provenance

Discovery (Python API):
- Replace dropna() with stat_info_collection() (MICE imputation, label encoding, z-score normalization)
- Replace heuristic stat tests with Ramsey RESET (linearity) and Shapiro-Wilk (gaussianity)
- Add LLM Filter+Reranker algorithm selection with rule-based fallback
- Add LLM HyperparameterSelector with defaults fallback
- Add Judge postprocessing (bootstrap stability + KCI pruning + LLM refinement)
- Store original-scale data for estimation (not normalized), matching main.py Analysis class

Discovery (MCP):
- Remove TS guard on Judge postprocessing — now runs for ALL data including time-series

All changes fall back gracefully if pipeline modules unavailable.
422 passed, 10 skipped, 0 failed.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: cauchyturing

causal_copilot/__init__.py

@@ -5,3 +5,4 @@
 from causal_copilot.copilot import CausalCopilot as CausalCopilot
 from causal_copilot.core.result import CausalResult as CausalResult
 from causal_copilot.core.result import Provenance as Provenance
+from causal_copilot.core.result import TreatmentEffect as TreatmentEffect

causal_copilot/cli.py

@@ -92,7 +92,7 @@ def cmd_version(args):
 
 
 def cmd_analyze(args):
-    """Run causal discovery on a CSV file."""
+    """Run causal discovery on a CSV file, optionally followed by effect estimation."""
     from causal_copilot import CausalCopilot
 
     try:
@@ -108,12 +108,30 @@ def cmd_analyze(args):
         seed=args.seed,
     )
 
+    # Run estimation if treatment/outcome specified
+    if result.status == "ok" and args.treatment and args.outcome:
+        try:
+            result = copilot.estimate_effect(
+                result,
+                treatment=args.treatment,
+                outcome=args.outcome,
+                method=args.method,
+            )
+        except (ValueError, ImportError) as e:
+            print(f"Estimation error: {e}", file=sys.stderr)
+
     if args.output:
         out_path = Path(args.output)
         out_path.write_text(json.dumps(result.to_dict(), indent=2))
         print(f"Result written to {out_path}")
     else:
         print(result.summary)
+        if result.effects:
+            print("\nEffects:")
+            for key, eff in result.effects.items():
+                print(f"  {key}: ATE={eff.ate}, method={eff.method}")
+                if eff.ate_ci:
+                    print(f"    95% CI: [{eff.ate_ci[0]:.4f}, {eff.ate_ci[1]:.4f}]")
         if result.warnings:
             print(f"\nWarnings ({len(result.warnings)}):")
             for w in result.warnings:
@@ -307,6 +325,11 @@ def main(argv=None):
     p_analyze.add_argument("--planner", "-p", default="rule", help="Planner: rule (default)")
     p_analyze.add_argument("--timeout", "-t", type=int, default=300, help="Timeout in seconds (default: 300)")
     p_analyze.add_argument("--seed", "-s", type=int, default=42, help="Random seed (default: 42)")
+    p_analyze.add_argument("--treatment", "-T", help="Treatment variable (enables effect estimation)")
+    p_analyze.add_argument("--outcome", "-Y", help="Outcome variable (enables effect estimation)")
+    p_analyze.add_argument(
+        "--method", "-m", help="Estimation method: linear, matching, dml, drl, metalearner, iv (auto if omitted)"
+    )
 
     # benchmark
     p_bench = sub.add_parser("benchmark", help="Run benchmark evaluation")