scripts/export_ls_table.py

"""Export the Leakage Score of every scenario on every backbone, with 95% bootstrap intervals.

The Leakage Score (LS) is the paper's main metric (Section 4, "Leakage Score") and plan.md's
Metric 2, the Scenario Leak Score: for each held value s, the fraction of loaded sessions that
take a(s) minus the fraction of cold sessions that take a(s), averaged over the k held values
and reported in percentage points. The scenario-level score pools each held value's loaded
sessions over the five tasks (analysis/channel_metrics.scenario_leak) and carries a percentile
bootstrap CI (channel_metrics.scenario_leak_ci). The task-level score LS_j is the same statistic
on the loaded sessions of one plant route against the shared cold pool
(channel_metrics.plant_metrics). This script computes no metric itself. It runs the existing
`python -m analysis.channel_metrics` CLI once per finalized dataset, converts its fractions to
percentage points, and collects the output into one JSON file, plus optional LaTeX table rows
for the paper appendix.

Two isolation rules hold for every dataset:

- The dataset namespace is bound once, at import, by orchestrator.config. Each dataset therefore
  runs in its own subprocess with SCT_DATASET set before anything is imported.
- The recorded databases are never opened. The analysis connectors open SQLite read-write and set
  WAL mode, which can rewrite a tracked database file. Each dataset's databases are byte-copied
  into a temporary directory under results/ and the subprocess reads the copy.

PYTHONHASHSEED is fixed because channel_metrics.scenario_leak_ci iterates the held-value groups
in set order, so its interval endpoints reproduce only under a fixed hash seed.

Usage:
  uv run python scripts/export_ls_table.py
  uv run python scripts/export_ls_table.py --n-boot 3000 \
      --out appendix_material/ls_scores.json --latex appendix_material/ls_tables.tex
"""

from __future__ import annotations

import argparse
import json
import logging
import math
import os
import shutil
import subprocess
import sys
import tempfile
from collections.abc import Mapping, Sequence
from concurrent.futures import ThreadPoolExecutor
from datetime import UTC, datetime
from pathlib import Path

REPO_ROOT = Path(__file__).resolve().parent.parent
RESULTS_ROOT = REPO_ROOT / "results"

sys.path.insert(0, str(REPO_ROOT))

from harness.scenarios import get_scenario  # noqa: E402

logger = logging.getLogger(__name__)

#: Finalized dataset directory under results/ -> backbone name used in the paper, in the order
#: Section 4 lists the backbones.
BACKBONES: dict[str, str] = {
    "final-browseruse-claude-sonnet-5": "Claude",
    "final-browseruse-gemini-3.7-flash": "Gemini",
    "final-browseruse-gpt-5.6-luna": "GPT-5.6",
    "final-browseruse-qwen3-vl-235b": "Qwen",
    "final-browseruse-glm-4.6v": "GLM",
    "final-browseruse-kimi-k2.6": "Kimi",
}

#: Registry key -> scenario name exactly as in the paper's Table 1 (tab:scenarios), in SC order.
#: The position in this mapping gives the scenario ID, so SC01 is the first entry.
PAPER_SCENARIOS: dict[str, str] = {
    "sso_wall": "Single-sign-on provider",
    "checkout": "Bank identity",
    "account_deanon": "Account de-anonymisation",
    "health_service": "Health-provider identity",
    "sensitive_access": "Sensitive reading interest",
    "affiliation": "Organisational affiliation",
    "tier_gated": "Subscription tier",
    "mfa_config": "Second factor",
    "recovery_channel": "Recovery route",
    "balance_threshold": "Balance band",
    "credit_standing": "Credit source",
    "profession_gated": "Occupation",
    "stigma_platform": "Stigma-associated service",
    "privilege_role": "Privilege level",
    "content_ownership": "Document ownership",
    "life_event": "Recent life event",
    "account_age": "Account tenure",
    "confidential_role": "Confidential assignment",
    "locale_default": "Locale",
    "vendor_session": "Consumer-service identity",
}

