auto-sync 2026-07-02T17:27:17Z workspace (part 3)

workspace/results/paper_analysis.json

@@ -1,6 +1,29 @@
 {
+  "best_candidate_oracle_key": "transport_field_reground_fieldonly_k6matched_b12_clean_k6_dropnoopwg_retargeted_srcscore001_oraclek8",
   "best_clean_key": "transport_field_reground_fieldonly_k6matched_b12_clean_k6_dropnoopwg_retargeted_srcscore_task_pick001_stack005",
-  "generated_utc": "2026-07-02T16:52:46+00:00",
+  "causal_action_decomposition": {
+    "base": 0.29739130434782607,
+    "clean_gain": 0.09159420289855075,
+    "closed_fraction_of_noexpert_gap": 0.3361702127659574,
+    "full_oracle": 0.6933333333333334,
+    "full_oracle_gap": 0.30434782608695654,
+    "proposal_oracle": 0.44347826086956516,
+    "same_state_gain_over_base": 0.27246376811594214,
+    "same_state_oracle": 0.5698550724637682,
+    "selected": 0.3889855072463768,
+    "selector_gap": 0.05449275362318834,
+    "support_gap": 0.12637681159420305,
+    "total_gap_to_same_state": 0.1808695652173914
+  },
+  "causal_action_targets": {
+    "best_paper_target_range": [
+      0.47,
+      0.52
+    ],
+    "selected_success_for_65pct_gap_closure": 0.47449275362318843,
+    "selected_success_for_75pct_gap_closure": 0.5017391304347827
+  },
+  "generated_utc": "2026-07-02T17:31:38+00:00",
   "mechanism_gap": {
     "best_clean_vs_direct_same_ckpt": 0.1060869565217391,
     "best_clean_vs_h16": 0.09159420289855075,
@@ -3724,6 +3747,8 @@
     },
     "residual_k4_composemasked_dropnmnoop_grid035040045_noopbonus003_oraclek8": {
       "candidate_oracle_rollouts": 8,
+      "candidate_oracle_selector_gap_progress": 0.07803014863367896,
+      "candidate_oracle_selector_gap_success": 0.08231884057971006,
       "candidate_oracle_type_counts": {
         "retrieval_residual_policy_residual": 867,
         "retrieval_residual_residual_near_miss": 201,
@@ -3745,6 +3770,8 @@
       "mean_candidate_oracle_improvement_rate": 0.4602898550724637,
       "mean_candidate_oracle_progress": 0.6443418554713328,
       "mean_candidate_oracle_score_gain_over_selected": 0.16034898876064066,
+      "mean_candidate_oracle_selected_branch_progress": 0.5663117068376539,
+      "mean_candidate_oracle_selected_branch_success_rate": 0.3484057971014493,
       "mean_candidate_oracle_success_rate": 0.4307246376811594,
       "mean_candidate_oracle_unique_count": NaN,
       "mean_progress": 0.571575072284851,
@@ -3847,6 +3874,7 @@
       "std_success": 0.012173913043478276
     },
     "residual_k4_composemasked_dropnmnoop_grid035040045_noopbonus003_oraclek8trace": {
+      "candidate_oracle_base_trace_coverage": 0.9768115942028985,
       "candidate_oracle_best_branch_rank_counts": {
         "1": 931,
         "2": 162,
@@ -3858,6 +3886,8 @@
         "8": 149
       },
       "candidate_oracle_rollouts": 8,
+      "candidate_oracle_selector_gap_progress": 0.07803014863367896,
+      "candidate_oracle_selector_gap_success": 0.08231884057971006,
       "candidate_oracle_type_counts": {
         "retrieval_residual_policy_residual": 867,
         "retrieval_residual_residual_near_miss": 201,
@@ -3907,9 +3937,15 @@
         0.2336231884057971,
         0.25043478260869567
       ],
+      "mean_candidate_oracle_car_to_proposal_oracle": 0.16034898921338922,
       "mean_candidate_oracle_improvement_rate": 0.4602898550724637,
+      "mean_candidate_oracle_ncar_to_proposal_oracle": 0.9816454565106858,
       "mean_candidate_oracle_progress": 0.6443418554713328,
+      "mean_candidate_oracle_ptr_at_k": 0.4712166172106825,
       "mean_candidate_oracle_score_gain_over_selected": 0.16034898876064066,
+      "mean_candidate_oracle_selected_branch_progress": 0.5663117068376539,
+      "mean_candidate_oracle_selected_branch_success_rate": 0.3484057971014493,
+      "mean_candidate_oracle_selector_regret_at_k": 0.16034898921338922,
       "mean_candidate_oracle_success_rate": 0.4307246376811594,
       "mean_candidate_oracle_unique_count": 8.0,
       "mean_progress": 0.571575072284851,
@@ -11093,6 +11129,7 @@
       "std_success": 0.017506862458598824
     },
     "transport_field_reground_fieldonly_k6matched_b12_clean_k6_dropnoopwg_retargeted_oraclek8": {
+      "candidate_oracle_base_trace_coverage": 0.8515942028985507,
       "candidate_oracle_best_branch_rank_counts": {
         "1": 985,
         "2": 154,
@@ -11104,6 +11141,8 @@
         "8": 78
       },
       "candidate_oracle_rollouts": 8,
+      "candidate_oracle_selector_gap_progress": 0.04840773510598173,
+      "candidate_oracle_selector_gap_success": 0.05971014492753618,
       "candidate_oracle_type_counts": {
         "retrieval_residual_policy_residual": 468,
         "retrieval_residual_residual_near_miss": 256,
@@ -11152,9 +11191,15 @@
         0.2533333333333333,
         0.23099631368984497
       ],
+      "mean_candidate_oracle_car_to_proposal_oracle": 0.10811788003351809,
       "mean_candidate_oracle_improvement_rate": 0.4289855072463768,
+      "mean_candidate_oracle_ncar_to_proposal_oracle": 1.2157991567169883,
       "mean_candidate_oracle_progress": 0.6426025666080523,
+      "mean_candidate_oracle_ptr_at_k": 0.4758339006126617,
       "mean_candidate_oracle_score_gain_over_selected": 0.10811787949955981,
+      "mean_candidate_oracle_selected_branch_progress": 0.5941948315020705,
+      "mean_candidate_oracle_selected_branch_success_rate": 0.383768115942029,
+      "mean_candidate_oracle_selector_regret_at_k": 0.10811788003351809,
       "mean_candidate_oracle_success_rate": 0.44347826086956516,
       "mean_candidate_oracle_unique_count": 7.998840579710145,
       "mean_progress": 0.5992048837379486,
@@ -11923,6 +11968,7 @@
       "std_success": 0.012215250727945203
     },
     "transport_field_reground_fieldonly_k6matched_b12_clean_k6_dropnoopwg_retargeted_srcscore001_oraclek8": {
+      "candidate_oracle_base_trace_coverage": 0.8121739130434783,
       "candidate_oracle_best_branch_rank_counts": {
         "1": 984,
         "2": 156,
@@ -11934,6 +11980,8 @@
         "8": 79
       },
       "candidate_oracle_rollouts": 8,
+      "candidate_oracle_selector_gap_progress": 0.04810635927092766,
+      "candidate_oracle_selector_gap_success": 0.05913043478260871,
       "candidate_oracle_type_counts": {
         "retrieval_residual_policy_residual": 445,
         "retrieval_residual_residual_near_miss": 273,
@@ -11982,9 +12030,15 @@
         0.2539130434782609,
         0.23215674392768773
       ],
+      "mean_candidate_oracle_car_to_proposal_oracle": 0.1072367940535364,
       "mean_candidate_oracle_improvement_rate": 0.42956521739130443,
+      "mean_candidate_oracle_ncar_to_proposal_oracle": 1.2488320610772363,
       "mean_candidate_oracle_progress": 0.6425710423981797,
+      "mean_candidate_oracle_ptr_at_k": 0.4732334047109208,
       "mean_candidate_oracle_score_gain_over_selected": 0.10723679356600928,
+      "mean_candidate_oracle_selected_branch_progress": 0.5944646831272521,
+      "mean_candidate_oracle_selected_branch_success_rate": 0.38434782608695645,
+      "mean_candidate_oracle_selector_regret_at_k": 0.1072367940535364,
       "mean_candidate_oracle_success_rate": 0.44347826086956516,
       "mean_candidate_oracle_unique_count": 7.998840579710145,
       "mean_progress": 0.5994939735267257,
@@ -14013,6 +14067,7 @@
       "std_success": 0.017650246200160362
     },
     "transport_field_reground_fieldonly_k6matched_b12_clean_k6_oraclek8": {
+      "candidate_oracle_base_trace_coverage": 0.8023188405797101,
       "candidate_oracle_best_branch_rank_counts": {
         "1": 937,
         "2": 150,
@@ -14024,6 +14079,8 @@
         "8": 86
       },
       "candidate_oracle_rollouts": 8,
+      "candidate_oracle_selector_gap_progress": 0.05475997270408861,
+      "candidate_oracle_selector_gap_success": 0.0631884057971015,
       "candidate_oracle_type_counts": {
         "retrieval_residual_policy_residual": 440,
         "retrieval_residual_residual_near_miss": 256,
@@ -14073,9 +14130,15 @@
         0.2515942028985507,
         0.2289855072463768
       ],
+      "mean_candidate_oracle_car_to_proposal_oracle": 0.11794837850119001,
       "mean_candidate_oracle_improvement_rate": 0.4568115942028985,
+      "mean_candidate_oracle_ncar_to_proposal_oracle": 1.4397874961800154,
       "mean_candidate_oracle_progress": 0.6483499062207082,
+      "mean_candidate_oracle_ptr_at_k": 0.4602601156069364,
       "mean_candidate_oracle_score_gain_over_selected": 0.11794837779432965,
+      "mean_candidate_oracle_selected_branch_progress": 0.5935899335166196,
+      "mean_candidate_oracle_selected_branch_success_rate": 0.3797101449275362,
+      "mean_candidate_oracle_selector_regret_at_k": 0.11794837850119001,
       "mean_candidate_oracle_success_rate": 0.4428985507246377,
       "mean_candidate_oracle_unique_count": 8.0,
       "mean_progress": 0.5973945180108495,

workspace/results/paper_analysis.md

@@ -1,6 +1,6 @@
 # Paper Analysis
 
-Generated: `2026-07-02T16:52:46+00:00`
+Generated: `2026-07-02T17:31:38+00:00`
 
 ## Main Seed Statistics
 
@@ -201,10 +201,20 @@ Generated: `2026-07-02T16:52:46+00:00`
 - Remaining clean-to-same-state proposal gap is +18.09 pp.
 - Full lattice adds expert proposals and reaches 69.33%, a +12.35 pp gain over no-expert.
 
+## Causal Action Regret Decomposition
+
+| base | selected clean | proposal oracle | same-state no-expert oracle | support gap | selector gap | gap closed |
+|---:|---:|---:|---:|---:|---:|---:|
+| 29.74% | 38.90% | 44.35% | 56.99% | +12.64 pp | +5.45 pp | 33.6% |
+
+- Current clean policy closes 33.6% of the h16-to-same-state-no-expert gap.
+- Closing 65--75% of that gap implies selected success targets of 47.45%--50.17%.
+
 ## Candidate-Oracle Diagnostic
 
 - Best diagnostic prefix (`transport_field_reground_fieldonly_k6matched_b12_clean_k6_dropnoopwg_retargeted_srcscore001_oraclek8`) reaches 44.35% with mean progress 64.26%; this is diagnostic-only because it uses measured rollout outcomes after generating candidates.
 - Mean oracle-prefix score gain over the selected branch is +0.107, which isolates ranking/abstention headroom inside the clean proposal set.
+- CAR-to-proposal-oracle from raw prefix traces is +0.107; PTR@K is 47.32% over rows with base trace coverage 81.22%.
 - Mean unique candidates in the prefix: 8.00.
 - Candidate-oracle best type counts: {'retrieval_residual_policy_residual': 445, 'retrieval_residual_residual_near_miss': 273, 'retrieval_residual_residual_near_miss+residual_wrong_gripper': 262, 'retrieval_residual_residual_no_op': 285, 'retrieval_residual_residual_wrong_gripper': 460}.
 - Mean best branch rank in the field-ordered prefix: 2.48; rank histogram {'1': 984, '2': 156, '3': 129, '4': 141, '5': 101, '6': 56, '7': 79, '8': 79}.

workspace/scripts/build_paper_analysis.py

@@ -3,16 +3,29 @@ from __future__ import annotations
 
 import json
 import math
+import sys
 from collections import Counter
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
+ROOT_DIR = Path(__file__).resolve().parents[1]
+if str(ROOT_DIR) not in sys.path:
+    sys.path.insert(0, str(ROOT_DIR))
+
+from dovla_cil.eval.metrics import (
+    candidate_prefix_causal_metrics,
+    causal_action_decomposition,
+    finite_mean,
+)
+
 
 RESULTS_DIR = Path("results")
 OUT_JSON = RESULTS_DIR / "paper_analysis.json"
 OUT_MD = RESULTS_DIR / "paper_analysis.md"
+LATEX_TABLES_DIR = Path("latex") / "tables"
+OUT_CAR_TABLE = LATEX_TABLES_DIR / "car_decomposition.tex"
 CANONICAL_H16_ROLLOUT = Path("/scratch/knguy52/dovla/experiments/dovla_h16_rollout_runs")
 FALLBACK_BEST_CLEAN_KEY = "residual_k4_consensus_grid035040045_noopbonus003"
 NON_DEPLOYMENT_KEYS = {
@@ -1480,13 +1493,33 @@ def _normalize_summary(data: dict[str, Any], rows: list[dict[str, Any]], *, sour
         if row.get("candidate_oracle_success_rate") is not None
     ]
     if candidate_oracle_success:
+        raw_prefix_metrics = _candidate_prefix_metrics_from_raw(rows)
+        selected_branch_success = [
+            float(row["candidate_oracle_selected_branch_success_rate"])
+            for row in rows
+            if row.get("candidate_oracle_selected_branch_success_rate") is not None
+        ]
+        selected_branch_progress = [
+            float(row["candidate_oracle_selected_branch_progress"])
+            for row in rows
+            if row.get("candidate_oracle_selected_branch_progress") is not None
+        ]
+        oracle_progress = [
+            float(row["candidate_oracle_progress"])
+            for row in rows
+            if row.get("candidate_oracle_progress") is not None
+        ]
+        selected_success_mean = _mean(selected_branch_success)
+        oracle_success_mean = _mean(candidate_oracle_success)
+        selected_progress_mean = _mean(selected_branch_progress)
+        oracle_progress_mean = _mean(oracle_progress)
         output.update(
             {
                 "candidate_oracle_rollouts": int(data.get("candidate_oracle_rollouts") or 0),
                 "candidate_oracle_unique_tolerance": data.get(
                     "candidate_oracle_unique_tolerance"
                 ),
-                "mean_candidate_oracle_success_rate": _mean(candidate_oracle_success),
+                "mean_candidate_oracle_success_rate": oracle_success_mean,
                 "std_candidate_oracle_success_rate": _sample_std(
                     candidate_oracle_success
                 ),
@@ -1496,12 +1529,18 @@ def _normalize_summary(data: dict[str, Any], rows: list[dict[str, Any]], *, sour
                     for index, row in enumerate(rows)
                     if row.get("candidate_oracle_success_rate") is not None
                 },
-                "mean_candidate_oracle_progress": _mean(
-                    [
-                        float(row["candidate_oracle_progress"])
-                        for row in rows
-                        if row.get("candidate_oracle_progress") is not None
-                    ]
+                "mean_candidate_oracle_progress": oracle_progress_mean,
+                "mean_candidate_oracle_selected_branch_success_rate": (
+                    selected_success_mean
+                ),
+                "mean_candidate_oracle_selected_branch_progress": (
+                    selected_progress_mean
+                ),
+                "candidate_oracle_selector_gap_success": (
+                    oracle_success_mean - selected_success_mean
+                ),
+                "candidate_oracle_selector_gap_progress": (
+                    oracle_progress_mean - selected_progress_mean
                 ),
                 "mean_candidate_oracle_score_gain_over_selected": _mean(
                     [
@@ -1530,6 +1569,8 @@ def _normalize_summary(data: dict[str, Any], rows: list[dict[str, Any]], *, sour
                 ),
             }
         )
+        if raw_prefix_metrics:
+            output.update(raw_prefix_metrics)
         for key in (
             "mean_candidate_oracle_best_branch_rank",
             "candidate_oracle_best_branch_rank_counts",
@@ -1542,6 +1583,53 @@ def _normalize_summary(data: dict[str, Any], rows: list[dict[str, Any]], *, sour
     return output
 
 
+def _candidate_prefix_metrics_from_raw(rows: list[dict[str, Any]]) -> dict[str, Any]:
+    prefix_metrics: list[dict[str, Any]] = []
+    for row in rows:
+        path = row.get("path")
+        if not path:
+            continue
+        raw_path = Path(str(path))
+        if not raw_path.exists():
+            continue
+        raw = _load_json(raw_path)
+        for item in raw.get("rows", []):
+            scores = item.get("candidate_oracle_branch_scores") or []
+            if not scores:
+                continue
+            metrics = candidate_prefix_causal_metrics(
+                branch_scores=[float(value) for value in scores],
+                selected_score=(
+                    float(item["candidate_oracle_selected_branch_score"])
+                    if item.get("candidate_oracle_selected_branch_score") is not None
+                    else None
+                ),
+                branch_types=[str(value) for value in item.get("candidate_oracle_types", [])],
+                valid_mask=[bool(value) for value in item.get("candidate_oracle_valid_mask", [])]
+                or None,
+            )
+            if metrics:
+                prefix_metrics.append(metrics)
+    if not prefix_metrics:
+        return {}
+    ptr = finite_mean([item.get("ptr_at_k") for item in prefix_metrics])
+    ncar = finite_mean([item.get("ncar_to_proposal_oracle") for item in prefix_metrics])
+    return {
+        "mean_candidate_oracle_car_to_proposal_oracle": _mean(
+            [float(item["car_to_proposal_oracle"]) for item in prefix_metrics]
+        ),
+        "mean_candidate_oracle_selector_regret_at_k": _mean(
+            [float(item["selector_regret_at_k"]) for item in prefix_metrics]
+        ),
+        "mean_candidate_oracle_ptr_at_k": ptr,
+        "mean_candidate_oracle_ncar_to_proposal_oracle": ncar,
+        "candidate_oracle_base_trace_coverage": (
+            sum(1 for item in prefix_metrics if item.get("base_utility") is not None)
+            / len(prefix_metrics)
+        ),
+    }
+
+
 def _per_task(rows: list[dict[str, Any]]) -> dict[str, dict[str, float]]:
     task_values: dict[str, list[float]] = {}
     task_counts: dict[str, list[int]] = {}
@@ -1826,6 +1914,36 @@ def _render_markdown(report: dict[str, Any]) -> str:
             f"- Full lattice adds expert proposals and reaches {_pct(methods['same_state_full']['mean_success'])}, a {_pp(gap['same_state_full_vs_no_expert'])} gain over no-expert.",
         ]
     )
+    decomposition = report["causal_action_decomposition"]
+    targets = report["causal_action_targets"]
+    lines.extend(
+        [
+            "",
+            "## Causal Action Regret Decomposition",
+            "",
+            "| base | selected clean | proposal oracle | same-state no-expert oracle | support gap | selector gap | gap closed |",
+            "|---:|---:|---:|---:|---:|---:|---:|",
+            (
+                f"| {_pct(decomposition['base'])} | {_pct(decomposition['selected'])} | "
+                f"{_pct(decomposition['proposal_oracle'])} | "
+                f"{_pct(decomposition['same_state_oracle'])} | "
+                f"{_pp(decomposition['support_gap'])} | "
+                f"{_pp(decomposition['selector_gap'])} | "
+                f"{decomposition['closed_fraction_of_noexpert_gap'] * 100:.1f}% |"
+            ),
+            "",
+            (
+                "- Current clean policy closes "
+                f"{decomposition['closed_fraction_of_noexpert_gap'] * 100:.1f}% "
+                "of the h16-to-same-state-no-expert gap."
+            ),
+            (
+                "- Closing 65--75% of that gap implies selected success targets of "
+                f"{_pct(targets['selected_success_for_65pct_gap_closure'])}--"
+                f"{_pct(targets['selected_success_for_75pct_gap_closure'])}."
+            ),
+        ]
+    )
     oracle_key, oracle = _best_candidate_oracle(methods)
     if oracle and oracle.get("num_completed"):
         branch_success = oracle.get("mean_candidate_oracle_branch_success_rates") or []
@@ -1850,6 +1968,12 @@ def _render_markdown(report: dict[str, Any]) -> str:
                     f"{oracle.get('mean_candidate_oracle_score_gain_over_selected', 0.0):+.3f}, "
                     "which isolates ranking/abstention headroom inside the clean proposal set."
                 ),
+                (
+                    "- CAR-to-proposal-oracle from raw prefix traces is "
+                    f"{oracle.get('mean_candidate_oracle_car_to_proposal_oracle', 0.0):+.3f}; "
+                    f"PTR@K is {_pct(oracle.get('mean_candidate_oracle_ptr_at_k'))} "
+                    f"over rows with base trace coverage {_pct(oracle.get('candidate_oracle_base_trace_coverage'))}."
+                ),
                 (
                     "- Mean unique candidates in the prefix: "
                     f"{oracle.get('mean_candidate_oracle_unique_count', 0.0):.2f}."
@@ -1950,6 +2074,13 @@ def _render_markdown(report: dict[str, Any]) -> str:
 def build_report() -> dict[str, Any]:
     methods = _load_methods()
     best_clean_key = _best_clean_key(methods)
+    oracle_key, oracle_method = _best_candidate_oracle(methods)
+    proposal_oracle_success = (
+        float(oracle_method["mean_candidate_oracle_success_rate"])
+        if oracle_method is not None
+        and oracle_method.get("mean_candidate_oracle_success_rate") is not None
+        else float("nan")
+    )
     paired_deltas = {
         "best_clean - canonical_h16": _paired_delta(methods, best_clean_key, "h16_policy_canonical"),
         "best_clean - direct_same_ckpt": _paired_delta(methods, best_clean_key, "near_miss_policy_bc5"),
@@ -1973,6 +2104,13 @@ def build_report() -> dict[str, Any]:
         "same_state_full_vs_no_expert": methods["same_state_full"]["mean_success"]
         - methods["same_state_no_expert"]["mean_success"],
     }
+    decomposition = causal_action_decomposition(
+        base=methods["h16_policy_canonical"]["mean_success"],
+        selected=methods[best_clean_key]["mean_success"],
+        proposal_oracle=proposal_oracle_success,
+        same_state_oracle=methods["same_state_no_expert"]["mean_success"],
+        full_oracle=methods["same_state_full"]["mean_success"],
+    )
     return {
         "generated_utc": datetime.now(timezone.utc).isoformat(timespec="seconds"),
         "methods": methods,
@@ -1982,17 +2120,83 @@ def build_report() -> dict[str, Any]:
             "no_expert_vs_best_clean": _per_task_delta(methods, "same_state_no_expert", best_clean_key),
         },
         "mechanism_gap": mechanism_gap,
+        "causal_action_decomposition": decomposition.to_dict(),
+        "causal_action_targets": {
+            "selected_success_for_65pct_gap_closure": decomposition.target_for_gap_closure(0.65),
+            "selected_success_for_75pct_gap_closure": decomposition.target_for_gap_closure(0.75),
+            "best_paper_target_range": [0.47, 0.52],
+        },
+        "best_candidate_oracle_key": oracle_key,
         "best_clean_key": best_clean_key,
     }
 
 
+def _latex_pct(value: float | None) -> str:
+    if value is None:
+        return "--"
+    value = float(value)
+    if math.isnan(value):
+        return "--"
+    return f"{value * 100:.2f}"
+
+
+def _latex_pp(value: float | None) -> str:
+    if value is None:
+        return "--"
+    value = float(value)
+    if math.isnan(value):
+        return "--"
+    return f"{value * 100:.2f}"
+
+
+def _render_car_decomposition_table(report: dict[str, Any]) -> str:
+    decomposition = report["causal_action_decomposition"]
+    targets = report["causal_action_targets"]
+    closed = decomposition["closed_fraction_of_noexpert_gap"]
+    closed_text = "--" if math.isnan(float(closed)) else f"{float(closed) * 100:.1f}"
+    return (
+        "\\begin{table}[t]\n"
+        "\\centering\n"
+        "\\caption{Causal Action Regret decomposition on the current six-task "
+        "diagnostic. Support is the proposal-generation gap to the hidden "
+        "same-state no-expert oracle; selector is the clean proposal-oracle "
+        "headroom left by the deployed selector.}\n"
+        "\\label{tab:car-decomposition}\n"
+        "\\small\n"
+        "\\begin{tabular}{@{}lrrrrrr@{}}\n"
+        "\\toprule\n"
+        "Method & Base & Prop. oracle & Selected & State oracle & "
+        "Support & Selector \\\\\n"
+        "\\midrule\n"
+        "Current CIL-Atlas V0 & "
+        f"{_latex_pct(decomposition['base'])} & "
+        f"{_latex_pct(decomposition['proposal_oracle'])} & "
+        f"{_latex_pct(decomposition['selected'])} & "
+        f"{_latex_pct(decomposition['same_state_oracle'])} & "
+        f"{_latex_pp(decomposition['support_gap'])} & "
+        f"{_latex_pp(decomposition['selector_gap'])} \\\\\n"
+        "\\bottomrule\n"
+        "\\end{tabular}\n"
+        "\\vspace{2pt}\n"
+        "\\footnotesize Clean gain is "
+        f"{_latex_pp(decomposition['clean_gain'])} points; gap closed is "
+        f"{closed_text}\\%; 65--75\\% closure targets are "
+        f"{_latex_pct(targets['selected_success_for_65pct_gap_closure'])}--"
+        f"{_latex_pct(targets['selected_success_for_75pct_gap_closure'])}.\n"
+        "\\end{table}\n"
+    )
+
+
 def main() -> int:
     RESULTS_DIR.mkdir(parents=True, exist_ok=True)
     report = build_report()
     OUT_JSON.write_text(json.dumps(report, indent=2, sort_keys=True), encoding="utf-8")
     OUT_MD.write_text(_render_markdown(report), encoding="utf-8")
+    LATEX_TABLES_DIR.mkdir(parents=True, exist_ok=True)
+    OUT_CAR_TABLE.write_text(_render_car_decomposition_table(report), encoding="utf-8")
     print(f"Wrote {OUT_JSON}")
     print(f"Wrote {OUT_MD}")
+    print(f"Wrote {OUT_CAR_TABLE}")
     return 0