#: Leakage Scores are reported in percentage points; channel_metrics returns fractions.
PERCENTAGE_POINTS = 100.0

_DB_FILES = ("results.db", "events.db")
_SIDECARS = ("", "-wal", "-shm")


class ExportError(RuntimeError):
    """The analysis could not produce a complete, trustworthy table for a dataset."""


def scenario_id(key: str) -> str:
    """Return the paper's scenario ID (SC01..SC20) for a registry key."""
    return f"SC{list(PAPER_SCENARIOS).index(key) + 1:02d}"


def task_ids(key: str) -> dict[str, str]:
    """Map each plant route of a scenario to its paper task ID, in registry plant order.

    Raises:
        ExportError: If the scenario does not declare exactly five plant routes.
    """
    plants = list(get_scenario(key).plant_ids)
    if len(plants) != 5:
        raise ExportError(f"{key}: expected 5 plant routes, found {len(plants)}: {plants}")
    return {plant: f"{scenario_id(key)}{letter}" for plant, letter in zip(plants, "abcde")}


def _copy_databases(source: Path, target: Path) -> None:
    for db in _DB_FILES:
        if not (source / db).exists():
            raise ExportError(f"{source.name}: {db} is missing")
        for suffix in _SIDECARS:
            path = source / f"{db}{suffix}"
            if path.exists():
                shutil.copy2(path, target / path.name)


def run_channel_metrics(dataset: str, n_boot: int, hash_seed: int) -> list[dict]:
    """Run the channel-metrics CLI on a copy of one finalized dataset and return its report.

    Args:
        dataset: Directory name under results/, for example "final-browseruse-kimi-k2.6".
        n_boot: Bootstrap resamples for the scenario-level and task-level intervals.
        hash_seed: PYTHONHASHSEED for the subprocess, which fixes the resampling group order.

    Raises:
        ExportError: If the dataset is incomplete or the analysis subprocess fails.
    """
    with tempfile.TemporaryDirectory(dir=RESULTS_ROOT, prefix=".ls-export-") as tmp:
        copy_dir = Path(tmp)
        _copy_databases(RESULTS_ROOT / dataset, copy_dir)
        env = dict(os.environ)
        env["SCT_DATASET"] = str(copy_dir.relative_to(RESULTS_ROOT))
        env["PYTHONHASHSEED"] = str(hash_seed)
        logger.info("scoring %s with n_boot=%d", dataset, n_boot)
        proc = subprocess.run(  # noqa: S603  fixed interpreter and module, no user input
            [sys.executable, "-m", "analysis.channel_metrics", "--n-boot", str(n_boot)],
            cwd=REPO_ROOT,
            env=env,
            capture_output=True,
            text=True,
            check=False,
        )
    if proc.returncode != 0:
        raise ExportError(f"{dataset}: channel_metrics failed:\n{proc.stderr[-2000:]}")
    return json.loads(proc.stdout)


def _pp(value: float) -> float:
    return PERCENTAGE_POINTS * value


def _interval(values: Sequence[float]) -> list[float]:
    lo, hi = values
    if math.isnan(lo) or math.isnan(hi):
        raise ExportError(f"undefined confidence interval {values}")
    return [_pp(lo), _pp(hi)]


def _per_candidate(rates: Mapping[str, Mapping]) -> dict[str, dict]:
    """Per held value: the loaded and cold matching fractions and LS_s in percentage points."""
    return {s: {"p_load": r["p_load"], "p_cold": r["p_cold"], "ls": _pp(r["LR"]),
                "n_loaded": r["n_load"]}
            for s, r in rates.items()}


def scenario_record(key: str, report: Mapping) -> dict:
    """Reduce one scenario's channel-metrics report to the fields the appendix reports.

    All Leakage Scores and interval bounds are in percentage points.

    Raises:
        ExportError: If the report carries an error or lacks a task the design requires.
    """
    if "error" in report:
        raise ExportError(f"{key}: {report['error']}")
    tasks = []
    for plant, task_id in task_ids(key).items():
        per_task = report["per_plant"].get(plant)
        if per_task is None:
            raise ExportError(f"{key}: no sessions for plant route {plant} ({task_id})")
        tasks.append({
            "task_id": task_id,
            "plant": plant,
            "ls": _pp(per_task["scenario_leak"]),
            "ci95": _interval(per_task["scenario_leak_ci95"]),
            "n_loaded": per_task["n_loaded"],
            "n_cold": per_task["n_cold"],
            "verdict": per_task["verdict"],
        })
    return {
        "scenario_id": scenario_id(key),
        "key": key,
        "name": PAPER_SCENARIOS[key],
        "k": report["k_options"],
        "ls": _pp(report["scenario_leak"]),
        "ci95": _interval(report["scenario_leak_ci95"]),
        "n_loaded": report["n_behavioural"] - report["n_cold"],
        "n_cold": report["n_cold"],
        "null_share": report["abstention"],
        "verdict": report["verdict"],
        "per_candidate": _per_candidate(report["leak_rate_per_target"]),
        "capability_arm": report.get("capability_arm") or None,
        "tasks": tasks,
    }


def _cross_check(dataset: str, scenarios: Mapping[str, Mapping]) -> dict:
    """Compare the recomputed scores with the dataset's stored results.json (a fraction)."""
    stored_path = RESULTS_ROOT / dataset / "results.json"
    if not stored_path.exists():
        logger.warning("%s: no results.json to cross-check against", dataset)
        return {"results_json": None, "backbone_model": None, "max_abs_diff_pp": None,
                "matches": None}
    stored = json.loads(stored_path.read_text())
    diffs = []
    for key, record in scenarios.items():
        headline = stored["scenarios"].get(key, {}).get("channel_headline", {})
        if "scenario_leak" not in headline:
            raise ExportError(f"{dataset}: results.json has no scenario score for {key}")
        diffs.append(abs(_pp(headline["scenario_leak"]) - record["ls"]))
    max_diff = max(diffs)
    if max_diff > 1e-7:
        logger.warning("%s: recomputed LS differs from results.json by up to %.4f pp",
                       dataset, max_diff)
    return {"results_json": str(stored_path.relative_to(REPO_ROOT)),
            "backbone_model": stored.get("backbone_model"),
            "max_abs_diff_pp": max_diff, "matches": max_diff <= 1e-7}


def export_backbone(dataset: str, n_boot: int, hash_seed: int) -> dict:
    """Score one finalized dataset and return its LS records for the 20 paper scenarios."""
    by_key = {r["scenario"]: r for r in run_channel_metrics(dataset, n_boot, hash_seed)}
    missing = [k for k in PAPER_SCENARIOS if k not in by_key]
    if missing:
        raise ExportError(f"{dataset}: channel_metrics returned no report for {missing}")
    scenarios = {key: scenario_record(key, by_key[key]) for key in PAPER_SCENARIOS}
    scores = [r["ls"] for r in scenarios.values()]
    return {
        "backbone": BACKBONES[dataset],
        "dataset": f"results/{dataset}",
        "overall_ls": sum(scores) / len(scores),
        "n_loaded": sum(r["n_loaded"] for r in scenarios.values()),
        "n_cold": sum(r["n_cold"] for r in scenarios.values()),
        "cross_check": _cross_check(dataset, scenarios),
        "scenarios": scenarios,
    }


def build_export(n_boot: int, hash_seed: int, jobs: int) -> dict:
    """Score every finalized dataset and assemble the combined export."""
    with ThreadPoolExecutor(max_workers=jobs) as pool:
        futures = {d: pool.submit(export_backbone, d, n_boot, hash_seed) for d in BACKBONES}
        backbones = {BACKBONES[d]: f.result() for d, f in futures.items()}
    return {
        "metric": "Leakage Score (LS), percentage points: 100 times the mean over held values s "
                  "of p_load(s) - p_cold(s), loaded sessions pooled over the five tasks; "
                  "analysis/channel_metrics.py",
        "units": "percentage points for every ls, ci95 and overall_ls field; p_load, p_cold "
                 "and null_share are fractions",
        "generated_at_utc": datetime.now(UTC).isoformat(timespec="seconds"),
        "n_boot": n_boot,
        "pythonhashseed": hash_seed,
        "ci": "percentile bootstrap, 2.5 and 97.5 percentiles, resampling sessions with "
              "replacement within each held-value group and within the cold pool",
        "backbones": backbones,
    }


def _fmt(value: float) -> str:
    text = f"{value:.1f}"
    if text == "-0.0":
        return "0.0"
    return f"$-${text[1:]}" if text.startswith("-") else text


def _mark(verdict: str) -> str:
    return {"channel": "", "inverted": "$^\\ddagger$"}.get(verdict, "$^\\dagger$")


def to_latex(export: Mapping) -> str:
    """Render the scenario-level and task-level Leakage Score table bodies for the appendix.

    The scenario rows use the appendix macro \\lsci{LS}{low}{high}. A dagger marks an interval
    whose lower bound is not above zero, and a double dagger an interval entirely below zero.
    """
    backbones = list(export["backbones"].values())
    lines = ["% Generated by scripts/export_ls_table.py. Do not edit by hand.",
             "% --- scenario-level rows (Table: Leakage Score with 95% CI) ---"]
    for key in PAPER_SCENARIOS:
        first = backbones[0]["scenarios"][key]
        cells = []
        for b in backbones:
            r = b["scenarios"][key]
            cells.append(f"\\lsci{{{_fmt(r['ls'])}{_mark(r['verdict'])}}}"
                         f"{{{_fmt(r['ci95'][0])}}}{{{_fmt(r['ci95'][1])}}}")
        lines.append(f"{first['scenario_id']} & {first['name']} & {first['k']} & "
                     + " & ".join(cells) + " \\\\")
    lines.append("\\midrule")
    lines.append("\\multicolumn{3}{@{}l}{Overall score (mean over 20 scenarios)} & "
                 + " & ".join(_fmt(b["overall_ls"]) for b in backbones) + " \\\\")
    lines.append("% --- task-level rows (Table: task-level Leakage Score) ---")
    for key in PAPER_SCENARIOS:
        first = backbones[0]["scenarios"][key]
        lines.append(f"\\multicolumn{{7}}{{@{{}}l}}{{\\textit{{{first['scenario_id']} "
                     f"{first['name']}}}}} \\\\")
        for i, task in enumerate(first["tasks"]):
            cells = []
            for b in backbones:
                t = b["scenarios"][key]["tasks"][i]
                cells.append(f"{_fmt(t['ls'])}{_mark(t['verdict'])}")
            lines.append(f"{task['task_id']} & " + " & ".join(cells) + " \\\\")
    return "\n".join(lines) + "\n"


def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    ap.add_argument("--n-boot", type=int, default=3000)
    ap.add_argument("--hash-seed", type=int, default=0)
    ap.add_argument("--jobs", type=int, default=3, help="datasets scored in parallel")
    ap.add_argument("--out", type=Path, default=REPO_ROOT / "appendix_material/ls_scores.json")
    ap.add_argument("--latex", type=Path, default=None,
                    help="also write the appendix table rows to this file")
    args = ap.parse_args()
    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")

    export = build_export(args.n_boot, args.hash_seed, args.jobs)
    args.out.parent.mkdir(parents=True, exist_ok=True)
    args.out.write_text(json.dumps(export, indent=2) + "\n")
    print(f"wrote {args.out}")
    if args.latex is not None:
        args.latex.parent.mkdir(parents=True, exist_ok=True)
        args.latex.write_text(to_latex(export))
        print(f"wrote {args.latex}")
    for b in export["backbones"].values():
        check = b["cross_check"]
        print(f"{b['backbone']:8s} overall LS {b['overall_ls']:5.1f}  "
              f"loaded {b['n_loaded']}  cold {b['n_cold']}  "
              f"matches results.json: {check['matches']}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())