@ictechgy/context-guard 0.4.16 → 0.5.1

package/plugins/context-guard/bin/context-guard-bench

@@ -54,6 +54,7 @@ dry-run 모드는 실제 호출은 하지 않고 어떤 명령이 실행될지
 from __future__ import annotations
 
 import argparse
+import base64
 import collections
 from contextlib import contextmanager, nullcontext
 import csv
@@ -71,13 +72,14 @@ import stat
 import struct
 import subprocess
 import sys
+import tarfile
 import tempfile
 import time
 import unicodedata
 from collections.abc import Iterable
 from dataclasses import dataclass, field, replace
 from fractions import Fraction
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import Any, Callable, Mapping, Sequence
 
 try:
@@ -400,6 +402,7 @@ MEASUREMENT_DOCUMENTED_HOOK_EVENTS = (
 )
 SUCCESS_COMMAND_OUTPUT_MAX_BYTES = 64_000
 VERSION_OUTPUT_MAX_BYTES = 16_000
+MEASUREMENT_CLI_PROBE_OUTPUT_MAX_BYTES = 65_536
 PROCESS_TERMINATE_GRACE_SECONDS = 2.0
 ALLOWED_FIRST_ABSOLUTE_SYMLINKS = {
     "tmp": Path("/private/tmp"),
@@ -991,6 +994,64 @@ def _stream_contains_nonfinite(value: Any) -> bool:
     return False
 
 
+def _stream_is_post_result_task_cleanup(
+    terminal_payload: dict[str, Any], events: list[dict[str, Any]],
+) -> bool:
+    """Recognize Claude Code's exact bounded background-task shutdown tail."""
+    if len(events) != 3:
+        return False
+    session_id = terminal_payload.get("session_id")
+    if not isinstance(session_id, str) or not session_id:
+        return False
+    changed, updated, notification = events
+    if (
+        set(changed) != {"type", "subtype", "session_id", "tasks", "uuid"}
+        or changed.get("type") != "system"
+        or changed.get("subtype") != "background_tasks_changed"
+        or changed.get("session_id") != session_id
+        or changed.get("tasks") != []
+        or not isinstance(changed.get("uuid"), str)
+        or not changed["uuid"]
+    ):
+        return False
+    patch = updated.get("patch")
+    task_id = updated.get("task_id")
+    if (
+        set(updated) != {"type", "subtype", "session_id", "task_id", "patch", "uuid"}
+        or updated.get("type") != "system"
+        or updated.get("subtype") != "task_updated"
+        or updated.get("session_id") != session_id
+        or not isinstance(task_id, str)
+        or not task_id
+        or not isinstance(patch, dict)
+        or set(patch) != {"end_time", "status"}
+        or isinstance(patch.get("end_time"), bool)
+        or not isinstance(patch.get("end_time"), int)
+        or patch["end_time"] < 0
+        or patch.get("status") != "killed"
+        or not isinstance(updated.get("uuid"), str)
+        or not updated["uuid"]
+    ):
+        return False
+    return (
+        set(notification) == {
+            "type", "subtype", "session_id", "task_id", "tool_use_id",
+            "status", "summary", "output_file", "uuid",
+        }
+        and notification.get("type") == "system"
+        and notification.get("subtype") == "task_notification"
+        and notification.get("session_id") == session_id
+        and notification.get("task_id") == task_id
+        and isinstance(notification.get("tool_use_id"), str)
+        and bool(notification["tool_use_id"])
+        and notification.get("status") == "stopped"
+        and isinstance(notification.get("summary"), str)
+        and isinstance(notification.get("output_file"), str)
+        and isinstance(notification.get("uuid"), str)
+        and bool(notification["uuid"])
+    )
+
+
 def parse_claude_stream_output(
     stdout: bytes | str,
     *,
@@ -1046,6 +1107,7 @@ def parse_claude_stream_output(
     terminal_payload: dict[str, Any] | None = None
     terminal_result_code: str | None = None
     terminal_status: str | None = None
+    post_result_events: list[dict[str, Any]] = []
     for raw_line in physical_lines:
         # CR in a CRLF record is a delimiter byte, not part of the JSON content.
         line = raw_line[:-1] if raw_line.endswith(b"\r") else raw_line
@@ -1104,11 +1166,14 @@ def parse_claude_stream_output(
 
         is_result = event.get("type") == "result"
         if terminal_payload is not None:
-            return _stream_result(
-                "invalid_stream",
-                result_code="invalid_stream",
-                error_code="stream_duplicate_result" if is_result else "stream_post_result",
-            )
+            if is_result:
+                return _stream_result(
+                    "invalid_stream",
+                    result_code="invalid_stream",
+                    error_code="stream_duplicate_result",
+                )
+            post_result_events.append(event)
+            continue
         if not is_result:
             continue
 
@@ -1144,6 +1209,12 @@ def parse_claude_stream_output(
             result_code="missing_terminal",
             error_code="stream_missing_terminal",
         )
+    if post_result_events and not _stream_is_post_result_task_cleanup(
+        terminal_payload, post_result_events,
+    ):
+        return _stream_result(
+            "invalid_stream", result_code="invalid_stream", error_code="stream_post_result",
+        )
     return _stream_result(
         terminal_status,
         result_code=terminal_result_code,
@@ -1484,8 +1555,11 @@ def _measurement_parse_variant(
     if any(item not in MEASUREMENT_DOCUMENTED_HOOK_EVENTS for item in required_event_classes):
         raise SystemExit(f"{owner}.hook_events.required_event_classes contains unsupported hook event")
     ordered_classes = tuple(dict.fromkeys(event for event, _command in registered_bindings))
-    if required_event_classes != ordered_classes:
-        raise SystemExit(f"{owner}.hook_events.required_event_classes must match binding order")
+    required_set = set(required_event_classes)
+    if required_event_classes != tuple(event for event in ordered_classes if event in required_set):
+        raise SystemExit(
+            f"{owner}.hook_events.required_event_classes must be an ordered subset of registered hook events"
+        )
     if variant_name == "baseline" and (registered_bindings or required_event_classes):
         raise SystemExit(f"{owner} baseline hook configuration must be empty")
 
@@ -1638,7 +1712,7 @@ def _measurement_validate_treatment_bindings(spec: MeasurementVariant) -> dict[s
         raise SystemExit("measurement baseline and treatment settings differ outside registered hooks")
     binding_set = set(spec.registered_bindings)
     occurrences = {binding: 0 for binding in spec.registered_bindings}
-    for event in spec.required_event_classes:
+    for event in dict.fromkeys(event for event, _command in spec.registered_bindings):
         registrations = hooks.get(event)
         if not isinstance(registrations, list) or not registrations:
             raise SystemExit("measurement baseline and treatment settings differ outside registered hooks")
@@ -2632,7 +2706,12 @@ def collect_self_hosted_metrics(payload: Any) -> dict[str, Any] | None:
     return None
 
 
-def _measurement_child_env(spec: MeasurementVariant, context: MeasurementRunContext | None = None) -> dict[str, str]:
+def _measurement_child_env(
+    spec: MeasurementVariant,
+    context: MeasurementRunContext | None = None,
+    *,
+    existing_login_home: Path | None = None,
+) -> dict[str, str]:
     env: dict[str, str] = {}
     for name in spec.environment_allow:
         # Names were validated before this function; do not inspect values for
@@ -2644,14 +2723,15 @@ def _measurement_child_env(spec: MeasurementVariant, context: MeasurementRunCont
         env["PATH"] = os.defpath
     if context is not None:
         env.update({
-            "HOME": str(context.home),
+            "HOME": str(existing_login_home or context.home),
             "XDG_CONFIG_HOME": str(context.xdg_config),
             "XDG_CACHE_HOME": str(context.xdg_cache),
             "XDG_DATA_HOME": str(context.xdg_data),
             "XDG_STATE_HOME": str(context.xdg_state),
             "TMPDIR": str(context.tmp),
-            "CLAUDE_CONFIG_DIR": str(context.session),
         })
+        if existing_login_home is None:
+            env["CLAUDE_CONFIG_DIR"] = str(context.session)
     return env
 
 
@@ -2697,7 +2777,7 @@ def validate_measurement_cli_capabilities(claude_bin: str, spec: MeasurementVari
                 [executable, "--help"],
                 cwd=cwd,
                 timeout_seconds=10,
-                max_output_bytes=VERSION_OUTPUT_MAX_BYTES,
+                max_output_bytes=MEASUREMENT_CLI_PROBE_OUTPUT_MAX_BYTES,
                 env=env,
             )
         except (OSError, subprocess.TimeoutExpired, ValueError) as exc:
@@ -3061,6 +3141,7 @@ def run_task_checker_study(
     workspace: Path,
     *,
     env: dict[str, str],
+    interpreter_binding: Mapping[str, Any] | None = None,
 ) -> str:
     """Run the content-bound success checker outside the measured workspace.
 
@@ -3076,6 +3157,14 @@ def run_task_checker_study(
     payload = task.success_checker_bytes
     if not payload:
         return "success_checker_infra_invalid"
+    checker_executable = sys.executable
+    if interpreter_binding is not None:
+        try:
+            checker_executable = _benchmark_study_v2_assert_python_binding(
+                interpreter_binding, require_current=False,
+            )
+        except (OSError, TypeError, ValueError):
+            return "success_checker_infra_invalid"
     private_root: str | None = None
     try:
         private_root = tempfile.mkdtemp(prefix="contextguard-bench-checker-")
@@ -3091,7 +3180,7 @@ def run_task_checker_study(
         # PYTHONHOME/PYTHONSTARTUP 또는 sys.path[0] 로 들어오면 심어둔 sitecustomize.py 가
         # 판정기 안에서 실행되어 위협 모델이 무너진다. 환경도 물려받지 않고 최소로 만든다.
         result = run_bounded_command(
-            [sys.executable, "-I", str(checker_path)],
+            [checker_executable, "-I", str(checker_path)],
             cwd=workspace,
             timeout_seconds=600,
             max_output_bytes=SUCCESS_COMMAND_OUTPUT_MAX_BYTES,
@@ -3349,9 +3438,11 @@ def normalize_measurement_hook_events(raw: bytes) -> list[dict[str, Any]]:
 def _measurement_resolve_terminal_status(
     *, raw_byte_limit: bool, raw_line_limit: bool, raw_line_byte_limit: bool,
     process_status: str, stream_status: str, hook_result: dict[str, Any],
-    arm: str, required_event_classes: tuple[str, ...],
+    arm: str, allowed_event_classes: tuple[str, ...],
+    required_event_classes: tuple[str, ...],
 ) -> str:
     completed_classes = {item["hook_event"] for item in hook_result["hooks"]}
+    allowed_classes = set(allowed_event_classes)
     required_classes = set(required_event_classes)
     hook_process_failed = any(
         item["hook_process_outcome"] != "success" or item["hook_process_exit_code"] not in (None, 0)
@@ -3381,11 +3472,13 @@ def _measurement_resolve_terminal_status(
     ):
         if hook_result.get("classification") == status or status in hook_result.get("failure_flags", ()):
             return status
-    if arm == "treatment" and completed_classes - required_classes:
+    hook_arms = {"treatment", "legacy_trim", "bash_reference_v1"}
+    unmodified_arms = {"baseline", "host_unmodified"}
+    if arm in hook_arms and completed_classes - allowed_classes:
         return "unexpected_hook_event_class"
-    if arm == "baseline" and hook_result["observed"]:
+    if arm in unmodified_arms and hook_result["observed"]:
         return "baseline_hook_contamination"
-    if arm == "treatment" and required_classes - completed_classes:
+    if arm in hook_arms and required_classes - completed_classes:
         return "missing_required_hook_event_class"
     if hook_process_failed:
         return "hook_process_failure"
@@ -3429,12 +3522,13 @@ def _measurement_receipt(
 ) -> dict[str, Any]:
     raw_sha256 = hashlib.sha256(raw).hexdigest()
     raw_lines = len(raw.splitlines())
-    required_classes = tuple(dict.fromkeys(event for event, _command in spec.pair_registered_bindings))
+    allowed_classes = tuple(dict.fromkeys(event for event, _command in spec.pair_registered_bindings))
+    required_classes = spec.required_event_classes
     counts = collections.Counter(item["hook_event"] for item in hook_result["hooks"])
     event_class_counts = [
         {"hook_event": event, "count": counts[event]}
         for event in MEASUREMENT_DOCUMENTED_HOOK_EVENTS
-        if counts[event] or event in required_classes
+        if counts[event] or event in allowed_classes
     ]
     settings_relative = Path("session") / spec.settings_file.name
     return {
@@ -3503,6 +3597,10 @@ def _run_measurement_fixture_locked(
     locked_root_fd: int,
     on_process_started: Callable[[], None] | None = None,
     measurement_study: bool = False,
+    workspace_overlay: Path | None = None,
+    on_workspace_prepared: Callable[[Path], None] | None = None,
+    checker_interpreter_binding: Mapping[str, Any] | None = None,
+    existing_login_home: Path | None = None,
 ) -> RunResult:
     spec = variant.measurement
     assert spec is not None
@@ -3522,6 +3620,18 @@ def _run_measurement_fixture_locked(
             "load_task_fixture_trees for every task declaring fixture_tree"
         )
     reset_task_fixture_tree(task.fixture_tree_entries or (), context.workspace)
+    if workspace_overlay is not None:
+        destination = context.workspace / BENCHMARK_STUDY_V2_OVERLAY_NAME
+        if destination.exists() or destination.is_symlink():
+            raise SystemExit("measurement candidate overlay destination already exists")
+        shutil.copytree(
+            workspace_overlay,
+            destination,
+            symlinks=True,
+            copy_function=shutil.copy2,
+        )
+    if on_workspace_prepared is not None:
+        on_workspace_prepared(context.workspace)
     settings_snapshot = context.session / spec.settings_file.name
     _measurement_write_exclusive(settings_snapshot, spec.settings_source_bytes)
     try:
@@ -3535,7 +3645,9 @@ def _run_measurement_fixture_locked(
         variant,
         measurement_settings_file=settings_snapshot,
     )
-    env = _measurement_child_env(spec, context)
+    env = _measurement_child_env(
+        spec, context, existing_login_home=existing_login_home,
+    )
     try:
         try:
             proc = run_bounded_command(
@@ -3582,6 +3694,9 @@ def _run_measurement_fixture_locked(
         stream_status=parsed.status,
         hook_result=hook_result,
         arm=variant.name,
+        allowed_event_classes=tuple(
+            dict.fromkeys(event for event, _command in spec.pair_registered_bindings)
+        ),
         required_event_classes=spec.required_event_classes,
     )
 
@@ -3660,6 +3775,7 @@ def _run_measurement_fixture_locked(
                 )
             checker_classification = run_task_checker_study(
                 task, context.workspace, env=env,
+                interpreter_binding=checker_interpreter_binding,
             )
         else:
             checker_classification = run_success_command_study(task, project_root, env=env)
@@ -7402,7 +7518,8 @@ def _verify_existing_measurement_run(
         hooks = receipt.get("hooks")
         if not isinstance(hooks, list) or summary.get("completed_lifecycle_count") != len(hooks):
             raise ValueError("hook count")
-        required_classes = list(dict.fromkeys(event for event, _command in spec.pair_registered_bindings))
+        allowed_classes = list(dict.fromkeys(event for event, _command in spec.pair_registered_bindings))
+        required_classes = list(spec.required_event_classes)
         if summary.get("required_event_classes") != required_classes:
             raise ValueError("required hook classes")
         for count_name in ("observed_lifecycle_count", "completed_lifecycle_count"):
@@ -7443,7 +7560,7 @@ def _verify_existing_measurement_run(
         expected_counts = [
             {"hook_event": event, "count": counts[event]}
             for event in MEASUREMENT_DOCUMENTED_HOOK_EVENTS
-            if counts[event] or event in required_classes
+            if counts[event] or event in allowed_classes
         ]
         if summary.get("event_class_counts") != expected_counts:
             raise ValueError("event class counts")
@@ -7482,6 +7599,7 @@ def _verify_existing_measurement_run(
                 stream_status=reparsed_stream.status,
                 hook_result=reparsed_hooks,
                 arm=spec.identity.arm,
+                allowed_event_classes=tuple(allowed_classes),
                 required_event_classes=spec.required_event_classes,
             )
         expected_receipt = _measurement_receipt(
@@ -8063,8 +8181,10 @@ def parse_measurement_terminal_usage(raw: bytes | str) -> dict[str, int]:
     if parsed.payload is None or parsed.payload.get("type") != "result":
         raise ValueError("measurement terminal usage requires one terminal result record")
     usage = parsed.payload.get("usage")
-    if not isinstance(usage, dict) or set(usage) != set(MEASUREMENT_STUDY_USAGE_KEYS):
-        raise ValueError("measurement terminal usage must contain the exact four buckets")
+    # Claude Code may add diagnostic telemetry beside the four accounting
+    # buckets. Only the frozen required buckets participate in the estimator.
+    if not isinstance(usage, dict) or not set(MEASUREMENT_STUDY_USAGE_KEYS).issubset(usage):
+        raise ValueError("measurement terminal usage must contain all four required buckets")
     result: dict[str, int] = {}
     total = 0
     for key in MEASUREMENT_STUDY_USAGE_KEYS:
@@ -8681,6 +8801,10 @@ def append_study_attempt_event(path: Path, event: Mapping[str, Any]) -> None:
         fd = _open_regular_no_symlink(path, flags, 0o600)
         os.fchmod(fd, 0o600)
         _measurement_write_fd(fd, payload)
+        # A provider launch may follow this reservation immediately. Persist the
+        # directory entry as well as the file bytes so a power loss cannot make
+        # an already-consumed identity appear unreserved after restart.
+        os.fsync(parent_fd)
     finally:
         if fd >= 0:
             os.close(fd)
@@ -8932,7 +9056,7 @@ def run_measurement_cli_probes(
                 [claude_bin, flag],
                 cwd=Path("<probe-root>/cwd"),
                 timeout_seconds=10.0,
-                max_output_bytes=65_536,
+                max_output_bytes=MEASUREMENT_CLI_PROBE_OUTPUT_MAX_BYTES,
                 env=dict(env),
             )
             for flag in ("--version", "--help")
@@ -8968,7 +9092,16 @@ def run_measurement_cli_probes(
     root, paths = create_measurement_probe_layout()
     try:
         validate_measurement_probe_layout(root, paths)
-        path_value = f"{executable_path.parent}:/usr/bin:/bin:/usr/sbin:/sbin"
+        runtime_directories = [str(executable_path.parent)]
+        invoked = shutil.which(claude_bin)
+        if invoked is not None:
+            runtime_directories.append(str(Path(invoked).absolute().parent))
+        for runtime_name in ("node", "python3"):
+            runtime = shutil.which(runtime_name)
+            if runtime is not None:
+                runtime_directories.append(str(Path(runtime).absolute().parent))
+        runtime_directories.extend(("/usr/bin", "/bin", "/usr/sbin", "/sbin"))
+        path_value = os.pathsep.join(dict.fromkeys(runtime_directories))
         env = {
             "PATH": path_value,
             "LANG": "C",
@@ -8988,7 +9121,7 @@ def run_measurement_cli_probes(
                 [executable, flag],
                 cwd=paths["cwd"],
                 timeout_seconds=10,
-                max_output_bytes=65_536,
+                max_output_bytes=MEASUREMENT_CLI_PROBE_OUTPUT_MAX_BYTES,
                 env=env,
             ))
         version_raw = _study_validate_probe_output(results[0], kind="version")
@@ -9286,6 +9419,7 @@ def build_measurement_study_manifest(
                 "record_type": "result",
                 "object_path": "$.usage",
                 "keys": list(MEASUREMENT_STUDY_USAGE_KEYS),
+                "additional_fields": "ignored_not_counted_v1",
                 "integer_grammar": "0|[1-9][0-9]*",
                 "maximum": MAX_USAGE_TOKEN_COUNT,
                 "formula": "P=input_tokens+cache_creation_input_tokens+cache_read_input_tokens+output_tokens",
@@ -10452,85 +10586,4064 @@ def run_measurement_study_action(
     return 0
 
 
-def main(argv: Sequence[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    parser.add_argument("--tasks", required=True, type=Path, help="task fixture JSON")
-    parser.add_argument("--variants", required=True, type=Path, help="variant fixture JSON")
-    parser.add_argument("--csv", default=None, type=Path,
-                        help="results CSV path (header is added on first write)")
-    parser.add_argument("--task-id", default=None, help="run only the named task id")
-    parser.add_argument("--variant", default=None, help="run only the named variant")
-    parser.add_argument("--claude-bin", default=os.environ.get("CLAUDE_BIN", "claude"),
-                        help="claude CLI executable (default: $CLAUDE_BIN or 'claude')")
-    parser.add_argument("--project-root", default=Path("."), type=Path,
-                        help="working directory used for success_command (default: cwd)")
-    parser.add_argument("--dry-run", action="store_true",
-                        help="print the claude command without invoking it")
-    parser.add_argument("--resume", action="store_true",
-                        help="skip (task_id, variant) rows already present in --csv")
-    parser.add_argument("--ledger-jsonl", default=None, type=Path,
-                        help="optional JSONL ledger path for cost-shift accounting per run")
-    parser.add_argument("--report-json", default=None, type=Path,
-                        help="optional A/B summary report JSON path generated from --csv after real runs")
-    parser.add_argument("--dashboard-md", default=None, type=Path,
-                        help="optional Markdown dashboard path generated from the benchmark report")
-    parser.add_argument("--evidence-jsonl", default=None, type=Path,
-                        help="optional validated run-evidence JSONL replay input; skips provider invocation")
-    parser.add_argument("--baseline-variant", default="baseline",
-                        help="variant name used as the report baseline (default: baseline)")
-    parser.add_argument("--measurement-study-plan", default=None, type=Path,
-                        help="exact S002 measurement study plan JSON")
-    parser.add_argument(
-        "--measurement-study-action",
-        default=None,
-        choices=("prepare", "run", "resume", "analyze"),
-        help="S002 measurement study action",
-    )
-    parser.add_argument("--measurement-study-output-root", default=None, type=Path,
-                        help="private S002 measurement study artifact directory")
-    args = parser.parse_args(argv)
+# V2 is a separately-versioned analytical surface.  It intentionally does not
+# alter the frozen S001--S003 runner, manifest, or report contracts above.
+BENCHMARK_STUDY_V2_PLAN_SCHEMA_VERSION = "contextguard.bench.study-plan.v2"
+BENCHMARK_STUDY_V2_SCHEDULE_ALGORITHM = "splitmix64-blocked-three-arm-v1"
+BENCHMARK_STUDY_V2_ARMS = (
+    "host_unmodified", "legacy_trim", "bash_reference_v1",
+)
+BENCHMARK_STUDY_V2_PRIMARY_CONTRAST = ("host_unmodified", "bash_reference_v1")
+BENCHMARK_STUDY_V2_DIAGNOSTIC_CONTRAST = ("legacy_trim", "bash_reference_v1")
+BENCHMARK_STUDY_V2_RETRY_POLICY = "retain_valid_unfavorable_attempts_v1"
+BENCHMARK_STUDY_V2_EVIDENCE_FORBIDDEN_KEYS = frozenset({
+    "prompt", "output", "command", "command_hash", "command_sha256", "path",
+    "project_id", "capabilities", "credential", "credentials", "token", "secret",
+})
+BENCHMARK_STUDY_V2_HANDLE_RE = re.compile(r"(?i)\bcgr1p(?:[_-]|\b)")
+BENCHMARK_STUDY_V2_REVISION_KEYS = frozenset({
+    "backend_revision", "model_revision", "cli_version",
+})
+BENCHMARK_STUDY_V2_REVISION_RE = re.compile(
+    r"[A-Za-z0-9][A-Za-z0-9._+:/@-]{0,127}"
+)
+BENCHMARK_STUDY_V2_SECRET_SHAPE_RE = re.compile(
+    r"(?i)(?:"
+    r"\bsk-[A-Za-z0-9_-]{16,}"
+    r"|\b[rs]k_(?:live|test)_[A-Za-z0-9]{16,}"
+    r"|\bgithub_pat_[A-Za-z0-9_]{16,}"
+    r"|\bgh[pousr]_[A-Za-z0-9]{16,}"
+    r"|\bnpm_[A-Za-z0-9]{16,}"
+    r"|\bxox[baprs]-[A-Za-z0-9-]{16,}"
+    r"|\bA[KS]IA[0-9A-Z]{16}\b"
+    r"|\bAIza[0-9A-Za-z_-]{20,}"
+    r"|\bya29\.[0-9A-Za-z_-]{16,}"
+    r"|\bbearer\s+[0-9A-Za-z._~+/-]+=*"
+    r"|-----BEGIN [A-Z ]*PRIVATE KEY-----"
+    r")"
+)
+BENCHMARK_STUDY_V2_CHECKER_BINDING_DOMAIN = (
+    "contextguard.bench.v2.checker-binding.v1"
+)
+BENCHMARK_STUDY_V2_CORPUS_TASK_ORDER_DOMAIN = (
+    "contextguard.bench.v2.corpus-task-order.v1"
+)
 
-    require_no_follow_file_ops_supported()
-    study_values = (
-        args.measurement_study_plan,
-        args.measurement_study_action,
-        args.measurement_study_output_root,
+
+def _benchmark_study_v2_seed(seed: int | str) -> int:
+    if isinstance(seed, str):
+        if re.fullmatch(r"0x[0-9A-F]{16}", seed) is None:
+            raise ValueError("v2 schedule seed must be frozen uppercase 64-bit hex")
+        return int(seed, 16)
+    if isinstance(seed, bool) or not isinstance(seed, int) or not 0 <= seed <= SPLITMIX64_MASK:
+        raise ValueError("v2 schedule seed must be an unsigned 64-bit integer")
+    return seed
+
+
+def _benchmark_study_v2_task_ids(task_ids: Sequence[str]) -> list[str]:
+    normalized = list(task_ids)
+    if len(normalized) != 12 or len(set(normalized)) != 12:
+        raise ValueError("v2 study requires exactly 12 unique ordered task ids")
+    if any(not isinstance(task_id, str) or not task_id for task_id in normalized):
+        raise ValueError("v2 study task ids must be non-empty strings")
+    return normalized
+
+
+def generate_benchmark_study_v2_schedule(
+    task_ids: Sequence[str], *, repetitions: int, schedule_seed: int | str,
+) -> list[dict[str, Any]]:
+    """Create the pre-randomized 3-arm order for each task/repetition block."""
+    tasks = _benchmark_study_v2_task_ids(task_ids)
+    if repetitions != 3:
+        raise ValueError("v2 study requires exactly three repetitions")
+    state = _benchmark_study_v2_seed(schedule_seed)
+    schedule: list[dict[str, Any]] = []
+    for task_id in tasks:
+        for repetition in range(repetitions):
+            arm_order = list(BENCHMARK_STUDY_V2_ARMS)
+            for index in range(len(arm_order) - 1, 0, -1):
+                state, selected = splitmix64_bounded(state, index + 1)
+                arm_order[index], arm_order[selected] = arm_order[selected], arm_order[index]
+            schedule.append({
+                "block_id": _study_domain_hash(
+                    "contextguard.bench.v2.block-id.v1", [task_id, repetition],
+                ),
+                "task_id": task_id,
+                "repetition": repetition,
+                "arm_order": arm_order,
+            })
+    return schedule
+
+
+def generate_benchmark_study_v2_slots(
+    task_ids: Sequence[str], schedule: Sequence[Mapping[str, Any]], *,
+    candidate_hash: str, namespace: str,
+) -> list[dict[str, Any]]:
+    """Materialize immutable initial/retry identities without replacement."""
+    tasks = _benchmark_study_v2_task_ids(task_ids)
+    if SHA256_HEX_PATTERN.fullmatch(candidate_hash) is None:
+        raise ValueError("v2 candidate hash is invalid")
+    if not isinstance(namespace, str) or not MEASUREMENT_ID_NAMESPACE_RE.fullmatch(namespace):
+        raise ValueError("v2 namespace is invalid")
+    expected_blocks = [(task, repetition) for task in tasks for repetition in range(3)]
+    if [(row.get("task_id"), row.get("repetition")) for row in schedule] != expected_blocks:
+        raise ValueError("v2 schedule task/repetition order drift")
+    initial: list[dict[str, Any]] = []
+    retry: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for block in schedule:
+        arm_order = block.get("arm_order")
+        if not isinstance(arm_order, list) or set(arm_order) != set(BENCHMARK_STUDY_V2_ARMS) or len(arm_order) != 3:
+            raise ValueError("v2 block arm order is invalid")
+        for arm in arm_order:
+            for attempt, state, destination in ((0, "planned", initial), (1, "conditional", retry)):
+                run_id = MeasurementIdentity(
+                    candidate_hash=candidate_hash, repetition=int(block["repetition"]),
+                    arm=arm, attempt=attempt, namespace=namespace,
+                ).run_id(str(block["task_id"]))
+                if run_id in seen:
+                    raise ValueError("v2 run identity collision")
+                seen.add(run_id)
+                destination.append({
+                    "block_id": block["block_id"], "task_id": block["task_id"],
+                    "repetition": block["repetition"], "arm": arm, "attempt": attempt,
+                    "run_id": run_id, "state": state,
+                })
+    slots = initial + retry
+    validate_benchmark_study_v2_slots(slots, task_ids=tasks)
+    return slots
+
+
+def validate_benchmark_study_v2_slots(
+    slots: Sequence[Mapping[str, Any]], *, task_ids: Sequence[str],
+) -> None:
+    tasks = _benchmark_study_v2_task_ids(task_ids)
+    if len(slots) != 216:
+        raise ValueError("v2 study requires exactly 216 immutable slots")
+    expected = {
+        (task, repetition, arm, attempt)
+        for task in tasks for repetition in range(3)
+        for arm in BENCHMARK_STUDY_V2_ARMS for attempt in (0, 1)
+    }
+    observed: set[tuple[str, int, str, int]] = set()
+    run_ids: set[str] = set()
+    required = {"block_id", "task_id", "repetition", "arm", "attempt", "run_id", "state"}
+    for slot in slots:
+        if set(slot) != required:
+            raise ValueError("v2 slot schema mismatch")
+        key = (slot["task_id"], slot["repetition"], slot["arm"], slot["attempt"])
+        if key in observed or key not in expected or slot["run_id"] in run_ids:
+            raise ValueError("v2 slot identity mismatch")
+        if slot["state"] != ("planned" if slot["attempt"] == 0 else "conditional"):
+            raise ValueError("v2 slot state mismatch")
+        if not isinstance(slot["run_id"], str) or SHA256_HEX_PATTERN.fullmatch(slot["run_id"]) is None:
+            raise ValueError("v2 slot run id is invalid")
+        observed.add(key)
+        run_ids.add(slot["run_id"])
+    if observed != expected:
+        raise ValueError("v2 slot coverage mismatch")
+
+
+def benchmark_study_v2_contrasts(_values: Mapping[str, Any] | None = None) -> dict[str, list[str]]:
+    """Expose the single product contrast separately from its diagnostic control."""
+    return {
+        "primary": list(BENCHMARK_STUDY_V2_PRIMARY_CONTRAST),
+        "diagnostic": list(BENCHMARK_STUDY_V2_DIAGNOSTIC_CONTRAST),
+    }
+
+
+def _benchmark_study_v2_cluster_interval(values_by_task: Sequence[Sequence[float]]) -> dict[str, Any]:
+    task_count = len(values_by_task)
+    if task_count < 2 or any(len(row) != 3 for row in values_by_task):
+        raise ValueError("v2 task-cluster interval requires task x 3 values")
+    task_means = [sum(float(value) for value in row) / 3.0 for row in values_by_task]
+    state = MEASUREMENT_STUDY_INFERENCE_SEED
+    estimates: list[float] = []
+    for _ in range(MEASUREMENT_STUDY_BOOTSTRAP_RESAMPLES):
+        total = 0.0
+        for _ in range(task_count):
+            state, index = splitmix64_bounded(state, task_count)
+            total += task_means[index]
+        estimates.append(total / task_count)
+    return {
+        "method": "task_cluster_bootstrap_v2",
+        "point": sum(task_means) / task_count,
+        "q025": float(type7_quantile(estimates, 0.025)),
+        "q975": float(type7_quantile(estimates, 0.975)),
+        "task_count": task_count,
+        "resamples": MEASUREMENT_STUDY_BOOTSTRAP_RESAMPLES,
+    }
+
+
+def infer_benchmark_study_v2_binary(
+    rows: Sequence[Mapping[str, Any]], *, task_order: Sequence[str], ni_margin: float = 0.10,
+) -> dict[str, Any]:
+    """Exact task-cluster sign-permutation inference for the product contrast."""
+    tasks = _benchmark_study_v2_task_ids(task_order)
+    if not isinstance(ni_margin, (int, float)) or isinstance(ni_margin, bool) or not 0 <= ni_margin < 1:
+        raise ValueError("v2 non-inferiority margin is invalid")
+    units: dict[tuple[str, int, str], bool] = {}
+    for row in rows:
+        task_id, repetition, arm, success = row.get("task_id"), row.get("repetition"), row.get("arm"), row.get("success")
+        if task_id not in tasks or repetition not in (0, 1, 2) or arm not in BENCHMARK_STUDY_V2_PRIMARY_CONTRAST or not isinstance(success, bool):
+            raise ValueError("v2 binary outcome identity is invalid")
+        key = (str(task_id), int(repetition), str(arm))
+        if key in units:
+            raise ValueError("duplicate v2 binary outcome")
+        units[key] = success
+    expected = {
+        (task, repetition, arm) for task in tasks for repetition in range(3)
+        for arm in BENCHMARK_STUDY_V2_PRIMARY_CONTRAST
+    }
+    if set(units) != expected:
+        raise ValueError("v2 binary outcome coverage is incomplete")
+    task_deltas = [
+        sum(
+            int(units[(task, repetition, "bash_reference_v1")])
+            - int(units[(task, repetition, "host_unmodified")])
+            for repetition in range(3)
+        ) / 3.0
+        for task in tasks
+    ]
+    point = sum(task_deltas) / len(tasks)
+    all_success = all(units.values())
+    # At the NI boundary, reference-minus-host plus the frozen margin has mean
+    # zero. Sign-flip that centered task effect, never the nested run rows.
+    centered_deltas = [value + float(ni_margin) for value in task_deltas]
+    outcomes = []
+    for mask in range(1 << len(tasks)):
+        outcomes.append(sum(
+            (-value if mask & (1 << index) else value)
+            for index, value in enumerate(centered_deltas)
+        ) / len(tasks))
+    observed_statistic = point + float(ni_margin)
+    p_value = (
+        sum(value >= observed_statistic for value in outcomes) + 1
+    ) / (len(outcomes) + 1)
+    return {
+        "method": "exact_task_cluster_sign_permutation_v1",
+        "contrast": list(BENCHMARK_STUDY_V2_PRIMARY_CONTRAST),
+        "task_ids_sha256": _study_domain_hash(
+            "contextguard.bench.v2.task-order.v1", tasks,
+        ),
+        "point": point,
+        "ni_margin": float(ni_margin),
+        "p_value": p_value,
+        "task_count": len(tasks),
+        "degenerate_all_success": all_success,
+        "noninferiority_pass": bool(not all_success and point > -float(ni_margin) and p_value < 0.05),
+    }
+
+
+def compute_benchmark_study_v2_effects(
+    records: Sequence[Mapping[str, Any]], *, task_order: Sequence[str],
+) -> dict[str, Any]:
+    """Retain every valid terminal attempt and derive task-clustered effects."""
+    tasks = _benchmark_study_v2_task_ids(task_order)
+    grouped: dict[tuple[str, int, str], list[Mapping[str, Any]]] = collections.defaultdict(list)
+    for record in records:
+        task_id, repetition, arm = record.get("task_id"), record.get("repetition"), record.get("arm")
+        if task_id not in tasks or repetition not in (0, 1, 2) or arm not in BENCHMARK_STUDY_V2_ARMS:
+            raise ValueError("v2 effect record identity is invalid")
+        grouped[(str(task_id), int(repetition), str(arm))].append(record)
+    token_deltas: list[list[float]] = []
+    diagnostic_token_deltas: list[list[float]] = []
+    metric_deltas: dict[str, list[list[float]]] = {"correction": [], "retrieval": []}
+    diagnostic_metric_deltas: dict[str, list[list[float]]] = {
+        "correction": [], "retrieval": [],
+    }
+    metric_available = {"correction": True, "retrieval": True}
+    retained_unfavorable = 0
+    for task in tasks:
+        per_task: list[float] = []
+        diagnostic_per_task: list[float] = []
+        per_task_metrics: dict[str, list[float]] = {"correction": [], "retrieval": []}
+        diagnostic_per_task_metrics: dict[str, list[float]] = {
+            "correction": [], "retrieval": [],
+        }
+        for repetition in range(3):
+            costs: dict[str, float] = {}
+            metrics: dict[str, dict[str, float]] = {"correction": {}, "retrieval": {}}
+            for arm in BENCHMARK_STUDY_V2_ARMS:
+                attempts = sorted(grouped.get((task, repetition, arm), ()), key=lambda row: int(row.get("attempt", -1)))
+                if not attempts or [row.get("attempt") for row in attempts] not in ([0], [0, 1]):
+                    raise ValueError("v2 attempts are incomplete or replaced")
+                values = []
+                for row in attempts:
+                    token = row.get("tokens")
+                    if (
+                        isinstance(token, bool)
+                        or not isinstance(token, (int, float))
+                        or not math.isfinite(float(token))
+                        or token < 0
+                    ):
+                        raise ValueError("v2 token value is invalid")
+                    if row.get("terminal_status") != "success" or row.get("success") is not True:
+                        retained_unfavorable += 1
+                    values.append(float(token))
+                costs[arm] = sum(values)
+                for metric in metrics:
+                    attempt_values = [row.get(metric) for row in attempts]
+                    if any(
+                        isinstance(value, bool)
+                        or not isinstance(value, (int, float))
+                        or not math.isfinite(float(value))
+                        or value < 0
+                        for value in attempt_values
+                    ):
+                        metric_available[metric] = False
+                        continue
+                    metrics[metric][arm] = sum(
+                        float(value) for value in attempt_values
+                    )
+            per_task.append(costs["host_unmodified"] - costs["bash_reference_v1"])
+            diagnostic_per_task.append(
+                costs["legacy_trim"] - costs["bash_reference_v1"]
+            )
+            for metric, values in metrics.items():
+                if set(values) == set(BENCHMARK_STUDY_V2_ARMS):
+                    per_task_metrics[metric].append(
+                        values["host_unmodified"] - values["bash_reference_v1"]
+                    )
+                    diagnostic_per_task_metrics[metric].append(
+                        values["legacy_trim"] - values["bash_reference_v1"]
+                    )
+        token_deltas.append(per_task)
+        diagnostic_token_deltas.append(diagnostic_per_task)
+        for metric in metric_deltas:
+            if len(per_task_metrics[metric]) == 3:
+                metric_deltas[metric].append(per_task_metrics[metric])
+                diagnostic_metric_deltas[metric].append(
+                    diagnostic_per_task_metrics[metric]
+                )
+            else:
+                metric_available[metric] = False
+    metric_effects = {
+        f"{metric}_effect": (
+            _benchmark_study_v2_cluster_interval(metric_deltas[metric])
+            if metric_available[metric] and len(metric_deltas[metric]) == len(tasks)
+            else {"method": "unavailable", "point": None, "q025": None, "q975": None}
+        )
+        for metric in metric_deltas
+    }
+    diagnostic_metric_effects = {
+        f"diagnostic_{metric}_effect": (
+            _benchmark_study_v2_cluster_interval(diagnostic_metric_deltas[metric])
+            if metric_available[metric]
+            and len(diagnostic_metric_deltas[metric]) == len(tasks)
+            else {"method": "unavailable", "point": None, "q025": None, "q975": None}
+        )
+        for metric in diagnostic_metric_deltas
+    }
+    return {
+        "primary_contrast": list(BENCHMARK_STUDY_V2_PRIMARY_CONTRAST),
+        "diagnostic_contrast": list(BENCHMARK_STUDY_V2_DIAGNOSTIC_CONTRAST),
+        "task_ids_sha256": _study_domain_hash(
+            "contextguard.bench.v2.task-order.v1", tasks,
+        ),
+        "retained_unfavorable_runs": retained_unfavorable,
+        "token_effect": _benchmark_study_v2_cluster_interval(token_deltas),
+        "diagnostic_token_effect": _benchmark_study_v2_cluster_interval(
+            diagnostic_token_deltas
+        ),
+        "quality_gate": False,
+        "failure_gate": False,
+        "correction_gate": False,
+        "retrieval_gate": False,
+        "shifted_cost_gate": False,
+        **metric_effects,
+        **diagnostic_metric_effects,
+    }
+
+
+def make_benchmark_study_v2_plan(
+    *, schedule_seed: str, required_task_count: int, corpus_sha256: str = "0" * 64,
+    checker_sha256: str = "0" * 64, task_ids_sha256: str = "0" * 64,
+    ni_margin: float = 0.10,
+) -> dict[str, Any]:
+    """Build the immutable, a-priori v2 analysis plan for a frozen corpus."""
+    plan = {
+        "schema_version": BENCHMARK_STUDY_V2_PLAN_SCHEMA_VERSION,
+        "arms": list(BENCHMARK_STUDY_V2_ARMS), "schedule_seed": schedule_seed,
+        "repetitions": 3, "max_attempts_per_arm_unit": 2,
+        "retry_policy": BENCHMARK_STUDY_V2_RETRY_POLICY,
+        "corpus_sha256": corpus_sha256, "checker_sha256": checker_sha256,
+        "task_ids_sha256": task_ids_sha256,
+        "primary_contrast": list(BENCHMARK_STUDY_V2_PRIMARY_CONTRAST),
+        "diagnostic_contrast": list(BENCHMARK_STUDY_V2_DIAGNOSTIC_CONTRAST),
+        "noninferiority_margin": ni_margin,
+        "power": {
+            "claim_capable": False,
+            "method": "not_estimated_without_independent_effect_model_v1",
+            "reason": "fixed_12_task_corpus_is_descriptive_only",
+            "required_task_count": required_task_count,
+        },
+        "exclusions": "none_after_schedule_except_prelaunch_refusal_v1",
+        "missing_data": "incomplete_primary_pair_is_descriptive_only_v1",
+        "contamination": "any_contamination_blocks_claim_v1",
+        "stopping": "fixed_task_count_no_optional_stopping_v1",
+        "model_cli_fields": ["model_revision", "backend_revision", "cli_version"],
+        "gates": ["quality", "failure", "correction", "retrieval", "shifted_cost"],
+    }
+    validate_benchmark_study_v2_plan(plan)
+    return plan
+
+
+def validate_benchmark_study_v2_plan(plan: Mapping[str, Any]) -> None:
+    required = {
+        "schema_version", "arms", "schedule_seed", "repetitions", "max_attempts_per_arm_unit", "retry_policy",
+        "corpus_sha256", "checker_sha256", "task_ids_sha256", "primary_contrast", "diagnostic_contrast", "noninferiority_margin",
+        "power", "exclusions", "missing_data", "contamination", "stopping", "model_cli_fields", "gates",
+    }
+    if set(plan) != required or plan.get("schema_version") != BENCHMARK_STUDY_V2_PLAN_SCHEMA_VERSION:
+        raise ValueError("v2 study plan schema mismatch")
+    _benchmark_study_v2_seed(plan["schedule_seed"])
+    if plan["arms"] != list(BENCHMARK_STUDY_V2_ARMS) or plan["primary_contrast"] != list(BENCHMARK_STUDY_V2_PRIMARY_CONTRAST) or plan["diagnostic_contrast"] != list(BENCHMARK_STUDY_V2_DIAGNOSTIC_CONTRAST):
+        raise ValueError("v2 study arms or contrasts drifted")
+    if plan["repetitions"] != 3 or plan["max_attempts_per_arm_unit"] != 2 or plan["retry_policy"] != BENCHMARK_STUDY_V2_RETRY_POLICY:
+        raise ValueError("v2 study retry contract drifted")
+    if any(not isinstance(plan[key], str) or SHA256_HEX_PATTERN.fullmatch(plan[key]) is None for key in ("corpus_sha256", "checker_sha256", "task_ids_sha256")):
+        raise ValueError("v2 corpus/checker/task-order binding is invalid")
+    if not isinstance(plan["noninferiority_margin"], (int, float)) or isinstance(plan["noninferiority_margin"], bool) or not 0 <= plan["noninferiority_margin"] < 1:
+        raise ValueError("v2 non-inferiority margin is invalid")
+    power = plan["power"]
+    if (
+        not isinstance(power, Mapping)
+        or set(power) != {"claim_capable", "method", "reason", "required_task_count"}
+        or power.get("claim_capable") is not False
+        or power.get("method") != "not_estimated_without_independent_effect_model_v1"
+        or power.get("reason") != "fixed_12_task_corpus_is_descriptive_only"
+        or power.get("required_task_count") != 12
+    ):
+        raise ValueError("v2 descriptive sample-size contract is unavailable or invalid")
+    if plan["model_cli_fields"] != ["model_revision", "backend_revision", "cli_version"] or plan["gates"] != ["quality", "failure", "correction", "retrieval", "shifted_cost"]:
+        raise ValueError("v2 provenance or gate contract drifted")
+    frozen_text = {
+        "exclusions": "none_after_schedule_except_prelaunch_refusal_v1",
+        "missing_data": "incomplete_primary_pair_is_descriptive_only_v1",
+        "contamination": "any_contamination_blocks_claim_v1",
+        "stopping": "fixed_task_count_no_optional_stopping_v1",
+    }
+    if any(plan[key] != expected for key, expected in frozen_text.items()):
+        raise ValueError("v2 study plan operational rule drifted")
+
+
+def load_benchmark_study_v2_plan(path: Path) -> dict[str, Any]:
+    """Load only canonical JSON so a plan's signed-by-bytes form is stable."""
+    raw = _read_bytes_no_follow(path, max_bytes=100_000)
+    try:
+        value = json.loads(raw.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise ValueError("v2 study plan is invalid JSON") from exc
+    if not isinstance(value, dict) or raw != _study_canonical_json_bytes(value):
+        raise ValueError("v2 study plan must be canonical JSON")
+    validate_benchmark_study_v2_plan(value)
+    return value
+
+
+def validate_benchmark_study_v2_bindings(
+    plan: Mapping[str, Any], *, corpus_bytes: bytes,
+    checker_binding: Mapping[str, Any],
+) -> None:
+    """Bind the raw corpus and domain-separated ordered checker inventory."""
+    validate_benchmark_study_v2_plan(plan)
+    if not isinstance(corpus_bytes, bytes):
+        raise ValueError("v2 corpus/checker binding bytes are invalid")
+    validate_benchmark_study_v2_checker_binding(checker_binding)
+    try:
+        task_ids = _benchmark_study_v2_task_ids_from_corpus(corpus_bytes)
+    except ValueError as exc:
+        raise ValueError("v2 corpus/checker/task-order binding drift") from exc
+    if (
+        _study_sha256_bytes(corpus_bytes) != plan["corpus_sha256"]
+        or checker_binding["sha256"] != plan["checker_sha256"]
+        or _benchmark_study_v2_task_ids_sha256(task_ids)
+        != plan["task_ids_sha256"]
+    ):
+        raise ValueError("v2 corpus/checker/task-order binding drift")
+
+
+def validate_benchmark_study_v2_checker_binding(
+    binding: Mapping[str, Any],
+) -> None:
+    """Validate the filename/size/content inventory before trusting its digest."""
+    if not isinstance(binding, Mapping) or set(binding) != {
+        "domain", "files", "sha256",
+    }:
+        raise ValueError("v2 checker binding schema is invalid")
+    files = binding["files"]
+    if (
+        binding["domain"] != BENCHMARK_STUDY_V2_CHECKER_BINDING_DOMAIN
+        or not isinstance(files, list)
+        or len(files) != 12
+    ):
+        raise ValueError("v2 checker binding inventory is invalid")
+    filenames: list[str] = []
+    for entry in files:
+        if not isinstance(entry, Mapping) or set(entry) != {
+            "filename", "size", "sha256",
+        }:
+            raise ValueError("v2 checker binding entry is invalid")
+        filename, size, digest = (
+            entry["filename"], entry["size"], entry["sha256"],
+        )
+        if (
+            not isinstance(filename, str)
+            or not filename.endswith(".py")
+            or Path(filename).name != filename
+            or isinstance(size, bool)
+            or not isinstance(size, int)
+            or not 0 <= size <= MAX_FIXTURE_FILE_BYTES
+            or not isinstance(digest, str)
+            or SHA256_HEX_PATTERN.fullmatch(digest) is None
+        ):
+            raise ValueError("v2 checker binding entry is invalid")
+        filenames.append(filename)
+    if filenames != sorted(filenames) or len(set(filenames)) != len(filenames):
+        raise ValueError("v2 checker binding order is invalid")
+    expected = _study_domain_hash(
+        BENCHMARK_STUDY_V2_CHECKER_BINDING_DOMAIN, files,
     )
-    if any(value is not None for value in study_values):
-        if not all(value is not None for value in study_values):
-            parser.error(
-                "--measurement-study-plan, --measurement-study-action, and "
-                "--measurement-study-output-root are all-or-none"
+    if binding["sha256"] != expected:
+        raise ValueError("v2 checker binding digest is invalid")
+
+
+def validate_benchmark_study_v2_evidence_metadata(metadata: Mapping[str, Any]) -> None:
+    """Fail closed before potentially sensitive execution evidence reaches a report."""
+    def visit(value: Any, key: str = "") -> None:
+        key_lower = key.lower()
+        # `tokens` is the aggregate study metric, not a credential-shaped token.
+        # All other token-bearing field names remain forbidden.
+        if key_lower == "tokens" and (
+            isinstance(value, bool)
+            or not isinstance(value, (int, float))
+            or not math.isfinite(float(value))
+            or value < 0
+        ):
+            raise ValueError("unsafe evidence token metric is invalid")
+        if (
+            key_lower != "tokens"
+            and any(forbidden in key_lower for forbidden in BENCHMARK_STUDY_V2_EVIDENCE_FORBIDDEN_KEYS)
+        ):
+            raise ValueError("unsafe evidence field is forbidden")
+        if isinstance(value, str):
+            if (
+                BENCHMARK_STUDY_V2_HANDLE_RE.search(value)
+                or BENCHMARK_STUDY_V2_SECRET_SHAPE_RE.search(value)
+            ):
+                raise ValueError("unsafe evidence secret-shaped value is forbidden")
+            if (
+                key_lower in BENCHMARK_STUDY_V2_REVISION_KEYS
+                and BENCHMARK_STUDY_V2_REVISION_RE.fullmatch(value) is None
+            ):
+                raise ValueError("unsafe evidence revision format is invalid")
+        if isinstance(value, Mapping):
+            for child_key, child in value.items():
+                if not isinstance(child_key, str):
+                    raise ValueError("unsafe evidence key is invalid")
+                visit(child, child_key)
+        elif isinstance(value, (list, tuple)):
+            for child in value:
+                visit(child, key)
+    visit(metadata)
+
+
+def redact_benchmark_study_v2_evidence(value: str) -> str:
+    """Safe display helper for planted/accidental cgr1p handles; reports still reject them."""
+    return BENCHMARK_STUDY_V2_HANDLE_RE.sub("[REDACTED_HANDLE]", value)
+
+
+def evaluate_benchmark_study_v2_claim_readiness(
+    *, plan: Mapping[str, Any], task_ids: Sequence[str], binary_inference: Mapping[str, Any],
+    effects: Mapping[str, Any], provenance: Mapping[str, Any],
+    binary_rows: Sequence[Mapping[str, Any]] | None = None,
+    effect_records: Sequence[Mapping[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Return a fail-closed product-claim gate; diagnostic results are ignored."""
+    validate_benchmark_study_v2_plan(plan)
+    unique_tasks = list(dict.fromkeys(task_ids))
+    task_order: list[str] | None = None
+    try:
+        task_order = _benchmark_study_v2_task_ids(task_ids)
+    except (TypeError, ValueError):
+        pass
+    power_ready = bool(
+        plan["power"].get("claim_capable") is True
+        and len(unique_tasks) >= int(plan["power"]["required_task_count"])
+    )
+    provenance_safe = True
+    try:
+        validate_benchmark_study_v2_evidence_metadata(provenance)
+    except (TypeError, ValueError):
+        provenance_safe = False
+    provider_ready = bool(
+        provenance_safe
+        and provenance.get("source") == "provider_export"
+        and provenance.get("complete_provider_export") is True
+        and isinstance(provenance.get("backend_revision"), str) and provenance["backend_revision"]
+        and isinstance(provenance.get("model_revision"), str) and provenance["model_revision"]
+        and isinstance(provenance.get("cli_version"), str) and provenance["cli_version"]
+    )
+    recomputed_inference: dict[str, Any] | None = None
+    if task_order is not None and binary_rows is not None:
+        try:
+            recomputed_inference = infer_benchmark_study_v2_binary(
+                binary_rows,
+                task_order=task_order,
+                ni_margin=float(plan["noninferiority_margin"]),
             )
-        conflicts = [
-            name for name, active in (
-                ("--task-id", args.task_id is not None),
-                ("--variant", args.variant is not None),
-                ("--resume", args.resume),
-                ("--evidence-jsonl", args.evidence_jsonl is not None),
-                ("--dry-run", args.dry_run),
-                ("--ledger-jsonl", args.ledger_jsonl is not None),
-                ("--report-json", args.report_json is not None),
-                ("--dashboard-md", args.dashboard_md is not None),
-                ("--csv", args.csv is not None),
-                ("--baseline-variant", args.baseline_variant != "baseline"),
-            ) if active
-        ]
-        if conflicts:
-            parser.error(f"measurement study mode conflicts with {', '.join(conflicts)}")
-        return run_measurement_study_action(args)
-    args.csv = args.csv or Path("bench/results.csv")
-    validate_distinct_output_paths(args.csv, args.ledger_jsonl, args.report_json, args.dashboard_md)
+        except (AttributeError, TypeError, ValueError):
+            pass
+    binary_ready = bool(
+        recomputed_inference is not None
+        and dict(binary_inference) == recomputed_inference
+        and recomputed_inference["degenerate_all_success"] is False
+        and recomputed_inference["noninferiority_pass"] is True
+    )
 
-    variants = parse_variants(args.variants)
-    tasks = parse_tasks(args.tasks, variants=variants)
-    targets = filter_targets(tasks, variants, args.task_id, args.variant)
-    if not targets:
-        if args.dry_run and (not tasks or not variants):
-            print("completed 0 run(s) (dry-run; no CSV writes)")
-            return 0
-        print("no (task, variant) targets matched the filters", file=sys.stderr)
-        return 1
+    recomputed_effects: dict[str, Any] | None = None
+    if task_order is not None and effect_records is not None:
+        try:
+            recomputed_effects = compute_benchmark_study_v2_effects(
+                effect_records, task_order=task_order,
+            )
+        except (AttributeError, TypeError, ValueError):
+            pass
+    bound_effect_fields = (
+        "primary_contrast", "diagnostic_contrast", "task_ids_sha256",
+        "retained_unfavorable_runs", "token_effect", "diagnostic_token_effect",
+        "correction_effect", "diagnostic_correction_effect",
+        "retrieval_effect", "diagnostic_retrieval_effect",
+    )
+    effects_bound = bool(
+        recomputed_effects is not None
+        and all(
+            effects.get(field) == recomputed_effects.get(field)
+            for field in bound_effect_fields
+        )
+    )
+
+    def interval_gate(field: str, *, strict: bool) -> bool:
+        if recomputed_effects is None:
+            return False
+        interval = recomputed_effects.get(field)
+        if not isinstance(interval, Mapping) or interval.get("method") != "task_cluster_bootstrap_v2":
+            return False
+        lower = interval.get("q025")
+        if isinstance(lower, bool) or not isinstance(lower, (int, float)) or not math.isfinite(float(lower)):
+            return False
+        return bool(lower > 0 if strict else lower >= 0)
+
+    derived_gates = {
+        "quality": binary_ready,
+        "failure": binary_ready,
+        "correction": interval_gate("correction_effect", strict=False),
+        "retrieval": interval_gate("retrieval_effect", strict=False),
+        "shifted_cost": interval_gate("token_effect", strict=True),
+    }
+    effect_ready = bool(effects_bound and all(derived_gates.values()))
+    contamination_ready = provenance.get("contaminated") is False
+    mixed_versions_ready = provenance.get("mixed_versions") is False
+    missing_data_ready = provenance.get("missing_primary_data") is False
+    unmet = []
+    for name, value in (("power", power_ready), ("provider_provenance", provider_ready), ("binary_inference", binary_ready), ("effect_gates", effect_ready), ("contamination", contamination_ready), ("mixed_versions", mixed_versions_ready), ("missing_data", missing_data_ready)):
+        if not value:
+            unmet.append(name)
+    return {
+        "claim_ready": not unmet,
+        "descriptive_only": bool(unmet),
+        "unmet_gates": unmet,
+        "primary_contrast": list(BENCHMARK_STUDY_V2_PRIMARY_CONTRAST),
+        "diagnostic_contrast": list(BENCHMARK_STUDY_V2_DIAGNOSTIC_CONTRAST),
+        "derived_gates": derived_gates,
+        "backend_revision": provenance.get("backend_revision") if provider_ready else "unavailable",
+        "model_revision": provenance.get("model_revision") if provider_ready else "unavailable",
+    }
+
+
+BENCHMARK_STUDY_V2_EXEC_MANIFEST_SCHEMA_VERSION = "contextguard.bench.study-manifest.v6"
+BENCHMARK_STUDY_V2_ATTEMPT_SCHEMA_VERSION = "contextguard.bench.study-attempt.v4"
+BENCHMARK_STUDY_V2_BOUNDED_FAILURE_RESULT_CODES = frozenset({
+    "error_max_turns",
+})
+BENCHMARK_STUDY_V2_BOUNDED_FAILURE_CHECKER_STATUS = (
+    "not_run_provider_bounded_failure_v1"
+)
+BENCHMARK_STUDY_V2_REPORT_SCHEMA_VERSION = "contextguard.bench.study-report.v4"
+BENCHMARK_STUDY_V2_INVALID_DECISION_SCHEMA_VERSION = (
+    "contextguard.bench.study-invalid-decision.v1"
+)
+BENCHMARK_STUDY_V2_CANDIDATE_SCHEMA_VERSION = "contextguard-npm-candidate-set/v1"
+BENCHMARK_STUDY_V2_CANDIDATE_NAMES = (
+    "@ictechgy/context-guard-receipt", "@ictechgy/context-guard",
+)
+BENCHMARK_STUDY_V2_OVERLAY_NAME = "node_modules"
+BENCHMARK_STUDY_V2_REWRITE_COMMAND = (
+    "./node_modules/.bin/context-guard-rewrite-bash"
+)
+BENCHMARK_STUDY_V2_CLI_BINDING_SCHEMA_VERSION = (
+    "contextguard.bench.cli-binding.v2"
+)
+BENCHMARK_STUDY_V2_AUTH_CONTEXT_SCHEMA_VERSION = (
+    "contextguard.bench.auth-context.v1"
+)
+BENCHMARK_STUDY_V2_CLI_CAPABILITIES = (
+    "--settings", "--setting-sources", "--include-hook-events",
+    "--no-session-persistence", "stream-json",
+)
+BENCHMARK_STUDY_V2_CLI_MAX_BYTES = 1_073_741_824
+BENCHMARK_STUDY_V2_CANARY_EVENT_SCHEMA_VERSION = (
+    "contextguard.bench.canary-event.v2"
+)
+BENCHMARK_STUDY_V2_CANARY_EVIDENCE_SCHEMA_VERSION = (
+    "contextguard.bench.canary-evidence.v3"
+)
+BENCHMARK_STUDY_V2_CANARY_ARMS = ("legacy_trim", "bash_reference_v1")
+BENCHMARK_STUDY_V2_CANARY_TASK_ID = "contextguard-v2-bash-canary"
+BENCHMARK_STUDY_V2_CANARY_MAX_BUDGET_USD = 0.75
+BENCHMARK_STUDY_V2_CANARY_MARKER = b"contextguard-v2-host-pretooluse-canary\n"
+BENCHMARK_STUDY_V2_CANARY_COMMAND = (
+    "python3 -c 'from pathlib import Path;"
+    "Path(\"contextguard-v2-canary.txt\").write_bytes("
+    "b\"contextguard-v2-host-pretooluse-canary\\n\")'"
+)
+BENCHMARK_STUDY_V2_CANARY_PROMPT = (
+    "Use the Bash tool exactly once to run this command, then reply done: "
+    + BENCHMARK_STUDY_V2_CANARY_COMMAND
+)
+BENCHMARK_STUDY_V2_CANARY_CHECKER = (
+    b"from pathlib import Path\n"
+    b"try:\n"
+    b"    value = Path('contextguard-v2-canary.txt').read_bytes()\n"
+    b"except OSError:\n"
+    b"    raise SystemExit(1)\n"
+    b"raise SystemExit(0 if value == b'contextguard-v2-host-pretooluse-canary\\n' else 1)\n"
+)
+
+
+def _benchmark_study_v2_canary_contract() -> dict[str, Any]:
+    fixture = b"This workspace is used only for the discarded v2 Bash-hook canary.\n"
+    return {
+        "schema_version": "contextguard.bench.canary-contract.v2",
+        "task_id": BENCHMARK_STUDY_V2_CANARY_TASK_ID,
+        "prompt_sha256": _study_sha256_bytes(
+            BENCHMARK_STUDY_V2_CANARY_PROMPT.encode("utf-8")
+        ),
+        "fixture_sha256": _study_sha256_bytes(fixture),
+        "checker_sha256": _study_sha256_bytes(BENCHMARK_STUDY_V2_CANARY_CHECKER),
+        "marker_sha256": _study_sha256_bytes(BENCHMARK_STUDY_V2_CANARY_MARKER),
+        "arms": list(BENCHMARK_STUDY_V2_CANARY_ARMS),
+        "required_event_classes": ["PreToolUse"],
+        "max_budget_usd": BENCHMARK_STUDY_V2_CANARY_MAX_BUDGET_USD,
+        "provider_calls": 2,
+        "discarded": True,
+        "excluded_from_analysis": True,
+    }
+
+
+def _benchmark_study_v2_canary_task() -> TaskFixture:
+    fixture = b"This workspace is used only for the discarded v2 Bash-hook canary.\n"
+    return TaskFixture(
+        id=BENCHMARK_STUDY_V2_CANARY_TASK_ID,
+        prompt=BENCHMARK_STUDY_V2_CANARY_PROMPT,
+        model="sonnet", max_turns=2,
+        max_budget_usd=BENCHMARK_STUDY_V2_CANARY_MAX_BUDGET_USD,
+        allowed_tools=["Bash"],
+        fixture_tree="inline-canary-fixture",
+        success_checker="inline-canary-checker.py",
+        fixture_tree_entries=(
+            FixtureTreeEntry(path="CANARY.md", data=fixture, executable=False),
+        ),
+        success_checker_bytes=BENCHMARK_STUDY_V2_CANARY_CHECKER,
+    )
+
+
+def _benchmark_study_v2_output_root(path: Path) -> Path:
+    if path.is_symlink():
+        raise ValueError("v2 output root must not be a symlink")
+    try:
+        return path.resolve(strict=False)
+    except OSError as exc:
+        raise ValueError("v2 output root is unavailable") from exc
+
+
+@contextmanager
+def _benchmark_study_v2_action_lock(output_root: Path) -> Iterable[None]:
+    """Serialize every canary/run/resume/analyze mutation for one study root."""
+    root = _benchmark_study_v2_output_root(output_root)
+    try:
+        root_fd = _ensure_directory_no_symlink(root, create=False)
+    except (OSError, SystemExit, ValueError) as exc:
+        raise ValueError(
+            "v2 executable study requires a prepared output root"
+        ) from exc
+    lock_fd = -1
+    locked = False
+    try:
+        if fcntl is None:
+            raise ValueError("v2 lifecycle locking is unavailable")
+        flags = os.O_RDWR | os.O_CREAT
+        if hasattr(os, "O_CLOEXEC"):
+            flags |= os.O_CLOEXEC
+        lock_fd = _open_regular_no_symlink(
+            root / ".study-v2-action.lock", flags, 0o600,
+        )
+        os.fchmod(lock_fd, 0o600)
+        os.fsync(root_fd)
+        try:
+            fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except (BlockingIOError, OSError) as exc:
+            raise ValueError("another v2 lifecycle action is already active") from exc
+        locked = True
+        yield
+    finally:
+        if locked:
+            fcntl.flock(lock_fd, fcntl.LOCK_UN)
+        if lock_fd >= 0:
+            os.close(lock_fd)
+        os.close(root_fd)
+
+
+def _benchmark_study_v2_validate_cli_binding(binding: Mapping[str, Any]) -> None:
+    required = {
+        "schema_version", "executable", "executable_bytes",
+        "executable_sha256", "bundle", "probe",
+    }
+    probe = binding.get("probe")
+    bundle = binding.get("bundle")
+    if (
+        set(binding) != required
+        or binding.get("schema_version")
+        != BENCHMARK_STUDY_V2_CLI_BINDING_SCHEMA_VERSION
+        or not isinstance(binding.get("executable"), str)
+        or not Path(str(binding.get("executable"))).is_absolute()
+        or isinstance(binding.get("executable_bytes"), bool)
+        or not isinstance(binding.get("executable_bytes"), int)
+        or not 0 < int(binding["executable_bytes"]) <= BENCHMARK_STUDY_V2_CLI_MAX_BYTES
+        or not isinstance(binding.get("executable_sha256"), str)
+        or SHA256_HEX_PATTERN.fullmatch(str(binding["executable_sha256"])) is None
+        or not isinstance(probe, Mapping)
+        or probe.get("schema_version") != MEASUREMENT_CLI_PROBE_SCHEMA_VERSION
+        or probe.get("executable") != binding.get("executable")
+        or probe.get("capabilities") != sorted(BENCHMARK_STUDY_V2_CLI_CAPABILITIES)
+        or "version" in probe
+        or not isinstance(bundle, Mapping)
+        or set(bundle) != {
+            "scope", "root", "file_count", "total_bytes", "sha256",
+        }
+        or bundle.get("scope") != "single-native-executable-v1"
+        or not isinstance(bundle.get("root"), str)
+        or not Path(str(bundle["root"])).is_absolute()
+        or isinstance(bundle.get("file_count"), bool)
+        or not isinstance(bundle.get("file_count"), int)
+        or not 0 < bundle["file_count"] <= 100_000
+        or isinstance(bundle.get("total_bytes"), bool)
+        or not isinstance(bundle.get("total_bytes"), int)
+        or not 0 < bundle["total_bytes"] <= 2_147_483_648
+        or not isinstance(bundle.get("sha256"), str)
+        or SHA256_HEX_PATTERN.fullmatch(bundle["sha256"]) is None
+        or bundle.get("root") != binding.get("executable")
+        or bundle.get("file_count") != 1
+        or bundle.get("total_bytes") != binding.get("executable_bytes")
+        or bundle.get("sha256") != binding.get("executable_sha256")
+    ):
+        raise ValueError("v2 CLI binding schema mismatch")
+
+
+def _benchmark_study_v2_cli_stat_guard(path: Path) -> dict[str, int | str]:
+    fd = _open_regular_no_symlink(path)
+    try:
+        item = os.fstat(fd)
+        if item.st_size <= 0 or item.st_size > BENCHMARK_STUDY_V2_CLI_MAX_BYTES:
+            raise ValueError("v2 CLI executable size is unsupported")
+        return {
+            "executable": str(path.resolve(strict=True)),
+            "device": int(item.st_dev), "inode": int(item.st_ino),
+            "bytes": int(item.st_size),
+            "mtime_ns": int(item.st_mtime_ns), "ctime_ns": int(item.st_ctime_ns),
+        }
+    finally:
+        os.close(fd)
+
+
+def _benchmark_study_v2_cli_file_binding(
+    path: Path,
+) -> tuple[dict[str, Any], dict[str, int | str]]:
+    """Hash a large native CLI through a bounded no-follow fd without buffering it."""
+    fd = _open_regular_no_symlink(path)
+    try:
+        before = os.fstat(fd)
+        if before.st_size <= 0 or before.st_size > BENCHMARK_STUDY_V2_CLI_MAX_BYTES:
+            raise ValueError("v2 CLI executable size is unsupported")
+        digest = hashlib.sha256()
+        total = 0
+        while True:
+            chunk = os.read(fd, 1024 * 1024)
+            if not chunk:
+                break
+            total += len(chunk)
+            if total > BENCHMARK_STUDY_V2_CLI_MAX_BYTES:
+                raise ValueError("v2 CLI executable size is unsupported")
+            digest.update(chunk)
+        after = os.fstat(fd)
+        stat_fields = ("st_dev", "st_ino", "st_size", "st_mtime_ns", "st_ctime_ns")
+        if total != before.st_size or any(
+            getattr(before, field) != getattr(after, field) for field in stat_fields
+        ):
+            raise ValueError("v2 CLI executable changed while hashing")
+        executable = str(path.resolve(strict=True))
+        return (
+            {
+                "executable": executable,
+                "executable_bytes": total,
+                "executable_sha256": digest.hexdigest(),
+            },
+            {
+                "executable": executable,
+                "device": int(after.st_dev), "inode": int(after.st_ino),
+                "bytes": int(after.st_size),
+                "mtime_ns": int(after.st_mtime_ns),
+                "ctime_ns": int(after.st_ctime_ns),
+            },
+        )
+    finally:
+        os.close(fd)
+
+
+def _benchmark_study_v2_read_executable_shebang(path: Path) -> str | None:
+    fd = _open_regular_no_symlink(path)
+    try:
+        raw = os.read(fd, 4096)
+    finally:
+        os.close(fd)
+    first = raw.splitlines()[0] if raw else b""
+    if not first.startswith(b"#!"):
+        return None
+    try:
+        value = first[2:].decode("utf-8", "strict").strip()
+    except UnicodeDecodeError:
+        raise ValueError("v2 CLI shebang is not UTF-8") from None
+    if not value or len(value) > 512:
+        raise ValueError("v2 CLI shebang is invalid")
+    return value
+
+
+def _benchmark_study_v2_cli_bundle_binding(
+    executable: Path, shebang: str | None,
+) -> dict[str, Any]:
+    if shebang is not None:
+        raise ValueError("v2 executable study requires a native executable")
+    file_binding, _guard = _benchmark_study_v2_cli_file_binding(executable)
+    return {
+        "scope": "single-native-executable-v1",
+        "root": str(executable), "file_count": 1,
+        "total_bytes": file_binding["executable_bytes"],
+        "sha256": file_binding["executable_sha256"],
+    }
+
+
+def _benchmark_study_v2_cli_bundle_stat_guard(
+    bundle: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Detect a native executable replacement between action hash and launch."""
+    if bundle.get("scope") != "single-native-executable-v1":
+        raise ValueError("v2 CLI bundle scope is invalid")
+    item = _benchmark_study_v2_cli_stat_guard(Path(str(bundle["root"])))
+    return {
+        "entry_count": 1,
+        "sha256": _study_domain_hash(
+            "contextguard.bench.v2.cli-bundle-stat.v1", item,
+        ),
+    }
+
+
+def _benchmark_study_v2_execution_environment(
+    cli_binding: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Freeze the PATH and interpreters used by the CLI and Python hook."""
+    _benchmark_study_v2_validate_cli_binding(cli_binding)
+    names = ["python3"]
+    bindings: list[dict[str, Any]] = []
+    lookup_directories: list[str] = []
+    for name in dict.fromkeys(names):
+        lookup = shutil.which(name)
+        if lookup is None:
+            raise ValueError(f"v2 required runtime unavailable: {name}")
+        lookup_path = Path(lookup).absolute()
+        resolved = lookup_path.resolve(strict=True)
+        file_binding, _guard = _benchmark_study_v2_cli_file_binding(resolved)
+        lookup_directories.append(str(lookup_path.parent))
+        bindings.append({
+            "name": name, "lookup_path": str(lookup_path),
+            **file_binding,
+        })
+    path_value = os.pathsep.join(dict.fromkeys(
+        lookup_directories + ["/usr/bin", "/bin", "/usr/sbin", "/sbin"]
+    ))
+    return {
+        "schema_version": "contextguard.bench.execution-environment.v3",
+        "values": {
+            "PATH": path_value,
+            "LANG": "C",
+            "LC_ALL": "C",
+            "PYTHONDONTWRITEBYTECODE": "1",
+        },
+        "runtime_bindings": bindings,
+    }
+
+
+def _benchmark_study_v2_validate_execution_environment(
+    binding: Mapping[str, Any],
+) -> None:
+    values = binding.get("values")
+    runtimes = binding.get("runtime_bindings")
+    if (
+        set(binding) != {"schema_version", "values", "runtime_bindings"}
+        or binding.get("schema_version")
+        != "contextguard.bench.execution-environment.v3"
+        or not isinstance(values, Mapping)
+        or set(values) != {"PATH", "LANG", "LC_ALL", "PYTHONDONTWRITEBYTECODE"}
+        or values.get("LANG") != "C" or values.get("LC_ALL") != "C"
+        or values.get("PYTHONDONTWRITEBYTECODE") != "1"
+        or not isinstance(values.get("PATH"), str) or not values["PATH"]
+        or any(
+            not part or not Path(part).is_absolute()
+            for part in str(values["PATH"]).split(os.pathsep)
+        )
+        or not isinstance(runtimes, list) or not runtimes
+    ):
+        raise ValueError("v2 execution environment binding schema mismatch")
+    seen: set[str] = set()
+    for runtime in runtimes:
+        if (
+            not isinstance(runtime, Mapping)
+            or set(runtime) != {
+                "name", "lookup_path", "executable", "executable_bytes",
+                "executable_sha256",
+            }
+            or not isinstance(runtime.get("name"), str)
+            or not re.fullmatch(r"[A-Za-z0-9_.+-]+", str(runtime["name"]))
+            or runtime["name"] in seen
+            or not isinstance(runtime.get("lookup_path"), str)
+            or not Path(str(runtime["lookup_path"])).is_absolute()
+            or not isinstance(runtime.get("executable"), str)
+            or not Path(str(runtime["executable"])).is_absolute()
+            or isinstance(runtime.get("executable_bytes"), bool)
+            or not isinstance(runtime.get("executable_bytes"), int)
+            or not 0 < runtime["executable_bytes"] <= BENCHMARK_STUDY_V2_CLI_MAX_BYTES
+            or not isinstance(runtime.get("executable_sha256"), str)
+            or SHA256_HEX_PATTERN.fullmatch(runtime["executable_sha256"]) is None
+        ):
+            raise ValueError("v2 runtime interpreter binding schema mismatch")
+        seen.add(str(runtime["name"]))
+
+
+def _benchmark_study_v2_assert_execution_environment(
+    binding: Mapping[str, Any],
+) -> dict[str, dict[str, int | str]]:
+    _benchmark_study_v2_validate_execution_environment(binding)
+    path_value = str(binding["values"]["PATH"])
+    guards: dict[str, dict[str, int | str]] = {}
+    for runtime in binding["runtime_bindings"]:
+        found = shutil.which(str(runtime["name"]), path=path_value)
+        if found is None or str(Path(found).absolute()) != runtime["lookup_path"]:
+            raise ValueError("v2 runtime interpreter lookup drift")
+        current, _guard = _benchmark_study_v2_cli_file_binding(
+            Path(str(runtime["executable"]))
+        )
+        expected = {
+            key: runtime[key]
+            for key in ("executable", "executable_bytes", "executable_sha256")
+        }
+        if current != expected or Path(found).resolve(strict=True) != Path(
+            str(runtime["executable"])
+        ):
+            raise ValueError("v2 runtime interpreter binding drift")
+        guards[str(runtime["name"])] = _benchmark_study_v2_cli_stat_guard(
+            Path(str(runtime["executable"]))
+        )
+    return guards
+
+
+def _benchmark_study_v2_assert_runtime_stat_guards(
+    binding: Mapping[str, Any],
+    guards: Mapping[str, Mapping[str, int | str]],
+) -> None:
+    _benchmark_study_v2_validate_execution_environment(binding)
+    runtimes = binding["runtime_bindings"]
+    if set(guards) != {str(runtime["name"]) for runtime in runtimes}:
+        raise ValueError("v2 runtime interpreter guard mismatch")
+    for runtime in runtimes:
+        name = str(runtime["name"])
+        guard = guards[name]
+        found = shutil.which(
+            name, path=str(binding["values"]["PATH"]),
+        )
+        if (
+            found is None
+            or str(Path(found).absolute()) != runtime["lookup_path"]
+            or Path(found).resolve(strict=True) != Path(str(runtime["executable"]))
+            or guard.get("executable") != runtime["executable"]
+            or guard.get("bytes") != runtime["executable_bytes"]
+            or _benchmark_study_v2_cli_stat_guard(
+                Path(str(runtime["executable"]))
+            ) != dict(guard)
+        ):
+            raise ValueError("v2 runtime interpreter changed before launch")
+
+
+def _benchmark_study_v2_auth_home_binding(home: Path) -> tuple[Path, dict[str, Any]]:
+    if "CLAUDE_CONFIG_DIR" in os.environ:
+        raise ValueError("v2 existing-login mode requires CLAUDE_CONFIG_DIR to be unset")
+    if not home.is_absolute() or "\0" in str(home):
+        raise ValueError("v2 existing-login HOME must be an absolute path")
+    resolved = home.resolve(strict=True)
+    directory_fd = _ensure_directory_no_symlink(resolved, create=False)
+    try:
+        item = os.fstat(directory_fd)
+    finally:
+        os.close(directory_fd)
+    mode = stat.S_IMODE(item.st_mode)
+    if (
+        not stat.S_ISDIR(item.st_mode)
+        or item.st_uid != os.geteuid()
+        or mode & 0o022
+    ):
+        raise ValueError("v2 existing-login HOME is not a private owned directory")
+    return resolved, {
+        "device": item.st_dev,
+        "inode": item.st_ino,
+        "uid": item.st_uid,
+        "mode": mode,
+    }
+
+
+def _benchmark_study_v2_validate_auth_context(binding: Mapping[str, Any]) -> None:
+    if (
+        set(binding) != {
+            "schema_version", "mode", "home_path_sha256", "home_stat",
+            "identity_sha256", "auth_method", "api_provider",
+            "credential_environment",
+        }
+        or binding.get("schema_version")
+        != BENCHMARK_STUDY_V2_AUTH_CONTEXT_SCHEMA_VERSION
+        or binding.get("mode") != "existing_cli_login_v1"
+        or not isinstance(binding.get("home_path_sha256"), str)
+        or SHA256_HEX_PATTERN.fullmatch(str(binding["home_path_sha256"])) is None
+        or not isinstance(binding.get("identity_sha256"), str)
+        or SHA256_HEX_PATTERN.fullmatch(str(binding["identity_sha256"])) is None
+        or binding.get("auth_method") != "claude.ai"
+        or binding.get("api_provider") != "firstParty"
+        or binding.get("credential_environment") != "forbidden"
+    ):
+        raise ValueError("v2 auth context binding schema mismatch")
+    home_stat = binding.get("home_stat")
+    if (
+        not isinstance(home_stat, Mapping)
+        or set(home_stat) != {"device", "inode", "uid", "mode"}
+        or any(isinstance(value, bool) or not isinstance(value, int) or value < 0
+               for value in home_stat.values())
+        or int(home_stat["uid"]) != os.geteuid()
+        or int(home_stat["mode"]) & 0o022
+    ):
+        raise ValueError("v2 auth HOME binding schema mismatch")
+
+
+def _benchmark_study_v2_auth_context(
+    claude_bin: str,
+    execution_environment: Mapping[str, Any],
+    auth_home: Path,
+) -> tuple[Path, dict[str, Any]]:
+    _benchmark_study_v2_validate_execution_environment(execution_environment)
+    resolved_home, home_stat = _benchmark_study_v2_auth_home_binding(auth_home)
+    with tempfile.TemporaryDirectory(prefix="contextguard-v2-auth-probe-") as temporary:
+        root = Path(temporary)
+        os.chmod(root, 0o700)
+        paths = {
+            name: root / name
+            for name in (
+                "cwd", "xdg-config", "xdg-cache", "xdg-data", "xdg-state", "tmp",
+            )
+        }
+        for path in paths.values():
+            path.mkdir(mode=0o700)
+        env = dict(execution_environment["values"])
+        env.update({
+            "HOME": str(resolved_home),
+            "XDG_CONFIG_HOME": str(paths["xdg-config"]),
+            "XDG_CACHE_HOME": str(paths["xdg-cache"]),
+            "XDG_DATA_HOME": str(paths["xdg-data"]),
+            "XDG_STATE_HOME": str(paths["xdg-state"]),
+            "TMPDIR": str(paths["tmp"]),
+            "NO_COLOR": "1",
+        })
+        result = run_bounded_command(
+            [executable_argv0(claude_bin), "auth", "status", "--json"],
+            cwd=paths["cwd"], timeout_seconds=10,
+            max_output_bytes=MEASUREMENT_CLI_PROBE_OUTPUT_MAX_BYTES, env=env,
+        )
+    if (
+        result.returncode != 0 or result.timed_out or result.output_truncated
+        or result.launch_error or result.stderr_bytes
+        or not 0 < len(result.stdout_bytes) <= 4096
+    ):
+        raise ValueError("v2 existing Claude login is unavailable")
+    try:
+        status_payload = json.loads(result.stdout_bytes.decode("utf-8", "strict"))
+    except (UnicodeDecodeError, json.JSONDecodeError):
+        raise ValueError("v2 existing Claude login status is invalid") from None
+    identity_keys = {
+        "loggedIn", "authMethod", "apiProvider", "email", "orgId",
+        "orgName", "subscriptionType",
+    }
+    if (
+        not isinstance(status_payload, Mapping)
+        or set(status_payload) != identity_keys
+        or status_payload.get("loggedIn") is not True
+        or status_payload.get("authMethod") != "claude.ai"
+        or status_payload.get("apiProvider") != "firstParty"
+        or any(
+            not isinstance(status_payload.get(key), str)
+            or len(str(status_payload[key]).encode("utf-8")) > 1024
+            or "\0" in str(status_payload[key])
+            for key in ("email", "orgId", "orgName", "subscriptionType")
+        )
+    ):
+        raise ValueError("v2 existing Claude login status is unsupported")
+    private_identity = {
+        key: status_payload[key]
+        for key in (
+            "authMethod", "apiProvider", "email", "orgId", "orgName",
+            "subscriptionType",
+        )
+    }
+    binding = {
+        "schema_version": BENCHMARK_STUDY_V2_AUTH_CONTEXT_SCHEMA_VERSION,
+        "mode": "existing_cli_login_v1",
+        "home_path_sha256": _study_domain_hash(
+            "contextguard.bench.v2.auth-home-path.v1", str(resolved_home),
+        ),
+        "home_stat": home_stat,
+        "identity_sha256": _study_domain_hash(
+            "contextguard.bench.v2.auth-identity.v1", private_identity,
+        ),
+        "auth_method": "claude.ai",
+        "api_provider": "firstParty",
+        "credential_environment": "forbidden",
+    }
+    _benchmark_study_v2_validate_auth_context(binding)
+    return resolved_home, binding
+
+
+def _benchmark_study_v2_assert_auth_context(
+    claude_bin: str,
+    execution_environment: Mapping[str, Any],
+    expected: Mapping[str, Any],
+    auth_home: Path,
+) -> Path:
+    _benchmark_study_v2_validate_auth_context(expected)
+    try:
+        resolved_home, actual = _benchmark_study_v2_auth_context(
+            claude_bin, execution_environment, auth_home,
+        )
+    except (OSError, SystemExit, TypeError, ValueError) as exc:
+        raise ValueError("v2 existing Claude login binding drift") from exc
+    if actual != dict(expected):
+        raise ValueError("v2 existing Claude login binding drift")
+    return resolved_home
+
+
+def _benchmark_study_v2_cli_binding(claude_bin: str) -> dict[str, Any]:
+    """Bind the exact executable bytes and isolated version/help capability probes."""
+    executable = Path(executable_argv0(claude_bin))
+    file_binding, stat_guard = _benchmark_study_v2_cli_file_binding(executable)
+    shebang = _benchmark_study_v2_read_executable_shebang(executable)
+    if shebang is not None:
+        raise ValueError(
+            "v2 executable study requires a native executable; script launcher "
+            "dependency closure cannot be proven"
+        )
+    bundle = _benchmark_study_v2_cli_bundle_binding(executable, shebang)
+    probe = run_measurement_cli_probes(
+        str(executable), BENCHMARK_STUDY_V2_CLI_CAPABILITIES,
+    )
+    # Bind exact version bytes by hash/length without persisting arbitrary CLI
+    # display text that could contain a secret-shaped value.
+    probe.pop("version", None)
+    if _benchmark_study_v2_cli_stat_guard(executable) != stat_guard:
+        raise ValueError("v2 CLI executable changed during capability probes")
+    binding = {
+        "schema_version": BENCHMARK_STUDY_V2_CLI_BINDING_SCHEMA_VERSION,
+        **file_binding,
+        "bundle": bundle,
+        "probe": probe,
+    }
+    _benchmark_study_v2_validate_cli_binding(binding)
+    return binding
+
+
+def _benchmark_study_v2_assert_cli_binding(
+    claude_bin: str, expected: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Refuse a changed or incompatible CLI before reserving any identity."""
+    _benchmark_study_v2_validate_cli_binding(expected)
+    try:
+        actual = _benchmark_study_v2_cli_binding(claude_bin)
+    except (OSError, SystemExit, TypeError, ValueError) as exc:
+        raise ValueError("v2 CLI binding drift") from exc
+    if actual != dict(expected):
+        raise ValueError("v2 CLI binding drift")
+    guard: dict[str, Any] = _benchmark_study_v2_cli_stat_guard(
+        Path(str(actual["executable"]))
+    )
+    guard["bundle_stat_guard"] = _benchmark_study_v2_cli_bundle_stat_guard(
+        actual["bundle"]
+    )
+    return guard
+
+
+def _benchmark_study_v2_assert_cli_executable_bytes(
+    expected: Mapping[str, Any], stat_guard: Mapping[str, Any],
+) -> None:
+    """Repeat a cheap post-hash file-identity check before provider reservation."""
+    _benchmark_study_v2_validate_cli_binding(expected)
+    if (
+        stat_guard.get("executable") != expected["executable"]
+        or stat_guard.get("bytes") != expected["executable_bytes"]
+        or _benchmark_study_v2_cli_stat_guard(
+            Path(str(expected["executable"]))
+        ) != {
+            key: stat_guard[key]
+            for key in ("executable", "device", "inode", "bytes", "mtime_ns", "ctime_ns")
+        }
+        or stat_guard.get("bundle_stat_guard")
+        != _benchmark_study_v2_cli_bundle_stat_guard(expected["bundle"])
+    ):
+        raise ValueError("v2 CLI executable bytes drift")
+
+
+def _benchmark_study_v2_python_binding() -> dict[str, Any]:
+    invoked_python = Path(sys.executable).absolute()
+    resolved_python = invoked_python.resolve(strict=True)
+    python_file, _guard = _benchmark_study_v2_cli_file_binding(resolved_python)
+    return {
+        "invoked_path": str(invoked_python),
+        **python_file,
+        "implementation": sys.implementation.name,
+        "cache_tag": sys.implementation.cache_tag,
+        "version_info": [
+            sys.version_info.major, sys.version_info.minor,
+            sys.version_info.micro, sys.version_info.releaselevel,
+            sys.version_info.serial,
+        ],
+        "version_sha256": _study_sha256_bytes(sys.version.encode("utf-8")),
+        "flags_sha256": _study_domain_hash(
+            "contextguard.bench.v2.python-flags.v1", list(sys.flags),
+        ),
+        "prefix": sys.prefix,
+        "base_prefix": sys.base_prefix,
+    }
+
+
+def _benchmark_study_v2_runner_binding() -> dict[str, Any]:
+    path = Path(__file__).resolve(strict=True)
+    raw = _read_bytes_no_follow(path, max_bytes=4_000_000)
+    return {
+        "path": str(path), "bytes": len(raw),
+        "sha256": _study_sha256_bytes(raw),
+        "python": _benchmark_study_v2_python_binding(),
+    }
+
+
+def _benchmark_study_v2_assert_python_binding(
+    binding: Mapping[str, Any], *, require_current: bool,
+) -> str:
+    required = {
+        "invoked_path", "executable", "executable_bytes", "executable_sha256",
+        "implementation", "cache_tag", "version_info", "version_sha256",
+        "flags_sha256", "prefix", "base_prefix",
+    }
+    if (
+        set(binding) != required
+        or not isinstance(binding.get("invoked_path"), str)
+        or not Path(str(binding["invoked_path"])).is_absolute()
+        or not isinstance(binding.get("executable"), str)
+        or not Path(str(binding["executable"])).is_absolute()
+        or isinstance(binding.get("executable_bytes"), bool)
+        or not isinstance(binding.get("executable_bytes"), int)
+        or not 0 < int(binding["executable_bytes"]) <= BENCHMARK_STUDY_V2_CLI_MAX_BYTES
+        or not isinstance(binding.get("executable_sha256"), str)
+        or SHA256_HEX_PATTERN.fullmatch(str(binding["executable_sha256"])) is None
+        or not isinstance(binding.get("implementation"), str)
+        or not binding["implementation"]
+        or not isinstance(binding.get("cache_tag"), (str, type(None)))
+        or not isinstance(binding.get("version_info"), list)
+        or len(binding["version_info"]) != 5
+        or any(
+            isinstance(value, bool) or not isinstance(value, (int, str))
+            for value in binding["version_info"]
+        )
+        or not isinstance(binding.get("version_sha256"), str)
+        or SHA256_HEX_PATTERN.fullmatch(str(binding["version_sha256"])) is None
+        or not isinstance(binding.get("flags_sha256"), str)
+        or SHA256_HEX_PATTERN.fullmatch(str(binding["flags_sha256"])) is None
+        or not isinstance(binding.get("prefix"), str)
+        or not isinstance(binding.get("base_prefix"), str)
+    ):
+        raise ValueError("v2 runner Python binding schema mismatch")
+    executable = Path(str(binding["executable"]))
+    current_file, _guard = _benchmark_study_v2_cli_file_binding(executable)
+    expected_file = {
+        key: binding[key]
+        for key in ("executable", "executable_bytes", "executable_sha256")
+    }
+    if current_file != expected_file:
+        raise ValueError("v2 runner Python binding drift")
+    if require_current:
+        invoked = Path(sys.executable).absolute()
+        try:
+            resolved = invoked.resolve(strict=True)
+        except OSError as exc:
+            raise ValueError("v2 runner Python binding drift") from exc
+        if (
+            str(invoked) != binding["invoked_path"]
+            or str(resolved) != binding["executable"]
+            or sys.implementation.name != binding["implementation"]
+            or sys.implementation.cache_tag != binding["cache_tag"]
+            or [
+                sys.version_info.major, sys.version_info.minor,
+                sys.version_info.micro, sys.version_info.releaselevel,
+                sys.version_info.serial,
+            ] != binding["version_info"]
+            or _study_sha256_bytes(sys.version.encode("utf-8"))
+            != binding["version_sha256"]
+            or _study_domain_hash(
+                "contextguard.bench.v2.python-flags.v1", list(sys.flags),
+            ) != binding["flags_sha256"]
+            or sys.prefix != binding["prefix"]
+            or sys.base_prefix != binding["base_prefix"]
+        ):
+            raise ValueError("v2 runner Python binding drift")
+    return str(executable)
+
+
+def _benchmark_study_v2_read_canonical(path: Path, *, owner: str, maximum: int) -> tuple[dict[str, Any], bytes]:
+    raw = _read_bytes_no_follow(path, max_bytes=maximum)
+    try:
+        value = json.loads(
+            raw.decode("utf-8"), object_pairs_hook=_measurement_object_no_duplicates,
+            parse_constant=_stream_reject_nonfinite,
+        )
+    except (UnicodeDecodeError, json.JSONDecodeError, ValueError) as exc:
+        raise ValueError(f"{owner} is invalid JSON") from exc
+    if not isinstance(value, dict) or raw != _study_canonical_json_bytes(value):
+        raise ValueError(f"{owner} must be exact canonical JSON bytes")
+    return value, raw
+
+
+def verify_benchmark_study_v2_candidate(
+    manifest_path: Path, *, checksum_path: Path | None = None,
+    expected_manifest_sha256: str | None = None,
+    expected_commit_sha: str | None = None,
+) -> dict[str, Any]:
+    """Verify the build-once candidate as inert bytes; never import its code."""
+    manifest, manifest_raw = _benchmark_study_v2_read_canonical(
+        manifest_path, owner="v2 candidate manifest", maximum=1_000_000,
+    )
+    required = {
+        "build_policy", "commit_sha", "exact_dependency", "packages",
+        "policy_sha256", "receipt_package_files_sha256", "protocol",
+        "repository", "schema_version", "tool_versions",
+    }
+    if set(manifest) != required or manifest.get("schema_version") != BENCHMARK_STUDY_V2_CANDIDATE_SCHEMA_VERSION:
+        raise ValueError("v2 candidate manifest schema mismatch")
+    if manifest.get("build_policy") != {
+        "ignore_scripts": True, "lockfiles": [], "network": "offline",
+        "package_build_count": 1,
+    }:
+        raise ValueError("v2 candidate build policy mismatch")
+    if manifest.get("protocol") != {
+        "maximum": 1, "minimum": 1, "name": "bash_reference_v1",
+    }:
+        raise ValueError("v2 candidate protocol mismatch")
+    if (
+        manifest.get("repository") != "ictechgy/context-guard"
+        or not isinstance(manifest.get("commit_sha"), str)
+        or re.fullmatch(r"[0-9a-f]{40}", manifest["commit_sha"]) is None
+        or not isinstance(manifest.get("tool_versions"), dict)
+        or not manifest["tool_versions"]
+        or any(
+            not isinstance(key, str) or not key or len(key) > 64
+            or not isinstance(value, str) or not value or len(value) > 128
+            for key, value in manifest["tool_versions"].items()
+        )
+        or any(
+            not isinstance(manifest.get(key), str)
+            or SHA256_HEX_PATTERN.fullmatch(manifest[key]) is None
+            for key in ("policy_sha256", "receipt_package_files_sha256")
+        )
+    ):
+        raise ValueError("v2 candidate build provenance is invalid")
+    manifest_sha256 = _study_sha256_bytes(manifest_raw)
+    if expected_manifest_sha256 is not None and manifest_sha256 != expected_manifest_sha256:
+        raise ValueError("v2 candidate canonical manifest hash drift")
+    if expected_commit_sha is not None and (
+        re.fullmatch(r"[0-9a-f]{40}", expected_commit_sha) is None
+        or manifest["commit_sha"] != expected_commit_sha
+    ):
+        raise ValueError(
+            "v2 candidate commit does not match approved source revision"
+        )
+    packages = manifest.get("packages")
+    if not isinstance(packages, list) or len(packages) != 2:
+        raise ValueError("v2 candidate must bind exactly two tarballs")
+    records: list[dict[str, Any]] = []
+    checksum_rows: list[str] = []
+    for index, package in enumerate(packages):
+        if not isinstance(package, dict) or set(package) != {
+            "filename", "integrity", "name", "sha256", "size_bytes", "version",
+        }:
+            raise ValueError("v2 candidate tarball record schema mismatch")
+        filename = package.get("filename")
+        digest = package.get("sha256")
+        size = package.get("size_bytes")
+        if (
+            package.get("name") != BENCHMARK_STUDY_V2_CANDIDATE_NAMES[index]
+            or not isinstance(filename, str) or Path(filename).name != filename
+            or not isinstance(digest, str) or SHA256_HEX_PATTERN.fullmatch(digest) is None
+            or isinstance(size, bool) or not isinstance(size, int) or size <= 0
+            or not isinstance(package.get("version"), str) or not package["version"]
+        ):
+            raise ValueError("v2 candidate tarball identity is invalid")
+        tarball_path = manifest_path.parent / filename
+        raw = _read_bytes_no_follow(tarball_path, max_bytes=100_000_000)
+        sri = "sha512-" + base64.b64encode(hashlib.sha512(raw).digest()).decode("ascii")
+        if len(raw) != size or _study_sha256_bytes(raw) != digest or package.get("integrity") != sri:
+            raise ValueError("v2 candidate tarball size, SHA-256, or SRI mismatch")
+        checksum_rows.append(f"{digest}  {filename}\n")
+        records.append({**package, "path": str(tarball_path.resolve())})
+    if len({record["filename"] for record in records}) != 2 or manifest.get("exact_dependency") != {
+        "name": BENCHMARK_STUDY_V2_CANDIDATE_NAMES[0],
+        "version": records[0]["version"],
+    }:
+        raise ValueError("v2 candidate exact dependency binding mismatch")
+    checksum = checksum_path or manifest_path.with_name("candidate-sha256sums.txt")
+    checksum_raw = _read_bytes_no_follow(checksum, max_bytes=10_000)
+    expected_checksum = "".join(checksum_rows).encode("ascii")
+    if checksum_raw != expected_checksum:
+        raise ValueError("v2 candidate checksum document mismatch")
+    return {
+        "manifest_path": str(manifest_path.resolve()),
+        "manifest_sha256": manifest_sha256,
+        "manifest_bytes": len(manifest_raw),
+        "checksum_path": str(checksum.resolve()),
+        "checksum_sha256": _study_sha256_bytes(checksum_raw),
+        "commit_sha": manifest["commit_sha"],
+        "packages": records,
+    }
+
+
+def _benchmark_study_v2_verify_retained_ref(
+    retained_ref: str, expected_commit_sha: str,
+) -> dict[str, str]:
+    if (
+        not isinstance(retained_ref, str)
+        or len(retained_ref) > 200
+        or re.fullmatch(
+            r"refs/heads/candidate/[A-Za-z0-9][A-Za-z0-9._/-]*",
+            retained_ref,
+        ) is None
+        or ".." in retained_ref
+        or "//" in retained_ref
+        or retained_ref.endswith(("/", ".lock"))
+        or re.fullmatch(r"[0-9a-f]{40}", expected_commit_sha) is None
+    ):
+        raise ValueError("v2 retained ref binding is invalid")
+    git = Path("/usr/bin/git")
+    if not git.is_file() or not os.access(git, os.X_OK):
+        raise ValueError("v2 retained ref verifier is unavailable")
+    with tempfile.TemporaryDirectory(prefix="contextguard-v2-git-home-") as temp:
+        os.chmod(temp, 0o700)
+        result = run_bounded_command(
+            [
+                str(git), "-c", "credential.helper=", "-c",
+                "core.askPass=", "ls-remote", "--exit-code", "--refs",
+                "https://github.com/ictechgy/context-guard.git", retained_ref,
+            ],
+            cwd=Path(temp), timeout_seconds=30, max_output_bytes=10_000,
+            env={
+                "GIT_ASKPASS": "/usr/bin/false",
+                "GIT_CONFIG_GLOBAL": "/dev/null",
+                "GIT_CONFIG_NOSYSTEM": "1",
+                "GIT_TERMINAL_PROMPT": "0",
+                "HOME": temp,
+                "LC_ALL": "C",
+                "PATH": "/usr/bin:/bin",
+                "SSH_ASKPASS": "/usr/bin/false",
+            },
+        )
+    expected_output = f"{expected_commit_sha}\t{retained_ref}\n"
+    if (
+        result.returncode != 0
+        or result.timed_out
+        or result.output_truncated
+        or result.stderr
+        or result.stdout != expected_output
+    ):
+        raise ValueError("v2 retained ref does not resolve to approved source")
+    return {
+        "commit_sha": expected_commit_sha,
+        "ref": retained_ref,
+        "repository": "ictechgy/context-guard",
+        "verification": "git-ls-remote-v1",
+    }
+
+
+def _benchmark_study_v2_tarball_inventory(path: Path) -> dict[str, Any]:
+    """Inventory regular npm package members without extracting candidate code."""
+    files: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    total_bytes = 0
+    try:
+        with tarfile.open(path, mode="r:gz") as archive:
+            for index, member in enumerate(archive):
+                if index >= 10_000:
+                    raise ValueError("v2 candidate tarball has too many members")
+                raw_parts = member.name.split("/")
+                if (
+                    not raw_parts
+                    or raw_parts[0] != "package"
+                    or any(part in {"", ".", ".."} for part in raw_parts)
+                    or any(
+                        ord(character) < 0x20 or ord(character) == 0x7F
+                        for character in member.name
+                    )
+                ):
+                    raise ValueError("v2 candidate tarball member path is invalid")
+                if len(raw_parts) == 1:
+                    if not member.isdir():
+                        raise ValueError("v2 candidate tarball package root is invalid")
+                    continue
+                relative = PurePosixPath(*raw_parts[1:]).as_posix()
+                if relative in seen:
+                    raise ValueError("v2 candidate tarball has duplicate members")
+                if member.isdir():
+                    continue
+                if not member.isreg() or member.size < 0 or member.size > 100_000_000:
+                    raise ValueError("v2 candidate tarball member type is unsupported")
+                stream = archive.extractfile(member)
+                if stream is None:
+                    raise ValueError("v2 candidate tarball member is unreadable")
+                raw = stream.read(member.size + 1)
+                if len(raw) != member.size:
+                    raise ValueError("v2 candidate tarball member size drift")
+                total_bytes += len(raw)
+                if total_bytes > 100_000_000:
+                    raise ValueError("v2 candidate tarball expanded size exceeds limit")
+                seen.add(relative)
+                files.append({
+                    "path": relative,
+                    "bytes": len(raw),
+                    "sha256": _study_sha256_bytes(raw),
+                    "executable": bool(member.mode & 0o111),
+                    "kind": "file",
+                    "target": None,
+                })
+    except (OSError, tarfile.TarError) as exc:
+        raise ValueError("v2 candidate tarball is not a readable npm archive") from exc
+    files.sort(key=lambda item: item["path"])
+    if not files:
+        raise ValueError("v2 candidate tarball package is empty")
+    return {
+        "files": files,
+        "file_count": len(files),
+        "sha256": _study_domain_hash("contextguard.bench.v2.inventory.v1", files),
+    }
+
+
+def _benchmark_study_v2_verify_installed_packages(
+    overlay_root: Path, candidate: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Bind the executed package bytes to the two already-verified tarballs."""
+    bindings: list[dict[str, Any]] = []
+    installed_documents: dict[str, dict[str, Any]] = {}
+    allowed_overlay_paths: set[str] = set()
+    for record in candidate["packages"]:
+        name = record["name"]
+        package_root = overlay_root.joinpath(*str(name).split("/"))
+        expected = _benchmark_study_v2_tarball_inventory(Path(record["path"]))
+        actual = _benchmark_study_v2_inventory(package_root)
+        if actual != expected:
+            raise ValueError("v2 installed package bytes differ from candidate tarball")
+        package_raw = _read_bytes_no_follow(
+            package_root / "package.json", max_bytes=128 * 1024,
+        )
+        try:
+            document = json.loads(
+                package_raw.decode("utf-8"),
+                object_pairs_hook=_measurement_object_no_duplicates,
+            )
+        except (UnicodeDecodeError, json.JSONDecodeError, ValueError) as exc:
+            raise ValueError("v2 installed package metadata is invalid") from exc
+        if (
+            not isinstance(document, dict)
+            or document.get("name") != name
+            or document.get("version") != record["version"]
+        ):
+            raise ValueError("v2 installed package identity differs from candidate")
+        installed_documents[str(name)] = document
+        allowed_overlay_paths.update(
+            f"{name}/{item['path']}" for item in expected["files"]
+        )
+        bindings.append({
+            "name": name,
+            "version": record["version"],
+            "inventory_sha256": actual["sha256"],
+        })
+    root_document = installed_documents[BENCHMARK_STUDY_V2_CANDIDATE_NAMES[1]]
+    receipt_record = candidate["packages"][0]
+    if root_document.get("dependencies") != {
+        BENCHMARK_STUDY_V2_CANDIDATE_NAMES[0]: receipt_record["version"],
+    }:
+        raise ValueError("v2 installed root exact dependency binding mismatch")
+    required_bins = ("context-guard", "context-guard-rewrite-bash")
+    root_bin_map = root_document.get("bin")
+    if not isinstance(root_bin_map, dict) or any(
+        not isinstance(root_bin_map.get(name), str) for name in required_bins
+    ):
+        raise ValueError("v2 installed root package lacks required public bins")
+    bin_bindings: list[dict[str, str]] = []
+    seen_bin_names: set[str] = set()
+    for package_name in sorted(installed_documents):
+        bin_map = installed_documents[package_name].get("bin", {})
+        if not isinstance(bin_map, dict):
+            raise ValueError("v2 installed package bin metadata is invalid")
+        package_root = overlay_root.joinpath(*package_name.split("/"))
+        for bin_name, relative_target in sorted(bin_map.items()):
+            if (
+                not isinstance(bin_name, str)
+                or not bin_name
+                or "/" in bin_name
+                or bin_name in {".", ".."}
+                or bin_name in seen_bin_names
+                or not isinstance(relative_target, str)
+            ):
+                raise ValueError("v2 installed package bin metadata is invalid")
+            target_parts = relative_target.split("/")
+            target_path = PurePosixPath(relative_target)
+            if (
+                target_path.is_absolute()
+                or not target_parts
+                or any(part in {"", ".", ".."} for part in target_parts)
+            ):
+                raise ValueError("v2 installed package bin target is unsafe")
+            package_relative_target = (
+                PurePosixPath(package_name) / target_path
+            ).as_posix()
+            if package_relative_target not in allowed_overlay_paths:
+                raise ValueError("v2 installed package bin target is not in its tarball")
+            link_relative = f".bin/{bin_name}"
+            link = overlay_root / ".bin" / bin_name
+            expected_raw_target = (
+                PurePosixPath("..") / package_name / target_path
+            ).as_posix()
+            try:
+                raw_target = os.readlink(link)
+                resolved = link.resolve(strict=True)
+                expected_target = (package_root / Path(*target_parts)).resolve(
+                    strict=True
+                )
+            except OSError as exc:
+                raise ValueError("v2 installed public bin link is unavailable") from exc
+            if raw_target != expected_raw_target or resolved != expected_target:
+                raise ValueError(
+                    "v2 installed public bin link differs from package metadata"
+                )
+            seen_bin_names.add(bin_name)
+            allowed_overlay_paths.add(link_relative)
+            bin_bindings.append({
+                "name": bin_name,
+                "package": package_name,
+                "target": expected_raw_target,
+            })
+    actual_overlay = _benchmark_study_v2_inventory(overlay_root)
+    actual_overlay_paths = {item["path"] for item in actual_overlay["files"]}
+    if actual_overlay_paths - allowed_overlay_paths:
+        raise ValueError("v2 candidate install contains an unverified overlay path")
+    if actual_overlay_paths != allowed_overlay_paths:
+        raise ValueError("v2 candidate install is missing a verified overlay path")
+    return {
+        "packages": bindings,
+        "bins": bin_bindings,
+        "sha256": _study_domain_hash(
+            "contextguard.bench.v2.installed-packages.v2",
+            {"packages": bindings, "bins": bin_bindings},
+        ),
+    }
+
+
+def _benchmark_study_v2_inventory(root: Path, *, reject_symlinks: bool = False) -> dict[str, Any]:
+    if root.is_symlink() or not root.is_dir():
+        raise ValueError("v2 inventory root must be a real directory")
+    files: list[dict[str, Any]] = []
+    for path in sorted(root.rglob("*"), key=lambda item: item.relative_to(root).as_posix()):
+        rel = path.relative_to(root).as_posix()
+        mode = os.lstat(path).st_mode
+        if stat.S_ISLNK(mode):
+            if reject_symlinks:
+                raise ValueError("v2 physical overlay must not contain symlinks")
+            raw_target = os.readlink(path)
+            if Path(raw_target).is_absolute():
+                raise ValueError("v2 candidate overlay symlink must be relative")
+            target = path.resolve(strict=True)
+            try:
+                target.relative_to(root.resolve(strict=True))
+            except ValueError:
+                raise ValueError("v2 candidate overlay symlink escapes the install root") from None
+            if not target.is_file():
+                raise ValueError("v2 candidate overlay symlink must resolve to an internal file")
+            raw = _read_bytes_no_follow(target, max_bytes=100_000_000)
+            executable = bool(target.stat().st_mode & 0o111)
+            kind = "symlink"
+        elif stat.S_ISREG(mode):
+            raw = _read_bytes_no_follow(path, max_bytes=100_000_000)
+            executable = bool(mode & 0o111)
+            raw_target = None
+            kind = "file"
+        elif stat.S_ISDIR(mode):
+            continue
+        else:
+            raise ValueError("v2 inventory contains an unsupported filesystem entry")
+        files.append({
+            "path": rel, "bytes": len(raw), "sha256": _study_sha256_bytes(raw),
+            "executable": executable, "kind": kind, "target": raw_target,
+        })
+    if not files:
+        raise ValueError("v2 candidate overlay is empty")
+    return {
+        "files": files,
+        "file_count": len(files),
+        "sha256": _study_domain_hash("contextguard.bench.v2.inventory.v1", files),
+    }
+
+
+def _benchmark_study_v2_verify_physical_copy(
+    source: Path, destination: Path, *, expected: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    source_inventory = _benchmark_study_v2_inventory(source)
+    if expected is not None and source_inventory != dict(expected):
+        raise ValueError("v2 staged candidate changed before the attempt copy")
+    destination_inventory = _benchmark_study_v2_inventory(destination)
+    if destination_inventory != source_inventory:
+        raise ValueError("v2 candidate overlay copy differs from installed candidate")
+    for item in source_inventory["files"]:
+        if item["kind"] != "file":
+            continue
+        source_path = source / item["path"]
+        destination_path = destination / item["path"]
+        if source_path.stat().st_dev == destination_path.stat().st_dev and source_path.stat().st_ino == destination_path.stat().st_ino:
+            raise ValueError("v2 candidate overlay contains a hardlink to the staged install")
+    return destination_inventory
+
+
+def _benchmark_study_v2_expected_pre_workspace(
+    task: TaskFixture, *, install_root: Path,
+    expected_overlay_inventory: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Re-materialize the bound cold workspace without invoking candidate code."""
+    with tempfile.TemporaryDirectory(prefix="contextguard-v2-pre-workspace-") as temp:
+        workspace = Path(temp).resolve()
+        os.chmod(workspace, 0o700)
+        reset_task_fixture_tree(task.fixture_tree_entries or (), workspace)
+        overlay = workspace / BENCHMARK_STUDY_V2_OVERLAY_NAME
+        shutil.copytree(
+            install_root, overlay, symlinks=True, copy_function=shutil.copy2,
+        )
+        _benchmark_study_v2_verify_physical_copy(
+            install_root, overlay, expected=expected_overlay_inventory,
+        )
+        return _benchmark_study_v2_inventory(workspace)
+
+
+def _benchmark_study_v2_settings() -> dict[str, dict[str, Any]]:
+    common: dict[str, Any] = {
+        "model": "sonnet",
+        "permissions": {"allow": ["Bash", "Edit", "Glob", "Grep", "Read", "Write"]},
+    }
+    result = {"host_unmodified": json.loads(json.dumps(common))}
+    for arm, suffix in (("legacy_trim", ""), ("bash_reference_v1", " --bash-reference-v1")):
+        settings = json.loads(json.dumps(common))
+        settings["hooks"] = {
+            "PreToolUse": [{
+                "matcher": "Bash",
+                "hooks": [{
+                    "type": "command",
+                    "command": BENCHMARK_STUDY_V2_REWRITE_COMMAND + suffix,
+                }],
+            }],
+        }
+        result[arm] = settings
+    return result
+
+
+def _benchmark_study_v2_write_settings(output_root: Path) -> dict[str, Any]:
+    settings_root = output_root / "inputs" / "settings-v2"
+    settings_root.mkdir(mode=0o700, parents=True)
+    bindings: dict[str, Any] = {}
+    for arm, value in _benchmark_study_v2_settings().items():
+        path = settings_root / f"{arm}.settings.json"
+        raw = _study_canonical_json_bytes(value)
+        _measurement_write_exclusive(path, raw)
+        bindings[arm] = {
+            "path": str(path.resolve()), "sha256": _study_sha256_bytes(raw),
+            "bytes": len(raw),
+            "bash_hook": arm != "host_unmodified",
+            "bash_reference_v1": arm == "bash_reference_v1",
+        }
+    return bindings
+
+
+def _benchmark_study_v2_install_candidate(
+    *, npm_bin: str, candidate: Mapping[str, Any], output_root: Path,
+) -> tuple[Path, dict[str, Any]]:
+    install_root = output_root / "candidate-install"
+    install_root.mkdir(mode=0o700)
+    isolated = output_root / "npm-isolation"
+    isolated.mkdir(mode=0o700)
+    for name in ("home", "cache", "tmp"):
+        (isolated / name).mkdir(mode=0o700)
+    root_package = next(
+        record for record in candidate["packages"]
+        if record["name"] == "@ictechgy/context-guard"
+    )
+    receipt_package = next(
+        record for record in candidate["packages"]
+        if record["name"] == "@ictechgy/context-guard-receipt"
+    )
+    npm_executable = executable_argv0(npm_bin)
+    runtime_directories = [str(Path(npm_executable).parent)]
+    node_executable = shutil.which("node")
+    if node_executable is not None:
+        runtime_directories.append(str(Path(node_executable).resolve().parent))
+    runtime_directories.extend(os.defpath.split(os.pathsep))
+    runtime_path = os.pathsep.join(dict.fromkeys(runtime_directories))
+    argv = [
+        npm_executable, "install", "--offline", "--ignore-scripts",
+        "--no-audit", "--fund=false", "--package-lock=false",
+        "--prefix", str(install_root.resolve()),
+        str(root_package["path"]), str(receipt_package["path"]),
+    ]
+    env = {
+        "PATH": runtime_path, "HOME": str((isolated / "home").resolve()),
+        "TMPDIR": str((isolated / "tmp").resolve()),
+        "NPM_CONFIG_CACHE": str((isolated / "cache").resolve()),
+        "NPM_CONFIG_OFFLINE": "true", "NPM_CONFIG_IGNORE_SCRIPTS": "true",
+        "NPM_CONFIG_AUDIT": "false", "NPM_CONFIG_FUND": "false",
+        "NPM_CONFIG_PACKAGE_LOCK": "false",
+        "NPM_CONFIG_UPDATE_NOTIFIER": "false",
+        "NPM_CONFIG_REGISTRY": "https://registry.invalid/",
+    }
+    result = run_bounded_command(
+        argv, cwd=output_root, timeout_seconds=180,
+        max_output_bytes=MEASUREMENT_CLI_PROBE_OUTPUT_MAX_BYTES, env=env,
+    )
+    if result.returncode != 0 or result.timed_out or result.output_truncated:
+        raise ValueError("v2 candidate offline npm install failed")
+    overlay_root = install_root / "node_modules"
+    hidden_lock = overlay_root / ".package-lock.json"
+    hidden_lock_removed = False
+    try:
+        hidden_lock_mode = os.lstat(hidden_lock).st_mode
+    except FileNotFoundError:
+        pass
+    else:
+        if not stat.S_ISREG(hidden_lock_mode):
+            raise ValueError("v2 npm hidden lockfile has an unsupported type")
+        hidden_lock.unlink()
+        hidden_lock_removed = True
+    inventory = _benchmark_study_v2_inventory(overlay_root)
+    installed_packages = _benchmark_study_v2_verify_installed_packages(
+        overlay_root, candidate,
+    )
+    receipt = {
+        "schema_version": "contextguard.bench.candidate-install.v2",
+        "install_count": 1,
+        "network": "offline",
+        "ignore_scripts": True,
+        "no_audit": True,
+        "fund": False,
+        "hidden_lockfile_removed": hidden_lock_removed,
+        "candidate_manifest_sha256": candidate["manifest_sha256"],
+        "argv_policy": [
+            "install", "--offline", "--ignore-scripts", "--no-audit",
+            "--fund=false", "--package-lock=false",
+        ],
+        "inventory": inventory,
+        "installed_packages": installed_packages,
+    }
+    _study_write_private(output_root / "candidate-install-receipt.json", receipt)
+    return overlay_root, receipt
+
+
+def prepare_benchmark_study_v2_executable(
+    *, output_root: Path, plan_path: Path, tasks_path: Path, checkers_dir: Path,
+    candidate_manifest_path: Path, candidate_checksum_path: Path | None,
+    expected_candidate_hash: str, npm_bin: str, claude_bin: str,
+    auth_home: Path, approved_source_commit: str,
+    retained_ref: str | None, offline_rehearsal: bool,
+) -> dict[str, Any]:
+    output_root = _benchmark_study_v2_output_root(output_root)
+    if output_root.exists() and (
+        output_root.is_symlink() or not output_root.is_dir() or any(output_root.iterdir())
+    ):
+        raise ValueError("v2 prepare output root must be new or empty")
+    # Candidate validation is deliberately first and performs no candidate import.
+    candidate = verify_benchmark_study_v2_candidate(
+        candidate_manifest_path, checksum_path=candidate_checksum_path,
+        expected_manifest_sha256=expected_candidate_hash,
+        expected_commit_sha=approved_source_commit,
+    )
+    if type(offline_rehearsal) is not bool:
+        raise TypeError("v2 offline rehearsal flag must be boolean")
+    if offline_rehearsal:
+        if retained_ref is not None:
+            raise ValueError("v2 offline rehearsal cannot bind a retained ref")
+        source_ref_binding: dict[str, Any] = {
+            "commit_sha": approved_source_commit,
+            "ref": None,
+            "repository": "ictechgy/context-guard",
+            "verification": "offline-rehearsal-unverified-v1",
+        }
+    else:
+        if retained_ref is None:
+            raise ValueError("v2 live prepare requires a retained ref")
+        source_ref_binding = _benchmark_study_v2_verify_retained_ref(
+            retained_ref, approved_source_commit,
+        )
+    plan = load_benchmark_study_v2_plan(plan_path)
+    corpus_bytes = _read_bytes_no_follow(tasks_path, max_bytes=MAX_FIXTURE_FILE_BYTES)
+    checker_binding = benchmark_study_v2_checker_binding(checkers_dir)
+    validate_benchmark_study_v2_bindings(
+        plan, corpus_bytes=corpus_bytes, checker_binding=checker_binding,
+    )
+    tasks = parse_tasks(tasks_path)
+    load_task_fixture_trees(tasks, task_file_dir=tasks_path.parent)
+    task_definitions = [
+        _study_task_manifest(task, tasks_path.parent) for task in tasks
+    ]
+    task_ids = _benchmark_study_v2_task_ids_from_corpus(corpus_bytes)
+    if [task.id for task in tasks] != task_ids:
+        raise ValueError("v2 parsed task order differs from the bound corpus")
+    cli_binding = _benchmark_study_v2_cli_binding(claude_bin)
+    execution_environment = _benchmark_study_v2_execution_environment(cli_binding)
+    _benchmark_study_v2_assert_execution_environment(execution_environment)
+    _resolved_auth_home, auth_context = _benchmark_study_v2_auth_context(
+        claude_bin, execution_environment, auth_home,
+    )
+    runner_binding = _benchmark_study_v2_runner_binding()
+    schedule = generate_benchmark_study_v2_schedule(
+        task_ids, repetitions=3, schedule_seed=plan["schedule_seed"],
+    )
+    slots = generate_benchmark_study_v2_slots(
+        task_ids, schedule, candidate_hash=candidate["manifest_sha256"],
+        namespace=BENCHMARK_STUDY_V2_NAMESPACE,
+    )
+    output_root.mkdir(mode=0o700, parents=True, exist_ok=True)
+    os.chmod(output_root, 0o700)
+    settings = _benchmark_study_v2_write_settings(output_root)
+    install_root, install_receipt = _benchmark_study_v2_install_candidate(
+        npm_bin=npm_bin, candidate=candidate, output_root=output_root,
+    )
+    manifest = {
+        "schema_version": BENCHMARK_STUDY_V2_EXEC_MANIFEST_SCHEMA_VERSION,
+        "plan": plan,
+        "plan_sha256": _study_sha256_bytes(_study_canonical_json_bytes(plan)),
+        "inputs": {
+            "plan_path": str(plan_path.resolve()),
+            "tasks_path": str(tasks_path.resolve()),
+            "tasks_sha256": _study_sha256_bytes(corpus_bytes),
+            "task_definitions": task_definitions,
+            "checkers_dir": str(checkers_dir.resolve()),
+            "checker_binding": checker_binding,
+            "cli_binding": cli_binding,
+            "execution_environment": execution_environment,
+            "auth_context": auth_context,
+            "runner_binding": runner_binding,
+            "canary_contract": _benchmark_study_v2_canary_contract(),
+            "approved_source_commit": approved_source_commit,
+            "source_ref_binding": source_ref_binding,
+            "candidate": candidate,
+            "candidate_install_root": str(install_root.resolve()),
+            "candidate_install_receipt_sha256": _study_sha256_bytes(
+                _study_canonical_json_bytes(install_receipt)
+            ),
+            "candidate_overlay_inventory": install_receipt["inventory"],
+            "settings": settings,
+            "namespace": BENCHMARK_STUDY_V2_NAMESPACE,
+            "task_ids": task_ids,
+            "task_ids_sha256": _benchmark_study_v2_task_ids_sha256(task_ids),
+        },
+        "schedule": schedule,
+        "slots": slots,
+        "execution": {
+            "identities": 216, "initial_calls": 108,
+            "retry": "exactly_after_valid_initial_failure_v1",
+            "resume": "never_replay_launched_identity_v1",
+            "attempt_schema_version": BENCHMARK_STUDY_V2_ATTEMPT_SCHEMA_VERSION,
+            "invalid_decision_schema_version": (
+                BENCHMARK_STUDY_V2_INVALID_DECISION_SCHEMA_VERSION
+            ),
+            "candidate_imported": False, "candidate_install_count": 1,
+            "overlay_copy": "physical_copy_no_hardlinks_v1",
+        },
+    }
+    _study_write_private(output_root / "study-manifest.json", manifest)
+    return manifest
+
+
+def load_benchmark_study_v2_executable_manifest(output_root: Path, *, revalidate_external: bool) -> tuple[dict[str, Any], str]:
+    output_root = _benchmark_study_v2_output_root(output_root)
+    manifest_path = output_root / "study-manifest.json"
+    if not manifest_path.exists():
+        raise ValueError("v2 executable study requires a prepared output root")
+    manifest, raw = _benchmark_study_v2_read_canonical(
+        manifest_path, owner="v2 executable manifest", maximum=2_000_000,
+    )
+    if set(manifest) != {"schema_version", "plan", "plan_sha256", "inputs", "schedule", "slots", "execution"} or manifest.get("schema_version") != BENCHMARK_STUDY_V2_EXEC_MANIFEST_SCHEMA_VERSION:
+        raise ValueError("v2 executable manifest schema mismatch")
+    validate_benchmark_study_v2_plan(manifest["plan"])
+    if manifest["plan_sha256"] != _study_sha256_bytes(_study_canonical_json_bytes(manifest["plan"])):
+        raise ValueError("v2 executable plan binding mismatch")
+    inputs = manifest["inputs"]
+    required_inputs = {
+        "plan_path", "tasks_path", "tasks_sha256", "task_definitions",
+        "checkers_dir", "checker_binding", "cli_binding", "execution_environment",
+        "auth_context", "runner_binding", "canary_contract", "candidate",
+        "approved_source_commit",
+        "source_ref_binding",
+        "candidate_install_root", "candidate_install_receipt_sha256",
+        "candidate_overlay_inventory", "settings", "namespace", "task_ids",
+        "task_ids_sha256",
+    }
+    if set(inputs) != required_inputs:
+        raise ValueError("v2 executable input schema mismatch")
+    _benchmark_study_v2_validate_cli_binding(inputs["cli_binding"])
+    _benchmark_study_v2_validate_execution_environment(
+        inputs["execution_environment"]
+    )
+    _benchmark_study_v2_validate_auth_context(inputs["auth_context"])
+    if inputs["runner_binding"] != _benchmark_study_v2_runner_binding():
+        raise ValueError("v2 benchmark runner binding drift")
+    if inputs["canary_contract"] != _benchmark_study_v2_canary_contract():
+        raise ValueError("v2 canary contract binding mismatch")
+    if (
+        not isinstance(inputs["approved_source_commit"], str)
+        or re.fullmatch(r"[0-9a-f]{40}", inputs["approved_source_commit"]) is None
+        or inputs["candidate"].get("commit_sha")
+        != inputs["approved_source_commit"]
+    ):
+        raise ValueError("v2 approved source revision binding mismatch")
+    source_ref_binding = inputs["source_ref_binding"]
+    if (
+        not isinstance(source_ref_binding, Mapping)
+        or set(source_ref_binding) != {
+            "commit_sha", "ref", "repository", "verification",
+        }
+        or source_ref_binding.get("commit_sha")
+        != inputs["approved_source_commit"]
+        or source_ref_binding.get("repository") != "ictechgy/context-guard"
+        or source_ref_binding.get("verification") not in {
+            "git-ls-remote-v1", "offline-rehearsal-unverified-v1",
+        }
+        or (
+            source_ref_binding.get("verification") == "git-ls-remote-v1"
+            and (
+                not isinstance(source_ref_binding.get("ref"), str)
+                or re.fullmatch(
+                    r"refs/heads/candidate/[A-Za-z0-9][A-Za-z0-9._/-]*",
+                    source_ref_binding["ref"],
+                ) is None
+            )
+        )
+        or (
+            source_ref_binding.get("verification")
+            == "offline-rehearsal-unverified-v1"
+            and source_ref_binding.get("ref") is not None
+        )
+    ):
+        raise ValueError("v2 retained source ref binding mismatch")
+    if (
+        not isinstance(inputs["task_definitions"], list)
+        or len(inputs["task_definitions"]) != 12
+    ):
+        raise ValueError("v2 executable task definition binding mismatch")
+    task_ids = _benchmark_study_v2_task_ids(inputs["task_ids"])
+    task_definition_ids = [
+        item.get("id") if isinstance(item, Mapping) else None
+        for item in inputs["task_definitions"]
+    ]
+    if (
+        inputs.get("namespace") != BENCHMARK_STUDY_V2_NAMESPACE
+        or inputs.get("tasks_sha256") != manifest["plan"]["corpus_sha256"]
+        or not isinstance(inputs.get("checker_binding"), Mapping)
+        or inputs["checker_binding"].get("sha256")
+        != manifest["plan"]["checker_sha256"]
+        or inputs.get("task_ids_sha256") != manifest["plan"]["task_ids_sha256"]
+        or inputs.get("task_ids_sha256")
+        != _benchmark_study_v2_task_ids_sha256(task_ids)
+        or task_definition_ids != task_ids
+    ):
+        raise ValueError("v2 executable task order or namespace binding mismatch")
+    if manifest["execution"] != {
+        "identities": 216, "initial_calls": 108,
+        "retry": "exactly_after_valid_initial_failure_v1",
+        "resume": "never_replay_launched_identity_v1",
+        "attempt_schema_version": BENCHMARK_STUDY_V2_ATTEMPT_SCHEMA_VERSION,
+        "invalid_decision_schema_version": (
+            BENCHMARK_STUDY_V2_INVALID_DECISION_SCHEMA_VERSION
+        ),
+        "candidate_imported": False, "candidate_install_count": 1,
+        "overlay_copy": "physical_copy_no_hardlinks_v1",
+    }:
+        raise ValueError("v2 executable lifecycle contract drift")
+    settings = inputs.get("settings")
+    expected_settings = _benchmark_study_v2_settings()
+    if not isinstance(settings, Mapping) or set(settings) != set(BENCHMARK_STUDY_V2_ARMS):
+        raise ValueError("v2 settings arm binding mismatch")
+    for arm in BENCHMARK_STUDY_V2_ARMS:
+        binding = settings[arm]
+        expected_path = output_root / "inputs" / "settings-v2" / f"{arm}.settings.json"
+        if (
+            not isinstance(binding, Mapping)
+            or set(binding) != {
+                "path", "sha256", "bytes", "bash_hook", "bash_reference_v1",
+            }
+            or binding.get("path") != str(expected_path.resolve())
+            or binding.get("bash_hook") is not (arm != "host_unmodified")
+            or binding.get("bash_reference_v1") is not (arm == "bash_reference_v1")
+        ):
+            raise ValueError(f"v2 {arm} settings binding mismatch")
+        raw_settings = _read_bytes_no_follow(expected_path, max_bytes=100_000)
+        expected_raw = _study_canonical_json_bytes(expected_settings[arm])
+        if (
+            raw_settings != expected_raw
+            or binding.get("sha256") != _study_sha256_bytes(expected_raw)
+            or binding.get("bytes") != len(expected_raw)
+        ):
+            raise ValueError(f"v2 {arm} settings policy drift")
+    install_receipt, install_receipt_raw = _benchmark_study_v2_read_canonical(
+        output_root / "candidate-install-receipt.json",
+        owner="v2 candidate install receipt", maximum=2_000_000,
+    )
+    if (
+        set(install_receipt) != {
+            "schema_version", "install_count", "network", "ignore_scripts",
+            "no_audit", "fund", "hidden_lockfile_removed",
+            "candidate_manifest_sha256", "argv_policy", "inventory",
+            "installed_packages",
+        }
+        or install_receipt.get("schema_version")
+        != "contextguard.bench.candidate-install.v2"
+        or install_receipt.get("install_count") != 1
+        or install_receipt.get("network") != "offline"
+        or install_receipt.get("ignore_scripts") is not True
+        or install_receipt.get("no_audit") is not True
+        or install_receipt.get("fund") is not False
+        or not isinstance(install_receipt.get("hidden_lockfile_removed"), bool)
+        or install_receipt.get("argv_policy") != [
+            "install", "--offline", "--ignore-scripts", "--no-audit",
+            "--fund=false", "--package-lock=false",
+        ]
+        or _study_sha256_bytes(install_receipt_raw)
+        != inputs.get("candidate_install_receipt_sha256")
+        or install_receipt.get("candidate_manifest_sha256")
+        != inputs.get("candidate", {}).get("manifest_sha256")
+        or install_receipt.get("inventory")
+        != inputs.get("candidate_overlay_inventory")
+    ):
+        raise ValueError("v2 candidate install receipt binding mismatch")
+    expected_schedule = generate_benchmark_study_v2_schedule(
+        task_ids, repetitions=3, schedule_seed=manifest["plan"]["schedule_seed"],
+    )
+    expected_slots = generate_benchmark_study_v2_slots(
+        task_ids, expected_schedule,
+        candidate_hash=inputs["candidate"]["manifest_sha256"],
+        namespace=inputs["namespace"],
+    )
+    if manifest["schedule"] != expected_schedule or manifest["slots"] != expected_slots:
+        raise ValueError("v2 executable schedule or identity drift")
+    if revalidate_external:
+        _benchmark_study_v2_assert_execution_environment(
+            inputs["execution_environment"]
+        )
+        external_plan = load_benchmark_study_v2_plan(Path(inputs["plan_path"]))
+        if external_plan != manifest["plan"]:
+            raise ValueError("v2 external study plan binding drift")
+        corpus = _read_bytes_no_follow(Path(inputs["tasks_path"]), max_bytes=MAX_FIXTURE_FILE_BYTES)
+        if _study_sha256_bytes(corpus) != inputs["tasks_sha256"]:
+            raise ValueError("v2 task corpus binding drift")
+        checker = benchmark_study_v2_checker_binding(Path(inputs["checkers_dir"]))
+        if checker != inputs["checker_binding"]:
+            raise ValueError("v2 checker inventory binding drift")
+        validate_benchmark_study_v2_bindings(
+            manifest["plan"], corpus_bytes=corpus, checker_binding=checker,
+        )
+        tasks = parse_tasks(Path(inputs["tasks_path"]))
+        load_task_fixture_trees(
+            tasks, task_file_dir=Path(inputs["tasks_path"]).parent,
+        )
+        task_definitions = [
+            _study_task_manifest(task, Path(inputs["tasks_path"]).parent)
+            for task in tasks
+        ]
+        if task_definitions != inputs["task_definitions"]:
+            raise ValueError("v2 task fixture or checker binding drift")
+        if [task.id for task in tasks] != task_ids:
+            raise ValueError("v2 external task order binding drift")
+        candidate = verify_benchmark_study_v2_candidate(
+            Path(inputs["candidate"]["manifest_path"]),
+            checksum_path=Path(inputs["candidate"]["checksum_path"]),
+            expected_manifest_sha256=inputs["candidate"]["manifest_sha256"],
+            expected_commit_sha=inputs["approved_source_commit"],
+        )
+        if candidate != inputs["candidate"]:
+            raise ValueError("v2 candidate binding drift")
+        if _benchmark_study_v2_verify_installed_packages(
+            Path(inputs["candidate_install_root"]), candidate,
+        ) != install_receipt["installed_packages"]:
+            raise ValueError("v2 installed candidate package binding drift")
+        if _benchmark_study_v2_inventory(Path(inputs["candidate_install_root"])) != inputs["candidate_overlay_inventory"]:
+            raise ValueError("v2 installed candidate inventory drift")
+        for arm, binding in inputs["settings"].items():
+            raw_settings = _read_bytes_no_follow(Path(binding["path"]), max_bytes=100_000)
+            if _study_sha256_bytes(raw_settings) != binding["sha256"] or len(raw_settings) != binding["bytes"]:
+                raise ValueError(f"v2 {arm} settings drift")
+    return manifest, _study_sha256_bytes(raw)
+
+
+def _benchmark_study_v2_variants(manifest: Mapping[str, Any], output_root: Path) -> dict[str, Variant]:
+    output_root = _benchmark_study_v2_output_root(output_root)
+    result: dict[str, Variant] = {}
+    artifact_root = output_root / "artifacts"
+    for arm in BENCHMARK_STUDY_V2_ARMS:
+        binding = manifest["inputs"]["settings"][arm]
+        settings_path = Path(binding["path"])
+        settings_raw = _read_bytes_no_follow(settings_path, max_bytes=100_000)
+        settings_payload = json.loads(settings_raw)
+        command = BENCHMARK_STUDY_V2_REWRITE_COMMAND + (
+            " --bash-reference-v1" if arm == "bash_reference_v1" else ""
+        )
+        registered = () if arm == "host_unmodified" else (("PreToolUse", command),)
+        identity = MeasurementIdentity(
+            candidate_hash=manifest["inputs"]["candidate"]["manifest_sha256"],
+            repetition=0, arm=arm, attempt=0,
+            namespace=manifest["inputs"]["namespace"],
+        )
+        result[arm] = Variant(
+            name=arm,
+            measurement=MeasurementVariant(
+                settings_file=settings_path,
+                setting_sources=("project",), environment_allow=(),
+                environment_overrides=tuple(
+                    (name, str(manifest["inputs"]["execution_environment"]["values"][name]))
+                    for name in sorted(
+                        manifest["inputs"]["execution_environment"]["values"]
+                    )
+                ),
+                workspace_mode="isolated",
+                session_mode="isolated", session_persistence="disabled",
+                hook_events_enabled=True, registered_bindings=registered,
+                required_event_classes=(), pair_registered_bindings=registered,
+                cli_capabilities=(
+                    "--settings", "--setting-sources", "--include-hook-events",
+                    "--no-session-persistence", "stream-json",
+                ),
+                identity=identity, artifact_root=artifact_root,
+                settings_payload=settings_payload, settings_source_bytes=settings_raw,
+            ),
+        )
+    return result
+
+
+def _benchmark_study_v2_canary_variants(
+    manifest: Mapping[str, Any], output_root: Path,
+) -> dict[str, Variant]:
+    analytic = _benchmark_study_v2_variants(manifest, output_root)
+    result: dict[str, Variant] = {}
+    for arm in BENCHMARK_STUDY_V2_CANARY_ARMS:
+        base = analytic[arm].measurement
+        assert base is not None
+        identity = MeasurementIdentity(
+            candidate_hash=manifest["inputs"]["candidate"]["manifest_sha256"],
+            repetition=0, arm=arm, attempt=0,
+            namespace=f"{manifest['inputs']['namespace']}.canary",
+        )
+        result[arm] = Variant(
+            name=arm,
+            measurement=replace(
+                base,
+                required_event_classes=("PreToolUse",),
+                identity=identity,
+                artifact_root=output_root / "canary-artifacts",
+            ),
+        )
+    return result
+
+
+def _benchmark_study_v2_canary_base_event(
+    *, arm: str, run_id: str, manifest_sha256: str, state: str,
+    **extra: Any,
+) -> dict[str, Any]:
+    event = {
+        "schema_version": BENCHMARK_STUDY_V2_CANARY_EVENT_SCHEMA_VERSION,
+        "manifest_sha256": manifest_sha256,
+        "arm": arm, "run_id": run_id, "state": state,
+    }
+    event.update(extra)
+    return event
+
+
+def _benchmark_study_v2_read_canary_events(
+    path: Path, *, manifest_sha256: str,
+    variants: Mapping[str, Variant],
+) -> list[dict[str, Any]]:
+    if not path.exists():
+        return []
+    raw = _measurement_read_private_file(path, maximum=200_000)
+    expected_run_ids = {}
+    for arm, variant in variants.items():
+        spec = variant.measurement
+        assert spec is not None
+        expected_run_ids[arm] = spec.identity.run_id(BENCHMARK_STUDY_V2_CANARY_TASK_ID)
+    base_keys = {"schema_version", "manifest_sha256", "arm", "run_id", "state"}
+    workspace_keys = base_keys | {
+        "pre_workspace_inventory_sha256", "pre_overlay_inventory_sha256",
+    }
+    terminal_keys = base_keys | {
+        "passed", "measurement_terminal_status", "checker_status",
+        "receipt_sha256", "pre_workspace_inventory_sha256",
+        "post_workspace_inventory_sha256", "pre_overlay_inventory_sha256",
+        "post_overlay_inventory_sha256", "pretooluse_event_count",
+    }
+    states: dict[str, list[str]] = collections.defaultdict(list)
+    rows: list[dict[str, Any]] = []
+    for line in raw.splitlines():
+        try:
+            row = json.loads(
+                line.decode("utf-8"),
+                object_pairs_hook=_measurement_object_no_duplicates,
+                parse_constant=_stream_reject_nonfinite,
+            )
+        except (UnicodeDecodeError, json.JSONDecodeError, ValueError) as exc:
+            raise ValueError("v2 canary event ledger is invalid JSONL") from exc
+        if not isinstance(row, dict) or line + b"\n" != _study_canonical_json_bytes(row):
+            raise ValueError("v2 canary event ledger must be canonical JSONL")
+        arm = row.get("arm")
+        state = row.get("state")
+        if (
+            row.get("schema_version") != BENCHMARK_STUDY_V2_CANARY_EVENT_SCHEMA_VERSION
+            or row.get("manifest_sha256") != manifest_sha256
+            or arm not in BENCHMARK_STUDY_V2_CANARY_ARMS
+            or row.get("run_id") != expected_run_ids.get(str(arm))
+            or state not in {"launch_reserved", "workspace_prepared", "launched", "terminal"}
+        ):
+            raise ValueError("v2 canary event binding mismatch")
+        expected_keys = (
+            workspace_keys if state == "workspace_prepared"
+            else terminal_keys if state == "terminal" else base_keys
+        )
+        if set(row) != expected_keys:
+            raise ValueError("v2 canary event schema mismatch")
+        previous = states[str(arm)]
+        expected_previous = {
+            "launch_reserved": [],
+            "workspace_prepared": ["launch_reserved"],
+            "launched": ["launch_reserved", "workspace_prepared"],
+            "terminal": ["launch_reserved", "workspace_prepared", "launched"],
+        }[str(state)]
+        if previous != expected_previous:
+            raise ValueError("v2 canary event state transition is invalid")
+        if state in {"workspace_prepared", "terminal"}:
+            hash_fields = (
+                ("pre_workspace_inventory_sha256", "pre_overlay_inventory_sha256")
+                if state == "workspace_prepared" else (
+                    "receipt_sha256", "pre_workspace_inventory_sha256",
+                    "post_workspace_inventory_sha256", "pre_overlay_inventory_sha256",
+                    "post_overlay_inventory_sha256",
+                )
+            )
+            if any(
+                not isinstance(row.get(field), str)
+                or SHA256_HEX_PATTERN.fullmatch(str(row[field])) is None
+                for field in hash_fields
+            ):
+                raise ValueError("v2 canary evidence hash is invalid")
+        if state == "terminal" and (
+            not isinstance(row.get("passed"), bool)
+            or row.get("measurement_terminal_status") not in {
+                "success", "raw_byte_limit", "raw_line_limit", "raw_line_byte_limit",
+                "process_timeout", "process_launch_error", "process_error",
+                "terminal_error", "missing_terminal", "invalid_stream",
+                "hook_payload_limit", "hook_lifecycle_limit", "invalid_hook_lifecycle",
+                "unexpected_hook_event_class", "missing_required_hook_event_class",
+                "hook_process_failure",
+            }
+            or row.get("checker_status") not in {
+                "task_success", "valid_task_failure_v1", "success_checker_infra_invalid",
+                "not_run",
+            }
+            or isinstance(row.get("pretooluse_event_count"), bool)
+            or not isinstance(row.get("pretooluse_event_count"), int)
+            or row["pretooluse_event_count"] < 0
+        ):
+            raise ValueError("v2 canary terminal evidence is invalid")
+        previous.append(str(state))
+        rows.append(row)
+    return rows
+
+
+def _benchmark_study_v2_derive_canary_terminal(
+    *, manifest: Mapping[str, Any], manifest_sha256: str, output_root: Path,
+    arm: str, variant: Variant, task: TaskFixture,
+    workspace_event: Mapping[str, Any],
+) -> dict[str, Any]:
+    spec = variant.measurement
+    assert spec is not None
+    run_id = spec.identity.run_id(task.id)
+    receipt = _verify_existing_measurement_run(
+        spec, task.id, run_id, require_index=True,
+    )
+    context = _measurement_existing_context(spec, run_id)
+    receipt_raw = _measurement_read_private_file(context.receipt_path)
+    expected_overlay = manifest["inputs"]["candidate_overlay_inventory"]
+    expected_pre = _benchmark_study_v2_expected_pre_workspace(
+        task,
+        install_root=Path(manifest["inputs"]["candidate_install_root"]),
+        expected_overlay_inventory=expected_overlay,
+    )
+    post_workspace = _benchmark_study_v2_inventory(context.workspace)
+    post_overlay = _benchmark_study_v2_inventory(
+        context.workspace / BENCHMARK_STUDY_V2_OVERLAY_NAME,
+    )
+    checker = (
+        run_task_checker_study(
+            task, context.workspace, env={},
+            interpreter_binding=manifest["inputs"]["runner_binding"]["python"],
+        )
+        if receipt["terminal_status"] == "success" else "not_run"
+    )
+    summary = receipt["hook_summary"]
+    counts = {
+        row["hook_event"]: row["count"]
+        for row in summary["event_class_counts"]
+    }
+    pretooluse_count = int(counts.get("PreToolUse", 0))
+    pre_bound = bool(
+        workspace_event.get("pre_workspace_inventory_sha256") == expected_pre["sha256"]
+        and workspace_event.get("pre_overlay_inventory_sha256") == expected_overlay["sha256"]
+    )
+    hooks_valid = bool(
+        summary["required_event_classes"] == ["PreToolUse"]
+        and pretooluse_count >= 1
+        and set(counts) == {"PreToolUse"}
+        and all(
+            hook["hook_event"] == "PreToolUse"
+            and hook["hook_process_outcome"] == "success"
+            and hook["hook_process_exit_code"] in (None, 0)
+            for hook in receipt["hooks"]
+        )
+    )
+    passed = bool(
+        receipt["terminal_status"] == "success"
+        and checker == "task_success" and hooks_valid and pre_bound
+        and post_overlay == expected_overlay
+    )
+    return _benchmark_study_v2_canary_base_event(
+        arm=arm, run_id=run_id, manifest_sha256=manifest_sha256,
+        state="terminal", passed=passed,
+        measurement_terminal_status=receipt["terminal_status"],
+        checker_status=checker,
+        receipt_sha256=_study_sha256_bytes(receipt_raw),
+        pre_workspace_inventory_sha256=str(
+            workspace_event["pre_workspace_inventory_sha256"]
+        ),
+        post_workspace_inventory_sha256=post_workspace["sha256"],
+        pre_overlay_inventory_sha256=str(
+            workspace_event["pre_overlay_inventory_sha256"]
+        ),
+        post_overlay_inventory_sha256=post_overlay["sha256"],
+        pretooluse_event_count=pretooluse_count,
+    )
+
+
+def _benchmark_study_v2_expected_canary_evidence(
+    *, manifest: Mapping[str, Any], manifest_sha256: str, output_root: Path,
+    rows: Sequence[Mapping[str, Any]], variants: Mapping[str, Variant],
+) -> dict[str, Any]:
+    task = _benchmark_study_v2_canary_task()
+    by_arm: dict[str, list[Mapping[str, Any]]] = {
+        arm: [row for row in rows if row["arm"] == arm]
+        for arm in BENCHMARK_STUDY_V2_CANARY_ARMS
+    }
+    records: list[dict[str, Any]] = []
+    for arm in BENCHMARK_STUDY_V2_CANARY_ARMS:
+        arm_rows = by_arm[arm]
+        if [row["state"] for row in arm_rows] != [
+            "launch_reserved", "workspace_prepared", "launched", "terminal",
+        ]:
+            raise ValueError("v2 canary evidence is incomplete")
+        recomputed = _benchmark_study_v2_derive_canary_terminal(
+            manifest=manifest, manifest_sha256=manifest_sha256,
+            output_root=output_root, arm=arm, variant=variants[arm], task=task,
+            workspace_event=arm_rows[1],
+        )
+        if recomputed != dict(arm_rows[-1]) or recomputed["passed"] is not True:
+            raise ValueError("v2 canary terminal evidence did not pass")
+        spec = variants[arm].measurement
+        assert spec is not None
+        records.append({
+            "arm": arm, "run_id": recomputed["run_id"], "passed": True,
+            "settings_sha256": manifest["inputs"]["settings"][arm]["sha256"],
+            "settings_binding_set_sha256": _measurement_binding_set_sha256(
+                spec.registered_bindings
+            ),
+            "required_event_classes": ["PreToolUse"],
+            "pretooluse_event_count": recomputed["pretooluse_event_count"],
+            "receipt_sha256": recomputed["receipt_sha256"],
+            "pre_overlay_inventory_sha256": recomputed[
+                "pre_overlay_inventory_sha256"
+            ],
+            "post_overlay_inventory_sha256": recomputed[
+                "post_overlay_inventory_sha256"
+            ],
+        })
+    return {
+        "schema_version": BENCHMARK_STUDY_V2_CANARY_EVIDENCE_SCHEMA_VERSION,
+        "manifest_sha256": manifest_sha256,
+        "canary_contract_sha256": _study_domain_hash(
+            "contextguard.bench.v2.canary-contract.v1",
+            manifest["inputs"]["canary_contract"],
+        ),
+        "cli_binding_sha256": _study_domain_hash(
+            "contextguard.bench.v2.cli-binding.v1",
+            manifest["inputs"]["cli_binding"],
+        ),
+        "auth_context_sha256": _study_domain_hash(
+            "contextguard.bench.v2.auth-context.v1",
+            manifest["inputs"]["auth_context"],
+        ),
+        "candidate_manifest_sha256": manifest["inputs"]["candidate"][
+            "manifest_sha256"
+        ],
+        "candidate_overlay_sha256": manifest["inputs"][
+            "candidate_overlay_inventory"
+        ]["sha256"],
+        "discarded": True, "excluded_from_analysis": True,
+        "provider_calls": 2, "arms": records,
+    }
+
+
+def _benchmark_study_v2_verify_canary_evidence(
+    *, manifest: Mapping[str, Any], manifest_sha256: str, output_root: Path,
+) -> tuple[dict[str, Any], str]:
+    variants = _benchmark_study_v2_canary_variants(manifest, output_root)
+    rows = _benchmark_study_v2_read_canary_events(
+        output_root / "canary-events.jsonl",
+        manifest_sha256=manifest_sha256, variants=variants,
+    )
+    expected = _benchmark_study_v2_expected_canary_evidence(
+        manifest=manifest, manifest_sha256=manifest_sha256,
+        output_root=output_root, rows=rows, variants=variants,
+    )
+    observed, raw = _benchmark_study_v2_read_canonical(
+        output_root / "canary-evidence.json",
+        owner="v2 canary evidence", maximum=200_000,
+    )
+    if observed != expected:
+        raise ValueError("v2 canary evidence binding mismatch")
+    return observed, _study_sha256_bytes(raw)
+
+
+def _benchmark_study_v2_run_canary_arm(
+    *, manifest: Mapping[str, Any], manifest_sha256: str, output_root: Path,
+    arm: str, variant: Variant, task: TaskFixture, claude_bin: str,
+    cli_stat_guard: Mapping[str, Any],
+    runtime_stat_guards: Mapping[str, Mapping[str, int | str]],
+    auth_home: Path,
+) -> dict[str, Any]:
+    spec = variant.measurement
+    assert spec is not None
+    run_id = spec.identity.run_id(task.id)
+    ledger_path = output_root / "canary-events.jsonl"
+    _benchmark_study_v2_assert_cli_executable_bytes(
+        manifest["inputs"]["cli_binding"], cli_stat_guard,
+    )
+    _benchmark_study_v2_assert_runtime_stat_guards(
+        manifest["inputs"]["execution_environment"], runtime_stat_guards,
+    )
+    resolved_auth_home = _benchmark_study_v2_assert_auth_context(
+        claude_bin, manifest["inputs"]["execution_environment"],
+        manifest["inputs"]["auth_context"], auth_home,
+    )
+    append_study_attempt_event(
+        ledger_path,
+        _benchmark_study_v2_canary_base_event(
+            arm=arm, run_id=run_id, manifest_sha256=manifest_sha256,
+            state="launch_reserved",
+        ),
+    )
+    pre: dict[str, Any] = {}
+
+    def prepared(workspace: Path) -> None:
+        overlay = workspace / BENCHMARK_STUDY_V2_OVERLAY_NAME
+        overlay_inventory = _benchmark_study_v2_verify_physical_copy(
+            Path(manifest["inputs"]["candidate_install_root"]), overlay,
+            expected=manifest["inputs"]["candidate_overlay_inventory"],
+        )
+        workspace_inventory = _benchmark_study_v2_inventory(workspace)
+        pre.update({"overlay": overlay_inventory, "workspace": workspace_inventory})
+        append_study_attempt_event(
+            ledger_path,
+            _benchmark_study_v2_canary_base_event(
+                arm=arm, run_id=run_id, manifest_sha256=manifest_sha256,
+                state="workspace_prepared",
+                pre_workspace_inventory_sha256=workspace_inventory["sha256"],
+                pre_overlay_inventory_sha256=overlay_inventory["sha256"],
+            ),
+        )
+
+    def launched() -> None:
+        append_study_attempt_event(
+            ledger_path,
+            _benchmark_study_v2_canary_base_event(
+                arm=arm, run_id=run_id, manifest_sha256=manifest_sha256,
+                state="launched",
+            ),
+        )
+
+    root_fd = _ensure_directory_no_symlink(spec.artifact_root, create=True)
+    try:
+        os.fchmod(root_fd, 0o700)
+        if fcntl is not None:
+            fcntl.flock(root_fd, fcntl.LOCK_EX)
+        _run_measurement_fixture_locked(
+            task, variant, claude_bin, Path(manifest_sha256),
+            locked_root_fd=root_fd, on_process_started=launched,
+            measurement_study=True,
+            workspace_overlay=Path(manifest["inputs"]["candidate_install_root"]),
+            on_workspace_prepared=prepared,
+            checker_interpreter_binding=manifest["inputs"]["runner_binding"][
+                "python"
+            ],
+            existing_login_home=resolved_auth_home,
+        )
+    finally:
+        os.close(root_fd)
+    if set(pre) != {"overlay", "workspace"}:
+        raise ValueError("v2 canary workspace was not prepared")
+    workspace_event = _benchmark_study_v2_canary_base_event(
+        arm=arm, run_id=run_id, manifest_sha256=manifest_sha256,
+        state="workspace_prepared",
+        pre_workspace_inventory_sha256=pre["workspace"]["sha256"],
+        pre_overlay_inventory_sha256=pre["overlay"]["sha256"],
+    )
+    terminal = _benchmark_study_v2_derive_canary_terminal(
+        manifest=manifest, manifest_sha256=manifest_sha256,
+        output_root=output_root, arm=arm, variant=variant, task=task,
+        workspace_event=workspace_event,
+    )
+    append_study_attempt_event(ledger_path, terminal)
+    if terminal["passed"] is not True:
+        raise ValueError(f"v2 {arm} host PreToolUse canary failed")
+    return terminal
+
+
+def execute_benchmark_study_v2_canary(
+    *, output_root: Path, claude_bin: str, auth_home: Path,
+) -> dict[str, Any]:
+    with _benchmark_study_v2_action_lock(output_root):
+        return _execute_benchmark_study_v2_canary_unlocked(
+            output_root=output_root, claude_bin=claude_bin,
+            auth_home=auth_home,
+        )
+
+
+def _execute_benchmark_study_v2_canary_unlocked(
+    *, output_root: Path, claude_bin: str, auth_home: Path,
+) -> dict[str, Any]:
+    output_root = _benchmark_study_v2_output_root(output_root)
+    manifest, manifest_sha256 = load_benchmark_study_v2_executable_manifest(
+        output_root, revalidate_external=True,
+    )
+    attempts_path = output_root / "attempts.jsonl"
+    if attempts_path.exists() and attempts_path.stat().st_size:
+        raise ValueError("v2 canary must finish before analytic attempts")
+    cli_stat_guard = _benchmark_study_v2_assert_cli_binding(
+        claude_bin, manifest["inputs"]["cli_binding"],
+    )
+    runtime_stat_guards = _benchmark_study_v2_assert_execution_environment(
+        manifest["inputs"]["execution_environment"]
+    )
+    bound_claude_bin = str(cli_stat_guard["executable"])
+    resolved_auth_home = _benchmark_study_v2_assert_auth_context(
+        bound_claude_bin, manifest["inputs"]["execution_environment"],
+        manifest["inputs"]["auth_context"], auth_home,
+    )
+    variants = _benchmark_study_v2_canary_variants(manifest, output_root)
+    task = _benchmark_study_v2_canary_task()
+    ledger_path = output_root / "canary-events.jsonl"
+    launched_now = 0
+    for arm in BENCHMARK_STUDY_V2_CANARY_ARMS:
+        rows = _benchmark_study_v2_read_canary_events(
+            ledger_path, manifest_sha256=manifest_sha256, variants=variants,
+        )
+        arm_rows = [row for row in rows if row["arm"] == arm]
+        if arm_rows and arm_rows[-1]["state"] == "terminal":
+            if arm_rows[-1]["passed"] is not True:
+                raise ValueError(f"v2 {arm} canary terminal did not pass")
+            continue
+        if arm_rows:
+            if arm_rows[-1]["state"] != "launched":
+                raise ValueError("v2 canary reserved identity cannot be replayed")
+            try:
+                recovered = _benchmark_study_v2_derive_canary_terminal(
+                    manifest=manifest, manifest_sha256=manifest_sha256,
+                    output_root=output_root, arm=arm, variant=variants[arm],
+                    task=task, workspace_event=arm_rows[1],
+                )
+            except (OSError, SystemExit, TypeError, ValueError) as exc:
+                raise ValueError("v2 launched canary cannot be safely recovered") from exc
+            append_study_attempt_event(ledger_path, recovered)
+            if recovered["passed"] is not True:
+                raise ValueError(f"v2 {arm} recovered canary did not pass")
+            continue
+        _benchmark_study_v2_run_canary_arm(
+            manifest=manifest, manifest_sha256=manifest_sha256,
+            output_root=output_root, arm=arm, variant=variants[arm], task=task,
+            claude_bin=bound_claude_bin, cli_stat_guard=cli_stat_guard,
+            runtime_stat_guards=runtime_stat_guards,
+            auth_home=resolved_auth_home,
+        )
+        launched_now += 1
+    rows = _benchmark_study_v2_read_canary_events(
+        ledger_path, manifest_sha256=manifest_sha256, variants=variants,
+    )
+    expected = _benchmark_study_v2_expected_canary_evidence(
+        manifest=manifest, manifest_sha256=manifest_sha256,
+        output_root=output_root, rows=rows, variants=variants,
+    )
+    evidence_path = output_root / "canary-evidence.json"
+    if evidence_path.exists():
+        observed, _raw = _benchmark_study_v2_read_canonical(
+            evidence_path, owner="v2 canary evidence", maximum=200_000,
+        )
+        if observed != expected:
+            raise ValueError("v2 canary evidence binding mismatch")
+    else:
+        _study_write_private(evidence_path, expected)
+    _observed, evidence_sha256 = _benchmark_study_v2_verify_canary_evidence(
+        manifest=manifest, manifest_sha256=manifest_sha256,
+        output_root=output_root,
+    )
+    return {
+        "provider_process_calls": launched_now,
+        "discarded_provider_calls": 2,
+        "canary_evidence_sha256": evidence_sha256,
+    }
+
+
+def _benchmark_study_v2_bounded_failure_usage(
+    *, receipt: Mapping[str, Any], raw: bytes, arm: str,
+    allowed_event_classes: Sequence[str],
+    required_event_classes: Sequence[str],
+) -> dict[str, int] | None:
+    """Return usage only for an exact policy-bounded provider task failure."""
+    if (
+        receipt.get("process_status") != "exited_nonzero"
+        or receipt.get("terminal_status") != "process_error"
+    ):
+        return None
+    parsed = parse_claude_stream_output(
+        raw, max_line_bytes=MEASUREMENT_RAW_MAX_LINE_BYTES,
+    )
+    if (
+        parsed.status != "terminal_error"
+        or parsed.result_code not in BENCHMARK_STUDY_V2_BOUNDED_FAILURE_RESULT_CODES
+    ):
+        return None
+    hooks = _parse_measurement_hook_events(raw)
+    completed_classes = {item["hook_event"] for item in hooks["hooks"]}
+    allowed_classes = set(allowed_event_classes)
+    required_classes = set(required_event_classes)
+    hook_arms = {"legacy_trim", "bash_reference_v1"}
+    if (
+        hooks["classification"] is not None
+        or hooks["failure_flags"]
+        or (arm in hook_arms and completed_classes - allowed_classes)
+        or (arm == "host_unmodified" and hooks["observed"])
+        or required_classes - completed_classes
+        or any(
+            item["hook_process_outcome"] != "success"
+            or item["hook_process_exit_code"] not in (None, 0)
+            for item in hooks["hooks"]
+        )
+    ):
+        return None
+    try:
+        return parse_measurement_terminal_usage(raw)
+    except ValueError:
+        return None
+
+
+def _benchmark_study_v2_revalidate_terminal_evidence(
+    *, manifest: Mapping[str, Any], output_root: Path,
+    rows: Sequence[Mapping[str, Any]], tasks_by_id: Mapping[str, TaskFixture],
+    variants: Mapping[str, Variant],
+) -> None:
+    slots = {slot["run_id"]: slot for slot in manifest["slots"]}
+    install_root = Path(manifest["inputs"]["candidate_install_root"])
+    expected_overlay = manifest["inputs"]["candidate_overlay_inventory"]
+    expected_pre_by_task: dict[str, dict[str, Any]] = {}
+    for row in rows:
+        if row["state"] != "terminal" or row["terminal_status"] == "recovered_process_status_unknown":
+            continue
+        slot = slots[row["run_id"]]
+        task_id = str(slot["task_id"])
+        if task_id not in expected_pre_by_task:
+            expected_pre_by_task[task_id] = _benchmark_study_v2_expected_pre_workspace(
+                tasks_by_id[task_id], install_root=install_root,
+                expected_overlay_inventory=expected_overlay,
+            )
+        if (
+            row["pre_workspace_inventory_sha256"]
+            != expected_pre_by_task[task_id]["sha256"]
+        ):
+            raise ValueError("v2 pre-launch workspace inventory drift")
+        study_variant = _study_variant_for_slot(variants[slot["arm"]], slot)
+        spec = study_variant.measurement
+        assert spec is not None
+        receipt = _verify_existing_measurement_run(
+            spec, task_id, str(slot["run_id"]), require_index=True,
+        )
+        context = _measurement_existing_context(spec, str(slot["run_id"]))
+        receipt_raw = _measurement_read_private_file(context.receipt_path)
+        raw = _measurement_read_private_raw(context.raw_path)
+        if _study_sha256_bytes(receipt_raw) != row["receipt_sha256"]:
+            raise ValueError("v2 attempt receipt hash differs from immutable receipt")
+        if receipt["terminal_status"] != row["provider_terminal_status"]:
+            raise ValueError("v2 attempt provider terminal differs from immutable receipt")
+        bounded_failure_usage = _benchmark_study_v2_bounded_failure_usage(
+            receipt=receipt, raw=raw, arm=str(slot["arm"]),
+            allowed_event_classes=tuple(
+                dict.fromkeys(
+                    event for event, _command in spec.pair_registered_bindings
+                )
+            ),
+            required_event_classes=spec.required_event_classes,
+        )
+        if receipt["terminal_status"] == "success":
+            usage = parse_measurement_terminal_usage(raw)
+            expected_buckets = {
+                key: usage[key] for key in MEASUREMENT_STUDY_USAGE_KEYS
+            }
+            checker = run_task_checker_study(
+                tasks_by_id[task_id], context.workspace, env={},
+                interpreter_binding=manifest["inputs"]["runner_binding"][
+                    "python"
+                ],
+            )
+        elif bounded_failure_usage is not None:
+            expected_buckets = {
+                key: bounded_failure_usage[key]
+                for key in MEASUREMENT_STUDY_USAGE_KEYS
+            }
+            checker = BENCHMARK_STUDY_V2_BOUNDED_FAILURE_CHECKER_STATUS
+        else:
+            expected_buckets = {key: 0 for key in MEASUREMENT_STUDY_USAGE_KEYS}
+            checker = "not_run"
+        if row["token_buckets"] != expected_buckets or row["primary_tokens"] != sum(expected_buckets.values()):
+            raise ValueError("v2 attempt tokens differ from provider terminal usage")
+        if row["checker_status"] != checker:
+            raise ValueError("v2 attempt checker status differs from the bound checker")
+        derived = (
+            "success" if receipt["terminal_status"] == "success" and checker == "task_success"
+            else "valid_task_failure_v1"
+            if receipt["terminal_status"] == "success" and checker == "valid_task_failure_v1"
+            else "valid_task_failure_v1"
+            if bounded_failure_usage is not None
+            else "study_infra_invalid"
+        )
+        if (
+            row["post_overlay_inventory_sha256"]
+            != row["pre_overlay_inventory_sha256"]
+        ):
+            derived = "study_infra_invalid"
+        if row["terminal_status"] != derived or row["success"] is not (derived == "success"):
+            raise ValueError("v2 attempt outcome was not derived from provider plus checker")
+        workspace_inventory = _benchmark_study_v2_inventory(context.workspace)
+        overlay_inventory = _benchmark_study_v2_inventory(
+            context.workspace / BENCHMARK_STUDY_V2_OVERLAY_NAME,
+        )
+        overlay_drifted = (
+            overlay_inventory != manifest["inputs"]["candidate_overlay_inventory"]
+        )
+        if (
+            workspace_inventory["sha256"] != row["post_workspace_inventory_sha256"]
+            or overlay_inventory["sha256"] != row["post_overlay_inventory_sha256"]
+            or (
+                overlay_drifted
+                and row["terminal_status"] != "study_infra_invalid"
+            )
+        ):
+            raise ValueError("v2 terminal workspace or overlay inventory drift")
+
+
+def _benchmark_study_v2_read_attempts(path: Path, *, manifest: Mapping[str, Any], manifest_sha256: str) -> list[dict[str, Any]]:
+    if not path.exists():
+        return []
+    raw = _measurement_read_private_file(path, maximum=4_000_000)
+    slots = {slot["run_id"]: slot for slot in manifest["slots"]}
+    rows: list[dict[str, Any]] = []
+    states: dict[str, list[str]] = collections.defaultdict(list)
+    base_keys = {
+        "schema_version", "manifest_sha256", "run_id", "task_id",
+        "repetition", "arm", "attempt", "state",
+    }
+    terminal_keys = base_keys | {
+        "terminal_status", "provider_terminal_status", "checker_status",
+        "success", "token_buckets", "primary_tokens", "correction",
+        "retrieval", "shifted_cost", "pre_workspace_inventory_sha256",
+        "post_workspace_inventory_sha256", "pre_overlay_inventory_sha256",
+        "post_overlay_inventory_sha256", "receipt_sha256",
+    }
+    blocked_keys = base_keys | {"reason"}
+    for line in raw.splitlines():
+        try:
+            row = json.loads(line.decode("utf-8"), object_pairs_hook=_measurement_object_no_duplicates)
+        except (UnicodeDecodeError, json.JSONDecodeError, ValueError) as exc:
+            raise ValueError("v2 attempt index is invalid JSONL") from exc
+        if not isinstance(row, dict) or line + b"\n" != _study_canonical_json_bytes(row):
+            raise ValueError("v2 attempt index must be canonical JSONL")
+        slot = slots.get(row.get("run_id"))
+        if row.get("schema_version") != BENCHMARK_STUDY_V2_ATTEMPT_SCHEMA_VERSION or row.get("manifest_sha256") != manifest_sha256 or slot is None:
+            raise ValueError("v2 attempt index binding mismatch")
+        if any(row.get(key) != slot.get(key) for key in ("task_id", "repetition", "arm", "attempt")):
+            raise ValueError("v2 attempt identity mismatch")
+        state = row.get("state")
+        if state not in {
+            "launch_reserved", "launched", "terminal", "not_needed",
+            "blocked_study_invalid",
+        }:
+            raise ValueError("v2 attempt state is invalid")
+        expected_keys = (
+            terminal_keys if state == "terminal"
+            else blocked_keys if state == "blocked_study_invalid"
+            else base_keys
+        )
+        if set(row) != expected_keys:
+            raise ValueError("v2 attempt state has an inexact key schema")
+        previous = states[row["run_id"]]
+        if (
+            (state == "launch_reserved" and previous)
+            or (state == "launched" and previous != ["launch_reserved"])
+            or (state == "terminal" and previous not in (["launch_reserved"], ["launch_reserved", "launched"]))
+            or (state in {"not_needed", "blocked_study_invalid"} and previous)
+        ):
+            raise ValueError("v2 attempt state transition is invalid")
+        if state in {"not_needed", "blocked_study_invalid"} and row["attempt"] != 1:
+            raise ValueError("v2 non-launched final state is only valid for a retry")
+        if state == "blocked_study_invalid" and row["reason"] != "initial_study_invalid":
+            raise ValueError("v2 blocked retry reason is invalid")
+        previous.append(state)
+        if state == "terminal":
+            status = row["terminal_status"]
+            if status not in {
+                "success", "valid_task_failure_v1", "study_infra_invalid",
+            } or not isinstance(row["success"], bool) or row["success"] is not (status == "success"):
+                raise ValueError("v2 attempt success/classification binding is invalid")
+            buckets = row["token_buckets"]
+            if not isinstance(buckets, dict) or set(buckets) != set(MEASUREMENT_STUDY_USAGE_KEYS):
+                raise ValueError("v2 attempt token bucket schema is invalid")
+            total = 0
+            for key in MEASUREMENT_STUDY_USAGE_KEYS:
+                value = buckets[key]
+                if isinstance(value, bool) or not isinstance(value, int) or not 0 <= value <= MAX_USAGE_TOKEN_COUNT:
+                    raise ValueError("v2 attempt token bucket is invalid")
+                total += value
+            if total > MAX_USAGE_TOKEN_COUNT or row["primary_tokens"] != total:
+                raise ValueError("v2 attempt primary token sum is invalid")
+            if any(row[field] is not None for field in ("correction", "retrieval", "shifted_cost")):
+                raise ValueError("v2 absent observer must remain null")
+            hash_fields = (
+                "pre_workspace_inventory_sha256", "post_workspace_inventory_sha256",
+                "pre_overlay_inventory_sha256", "post_overlay_inventory_sha256",
+                "receipt_sha256",
+            )
+            if any(
+                not isinstance(row[field], str)
+                or SHA256_HEX_PATTERN.fullmatch(row[field]) is None
+                for field in hash_fields
+            ):
+                raise ValueError("v2 terminal evidence hash is invalid")
+            expected_overlay_sha256 = manifest["inputs"][
+                "candidate_overlay_inventory"
+            ]["sha256"]
+            if (
+                row["pre_overlay_inventory_sha256"] != expected_overlay_sha256
+                or (
+                    row["post_overlay_inventory_sha256"]
+                    != row["pre_overlay_inventory_sha256"]
+                    and status != "study_infra_invalid"
+                )
+            ):
+                raise ValueError("v2 terminal overlay binding is invalid")
+            if status == "success" and not (
+                row["provider_terminal_status"] == "success"
+                and row["checker_status"] == "task_success"
+            ):
+                raise ValueError("v2 successful outcome lacks provider/checker evidence")
+            if status == "valid_task_failure_v1" and not (
+                (
+                    row["provider_terminal_status"] == "success"
+                    and row["checker_status"] == "valid_task_failure_v1"
+                )
+                or (
+                    row["provider_terminal_status"] == "process_error"
+                    and row["checker_status"]
+                    == BENCHMARK_STUDY_V2_BOUNDED_FAILURE_CHECKER_STATUS
+                )
+            ):
+                raise ValueError("v2 valid failure lacks provider/checker evidence")
+        rows.append(row)
+    terminal_by_unit = {
+        (row["task_id"], row["repetition"], row["arm"]): row
+        for row in rows
+        if row["attempt"] == 0 and row["state"] == "terminal"
+    }
+    for row in rows:
+        if row["attempt"] != 1:
+            continue
+        initial = terminal_by_unit.get((row["task_id"], row["repetition"], row["arm"]))
+        if row["state"] == "not_needed" and (
+            initial is None or initial["terminal_status"] != "success"
+        ):
+            raise ValueError("v2 not-needed retry lacks a successful initial")
+        if row["state"] == "blocked_study_invalid" and (
+            initial is None
+            or initial["terminal_status"] != "study_infra_invalid"
+        ):
+            raise ValueError("v2 blocked retry lacks an invalid initial")
+        if row["state"] in {"launch_reserved", "launched", "terminal"} and (
+            initial is None or initial["terminal_status"] != "valid_task_failure_v1"
+        ):
+            raise ValueError("v2 launched retry lacks a valid failed initial")
+    return rows
+
+
+def _benchmark_study_v2_event(slot: Mapping[str, Any], manifest_sha256: str, state: str, **extra: Any) -> dict[str, Any]:
+    event = {
+        "schema_version": BENCHMARK_STUDY_V2_ATTEMPT_SCHEMA_VERSION,
+        "manifest_sha256": manifest_sha256, "run_id": slot["run_id"],
+        "task_id": slot["task_id"], "repetition": slot["repetition"],
+        "arm": slot["arm"], "attempt": slot["attempt"], "state": state,
+    }
+    event.update(extra)
+    return event
+
+
+def _benchmark_study_v2_run_slot(
+    *, slot: Mapping[str, Any], task: TaskFixture, variant: Variant,
+    claude_bin: str, attempts_path: Path, manifest_sha256: str,
+    install_root: Path, expected_overlay_inventory: Mapping[str, Any],
+    cli_binding: Mapping[str, Any],
+    cli_stat_guard: Mapping[str, Any],
+    execution_environment: Mapping[str, Any],
+    runtime_stat_guards: Mapping[str, Mapping[str, int | str]],
+    checker_interpreter_binding: Mapping[str, Any],
+    auth_context: Mapping[str, Any],
+    auth_home: Path,
+) -> str:
+    study_variant = _study_variant_for_slot(variant, slot)
+    spec = study_variant.measurement
+    assert spec is not None
+    pre: dict[str, Any] = {}
+
+    def prepared(workspace: Path) -> None:
+        overlay = workspace / BENCHMARK_STUDY_V2_OVERLAY_NAME
+        pre["overlay"] = _benchmark_study_v2_verify_physical_copy(
+            install_root, overlay, expected=expected_overlay_inventory,
+        )
+        pre["workspace"] = _benchmark_study_v2_inventory(workspace)
+
+    def launched() -> None:
+        append_study_attempt_event(
+            attempts_path,
+            _benchmark_study_v2_event(slot, manifest_sha256, "launched"),
+        )
+
+    # Durable reservation precedes Popen. Resume treats even a reservation-only
+    # identity as consumed/unknown, so a provider that started while launched
+    # accounting failed can never be invoked twice.
+    _benchmark_study_v2_assert_cli_executable_bytes(cli_binding, cli_stat_guard)
+    _benchmark_study_v2_assert_runtime_stat_guards(
+        execution_environment, runtime_stat_guards,
+    )
+    resolved_auth_home = _benchmark_study_v2_assert_auth_context(
+        claude_bin, execution_environment, auth_context, auth_home,
+    )
+    append_study_attempt_event(
+        attempts_path,
+        _benchmark_study_v2_event(slot, manifest_sha256, "launch_reserved"),
+    )
+    root_fd = _ensure_directory_no_symlink(spec.artifact_root, create=True)
+    try:
+        os.fchmod(root_fd, 0o700)
+        if fcntl is not None:
+            fcntl.flock(root_fd, fcntl.LOCK_EX)
+        result = _run_measurement_fixture_locked(
+            task, study_variant, claude_bin, Path(manifest_sha256),
+            locked_root_fd=root_fd, on_process_started=launched,
+            measurement_study=True, workspace_overlay=install_root,
+            on_workspace_prepared=prepared,
+            checker_interpreter_binding=checker_interpreter_binding,
+            existing_login_home=resolved_auth_home,
+        )
+    finally:
+        os.close(root_fd)
+    context = _measurement_existing_context(spec, str(slot["run_id"]))
+    post_workspace = _benchmark_study_v2_inventory(context.workspace)
+    post_overlay = _benchmark_study_v2_inventory(
+        context.workspace / BENCHMARK_STUDY_V2_OVERLAY_NAME,
+    )
+    if _benchmark_study_v2_inventory(install_root) != dict(expected_overlay_inventory):
+        raise ValueError("v2 staged candidate changed during an attempt")
+    receipt_raw = _measurement_read_private_file(context.receipt_path)
+    receipt = _measurement_parse_canonical_json_bytes(receipt_raw, owner="v2 measurement receipt")
+    provider_terminal = str(receipt["terminal_status"])
+    raw = _measurement_read_private_raw(context.raw_path)
+    bounded_failure_usage = _benchmark_study_v2_bounded_failure_usage(
+        receipt=receipt, raw=raw, arm=str(slot["arm"]),
+        allowed_event_classes=tuple(
+            dict.fromkeys(
+                event for event, _command in spec.pair_registered_bindings
+            )
+        ),
+        required_event_classes=spec.required_event_classes,
+    )
+    checker_status = (
+        result.notes if provider_terminal == "success"
+        else BENCHMARK_STUDY_V2_BOUNDED_FAILURE_CHECKER_STATUS
+        if bounded_failure_usage is not None
+        else "not_run"
+    )
+    if provider_terminal == "success" and checker_status == "task_success":
+        classification = "success"
+    elif provider_terminal == "success" and checker_status == "valid_task_failure_v1":
+        classification = "valid_task_failure_v1"
+    elif bounded_failure_usage is not None:
+        classification = "valid_task_failure_v1"
+    else:
+        classification = "study_infra_invalid"
+    if post_overlay != pre.get("overlay"):
+        classification = "study_infra_invalid"
+    token_buckets = (
+        {
+            key: bounded_failure_usage[key]
+            for key in MEASUREMENT_STUDY_USAGE_KEYS
+        }
+        if bounded_failure_usage is not None
+        else {
+            "input_tokens": result.tokens["input_tokens"],
+            "cache_creation_input_tokens": result.tokens["cache_creation"],
+            "cache_read_input_tokens": result.tokens["cache_read"],
+            "output_tokens": result.tokens["output_tokens"],
+        }
+    )
+    append_study_attempt_event(
+        attempts_path,
+        _benchmark_study_v2_event(
+            slot, manifest_sha256, "terminal",
+            terminal_status=classification,
+            provider_terminal_status=provider_terminal,
+            checker_status=checker_status,
+            success=classification == "success",
+            token_buckets=token_buckets,
+            primary_tokens=sum(token_buckets.values()),
+            correction=None, retrieval=None, shifted_cost=None,
+            pre_workspace_inventory_sha256=pre["workspace"]["sha256"],
+            post_workspace_inventory_sha256=post_workspace["sha256"],
+            pre_overlay_inventory_sha256=pre["overlay"]["sha256"],
+            post_overlay_inventory_sha256=post_overlay["sha256"],
+            receipt_sha256=_study_sha256_bytes(receipt_raw),
+        ),
+    )
+    return classification
+
+
+def execute_benchmark_study_v2(
+    *, output_root: Path, claude_bin: str, resume: bool, auth_home: Path,
+) -> dict[str, int]:
+    with _benchmark_study_v2_action_lock(output_root):
+        return _execute_benchmark_study_v2_unlocked(
+            output_root=output_root, claude_bin=claude_bin, resume=resume,
+            auth_home=auth_home,
+        )
+
+
+def _execute_benchmark_study_v2_unlocked(
+    *, output_root: Path, claude_bin: str, resume: bool, auth_home: Path,
+) -> dict[str, int]:
+    output_root = _benchmark_study_v2_output_root(output_root)
+    # Revalidate every inert candidate byte and installed overlay before a provider launch.
+    manifest, manifest_sha256 = load_benchmark_study_v2_executable_manifest(
+        output_root, revalidate_external=True,
+    )
+    cli_stat_guard = _benchmark_study_v2_assert_cli_binding(
+        claude_bin, manifest["inputs"]["cli_binding"],
+    )
+    runtime_stat_guards = _benchmark_study_v2_assert_execution_environment(
+        manifest["inputs"]["execution_environment"]
+    )
+    bound_claude_bin = str(cli_stat_guard["executable"])
+    resolved_auth_home = _benchmark_study_v2_assert_auth_context(
+        bound_claude_bin, manifest["inputs"]["execution_environment"],
+        manifest["inputs"]["auth_context"], auth_home,
+    )
+    attempts_path = output_root / "attempts.jsonl"
+    if not resume and attempts_path.exists() and attempts_path.stat().st_size:
+        raise ValueError("v2 run requires an absent or empty attempt index")
+    if resume and not attempts_path.exists():
+        raise ValueError("v2 resume requires an existing attempt index")
+    _canary_evidence, _canary_evidence_sha256 = (
+        _benchmark_study_v2_verify_canary_evidence(
+            manifest=manifest, manifest_sha256=manifest_sha256,
+            output_root=output_root,
+        )
+    )
+    tasks = parse_tasks(Path(manifest["inputs"]["tasks_path"]))
+    load_task_fixture_trees(tasks, task_file_dir=Path(manifest["inputs"]["tasks_path"]).parent)
+    tasks_by_id = {task.id: task for task in tasks}
+    variants = _benchmark_study_v2_variants(manifest, output_root)
+    rows = _benchmark_study_v2_read_attempts(
+        attempts_path, manifest=manifest, manifest_sha256=manifest_sha256,
+    )
+    _benchmark_study_v2_revalidate_terminal_evidence(
+        manifest=manifest, output_root=output_root, rows=rows,
+        tasks_by_id=tasks_by_id, variants=variants,
+    )
+    launched = {
+        row["run_id"] for row in rows
+        if row["state"] in {"launch_reserved", "launched", "terminal"}
+    }
+    accounted = {row["run_id"] for row in rows}
+    terminal = {row["run_id"]: row for row in rows if row["state"] == "terminal"}
+    ambiguous_run_ids = sorted(launched - set(terminal))
+    if ambiguous_run_ids:
+        raise ValueError(
+            "v2 ambiguous provider process state permanently blocks this study root"
+        )
+    retry_by_unit = {
+        (slot["task_id"], slot["repetition"], slot["arm"]): slot
+        for slot in manifest["slots"] if slot["attempt"] == 1
+    }
+    install_root = Path(manifest["inputs"]["candidate_install_root"])
+    calls_before = len(launched)
+    for initial in (slot for slot in manifest["slots"] if slot["attempt"] == 0):
+        if initial["run_id"] not in launched:
+            _benchmark_study_v2_run_slot(
+                slot=initial, task=tasks_by_id[initial["task_id"]],
+                variant=variants[initial["arm"]], claude_bin=bound_claude_bin,
+                attempts_path=attempts_path, manifest_sha256=manifest_sha256,
+                install_root=install_root,
+                expected_overlay_inventory=manifest["inputs"]["candidate_overlay_inventory"],
+                cli_binding=manifest["inputs"]["cli_binding"],
+                cli_stat_guard=cli_stat_guard,
+                execution_environment=manifest["inputs"]["execution_environment"],
+                runtime_stat_guards=runtime_stat_guards,
+                checker_interpreter_binding=manifest["inputs"]["runner_binding"][
+                    "python"
+                ],
+                auth_context=manifest["inputs"]["auth_context"],
+                auth_home=resolved_auth_home,
+            )
+            launched.add(initial["run_id"])
+            terminal = {
+                row["run_id"]: row for row in _benchmark_study_v2_read_attempts(
+                    attempts_path, manifest=manifest, manifest_sha256=manifest_sha256,
+                ) if row["state"] == "terminal"
+            }
+        initial_row = terminal.get(initial["run_id"])
+        if initial_row is None:
+            continue
+        retry = retry_by_unit[(initial["task_id"], initial["repetition"], initial["arm"])]
+        if initial_row.get("terminal_status") != "valid_task_failure_v1":
+            state = (
+                "not_needed"
+                if initial_row.get("terminal_status") == "success"
+                else "blocked_study_invalid"
+            )
+            if retry["run_id"] not in accounted:
+                extra = {"reason": "initial_study_invalid"} if state == "blocked_study_invalid" else {}
+                append_study_attempt_event(
+                    attempts_path,
+                    _benchmark_study_v2_event(
+                        retry, manifest_sha256, state, **extra,
+                    ),
+                )
+                accounted.add(retry["run_id"])
+            if state == "blocked_study_invalid":
+                raise ValueError(
+                    "v2 terminal infrastructure-invalid evidence permanently "
+                    "blocks later provider launches"
+                )
+            continue
+        if retry["run_id"] in accounted:
+            continue
+        # A failed retry is retained, but it never stops later scheduled blocks.
+        _benchmark_study_v2_run_slot(
+            slot=retry, task=tasks_by_id[retry["task_id"]],
+            variant=variants[retry["arm"]], claude_bin=bound_claude_bin,
+            attempts_path=attempts_path, manifest_sha256=manifest_sha256,
+            install_root=install_root,
+            expected_overlay_inventory=manifest["inputs"]["candidate_overlay_inventory"],
+            cli_binding=manifest["inputs"]["cli_binding"],
+            cli_stat_guard=cli_stat_guard,
+            execution_environment=manifest["inputs"]["execution_environment"],
+            runtime_stat_guards=runtime_stat_guards,
+            checker_interpreter_binding=manifest["inputs"]["runner_binding"][
+                "python"
+            ],
+            auth_context=manifest["inputs"]["auth_context"],
+            auth_home=resolved_auth_home,
+        )
+        launched.add(retry["run_id"])
+        accounted.add(retry["run_id"])
+        terminal = {
+            row["run_id"]: row for row in _benchmark_study_v2_read_attempts(
+                attempts_path, manifest=manifest, manifest_sha256=manifest_sha256,
+            ) if row["state"] == "terminal"
+        }
+    final_rows = _benchmark_study_v2_read_attempts(
+        attempts_path, manifest=manifest, manifest_sha256=manifest_sha256,
+    )
+    final_states = {row["run_id"]: row["state"] for row in final_rows}
+    return {
+        "provider_process_calls": len(launched) - calls_before,
+        "launched_identities": len(launched),
+        "accounted_identities": len(final_states),
+    }
+
+
+def analyze_benchmark_study_v2_executable(
+    *, output_root: Path, claude_bin: str,
+) -> dict[str, Any]:
+    with _benchmark_study_v2_action_lock(output_root):
+        return _analyze_benchmark_study_v2_executable_unlocked(
+            output_root=output_root, claude_bin=claude_bin,
+        )
+
+
+def _benchmark_study_v2_persist_analysis(
+    *, output_root: Path, report: Mapping[str, Any],
+) -> str:
+    report_name = (
+        "study-invalid-decision.json"
+        if report.get("schema_version")
+        == BENCHMARK_STUDY_V2_INVALID_DECISION_SCHEMA_VERSION
+        else "study-report.json"
+    )
+    path = output_root / report_name
+    expected = _study_canonical_json_bytes(report)
+    if path.exists():
+        observed = _measurement_read_private_file(path, maximum=4_000_000)
+        if observed != expected:
+            raise ValueError("v2 persisted analysis binding mismatch")
+    else:
+        _measurement_write_exclusive(path, expected)
+    return report_name
+
+
+def _benchmark_study_v2_persist_invalid_after_refusal(
+    *, output_root: Path, claude_bin: str,
+) -> None:
+    try:
+        report = analyze_benchmark_study_v2_executable(
+            output_root=output_root, claude_bin=claude_bin,
+        )
+        if (
+            report.get("schema_version")
+            == BENCHMARK_STUDY_V2_INVALID_DECISION_SCHEMA_VERSION
+        ):
+            _benchmark_study_v2_persist_analysis(
+                output_root=output_root, report=report,
+            )
+    except (OSError, SystemExit, TypeError, ValueError):
+        # The original refusal remains authoritative when damaged or incomplete
+        # evidence cannot safely support a canonical P1-X decision.
+        print(
+            "v2 canonical P1-X unavailable after refusal",
+            file=sys.stderr,
+        )
+        return
+
+
+def _benchmark_study_v2_ledger_binding(
+    path: Path, *, maximum: int,
+) -> dict[str, Any]:
+    if not path.exists():
+        return {"bytes": 0, "record_count": 0, "sha256": None}
+    raw = _measurement_read_private_file(path, maximum=maximum)
+    return {
+        "bytes": len(raw), "record_count": len(raw.splitlines()),
+        "sha256": _study_sha256_bytes(raw),
+    }
+
+
+def _benchmark_study_v2_invalid_canary_decision(
+    *, output_root: Path, manifest: Mapping[str, Any],
+    manifest_sha256: str, rows: Sequence[Mapping[str, Any]],
+) -> dict[str, Any] | None:
+    final_by_arm = {str(row["arm"]): row for row in rows}
+    ambiguous = [
+        final_by_arm[arm] for arm in BENCHMARK_STUDY_V2_CANARY_ARMS
+        if arm in final_by_arm and final_by_arm[arm]["state"] != "terminal"
+    ]
+    failed = [
+        final_by_arm[arm] for arm in BENCHMARK_STUDY_V2_CANARY_ARMS
+        if arm in final_by_arm
+        and final_by_arm[arm]["state"] == "terminal"
+        and final_by_arm[arm]["passed"] is not True
+    ]
+    if not ambiguous and not failed:
+        return None
+    return {
+        "schema_version": BENCHMARK_STUDY_V2_INVALID_DECISION_SCHEMA_VERSION,
+        "study_version": "v2", "decision": "P1-X",
+        "stop_reason": (
+            "ambiguous_canary_process_state" if ambiguous
+            else "failed_canary_terminal_evidence"
+        ),
+        "manifest_sha256": manifest_sha256,
+        "attempt_schema_version": BENCHMARK_STUDY_V2_ATTEMPT_SCHEMA_VERSION,
+        "consumed_identity_count": len(final_by_arm),
+        "accounted_identity_count": sum(
+            row["state"] == "terminal" for row in final_by_arm.values()
+        ),
+        "ambiguous_identities": [{
+            "arm": row["arm"], "run_id": row["run_id"],
+            "state": row["state"],
+        } for row in ambiguous],
+        "failed_canary_identities": [{
+            "arm": row["arm"], "run_id": row["run_id"],
+            "state": row["state"],
+        } for row in failed],
+        "ledgers": {
+            "attempts": _benchmark_study_v2_ledger_binding(
+                output_root / "attempts.jsonl", maximum=4_000_000,
+            ),
+            "canary_events": _benchmark_study_v2_ledger_binding(
+                output_root / "canary-events.jsonl", maximum=200_000,
+            ),
+        },
+        "canary_evidence_sha256": None,
+        "descriptive_only": True, "claim_allowed": False, "claim": None,
+    }
+
+
+def _benchmark_study_v2_invalid_analytic_decision(
+    *, output_root: Path, manifest: Mapping[str, Any],
+    manifest_sha256: str, rows: Sequence[Mapping[str, Any]],
+    canary_evidence_sha256: str,
+) -> dict[str, Any] | None:
+    final_by_run = {str(row["run_id"]): row for row in rows}
+    ambiguous = [
+        final_by_run[str(slot["run_id"])]
+        for slot in manifest["slots"]
+        if str(slot["run_id"]) in final_by_run
+        and final_by_run[str(slot["run_id"])]["state"]
+        in {"launch_reserved", "launched"}
+    ]
+    failed = [
+        row for row in final_by_run.values()
+        if row["state"] == "terminal"
+        and row["terminal_status"] == "study_infra_invalid"
+    ]
+    if not ambiguous and not failed:
+        return None
+    attempts_path = output_root / "attempts.jsonl"
+    return {
+        "schema_version": BENCHMARK_STUDY_V2_INVALID_DECISION_SCHEMA_VERSION,
+        "study_version": "v2", "decision": "P1-X",
+        "stop_reason": (
+            "ambiguous_analytic_process_state" if ambiguous
+            else "terminal_analytic_infrastructure_invalid"
+        ),
+        "manifest_sha256": manifest_sha256,
+        "attempt_schema_version": BENCHMARK_STUDY_V2_ATTEMPT_SCHEMA_VERSION,
+        "consumed_identity_count": sum(
+            row["state"] in {"launch_reserved", "launched", "terminal"}
+            for row in final_by_run.values()
+        ),
+        "accounted_identity_count": len(final_by_run),
+        "ambiguous_identities": [{
+            "arm": row["arm"], "attempt": row["attempt"],
+            "repetition": row["repetition"], "run_id": row["run_id"],
+            "state": row["state"], "task_id": row["task_id"],
+        } for row in ambiguous],
+        "failed_analytic_identities": [{
+            "arm": row["arm"], "attempt": row["attempt"],
+            "repetition": row["repetition"], "run_id": row["run_id"],
+            "state": row["state"], "task_id": row["task_id"],
+            "terminal_status": row["terminal_status"],
+        } for row in failed],
+        "ledgers": {
+            "attempts": _benchmark_study_v2_ledger_binding(
+                attempts_path, maximum=4_000_000,
+            ),
+            "canary_events": _benchmark_study_v2_ledger_binding(
+                output_root / "canary-events.jsonl", maximum=200_000,
+            ),
+        },
+        "canary_evidence_sha256": canary_evidence_sha256,
+        "descriptive_only": True, "claim_allowed": False, "claim": None,
+    }
+
+
+def _analyze_benchmark_study_v2_executable_unlocked(
+    *, output_root: Path, claude_bin: str,
+) -> dict[str, Any]:
+    output_root = _benchmark_study_v2_output_root(output_root)
+    manifest, manifest_sha256 = load_benchmark_study_v2_executable_manifest(
+        output_root, revalidate_external=True,
+    )
+    _benchmark_study_v2_assert_cli_binding(
+        claude_bin, manifest["inputs"]["cli_binding"],
+    )
+    canary_variants = _benchmark_study_v2_canary_variants(manifest, output_root)
+    canary_rows = _benchmark_study_v2_read_canary_events(
+        output_root / "canary-events.jsonl",
+        manifest_sha256=manifest_sha256, variants=canary_variants,
+    )
+    invalid_canary_decision = _benchmark_study_v2_invalid_canary_decision(
+        output_root=output_root, manifest=manifest,
+        manifest_sha256=manifest_sha256, rows=canary_rows,
+    )
+    if invalid_canary_decision is not None:
+        return invalid_canary_decision
+    _canary_evidence, canary_evidence_sha256 = (
+        _benchmark_study_v2_verify_canary_evidence(
+            manifest=manifest, manifest_sha256=manifest_sha256,
+            output_root=output_root,
+        )
+    )
+    rows = _benchmark_study_v2_read_attempts(
+        output_root / "attempts.jsonl", manifest=manifest,
+        manifest_sha256=manifest_sha256,
+    )
+    tasks = parse_tasks(Path(manifest["inputs"]["tasks_path"]))
+    load_task_fixture_trees(
+        tasks, task_file_dir=Path(manifest["inputs"]["tasks_path"]).parent,
+    )
+    _benchmark_study_v2_revalidate_terminal_evidence(
+        manifest=manifest, output_root=output_root, rows=rows,
+        tasks_by_id={task.id: task for task in tasks},
+        variants=_benchmark_study_v2_variants(manifest, output_root),
+    )
+    invalid_decision = _benchmark_study_v2_invalid_analytic_decision(
+        output_root=output_root, manifest=manifest,
+        manifest_sha256=manifest_sha256, rows=rows,
+        canary_evidence_sha256=canary_evidence_sha256,
+    )
+    if invalid_decision is not None:
+        return invalid_decision
+    terminal_rows = [row for row in rows if row["state"] == "terminal"]
+    final_states = {row["run_id"]: row["state"] for row in rows}
+    if len(final_states) != 216 or any(
+        state not in {"terminal", "not_needed", "blocked_study_invalid"}
+        for state in final_states.values()
+    ):
+        raise ValueError("v2 analysis requires final accounting for all 216 identities")
+    identity_state_counts = dict(sorted(collections.Counter(final_states.values()).items()))
+    if any(
+        row["terminal_status"] not in {"success", "valid_task_failure_v1"}
+        for row in terminal_rows
+    ):
+        raise ValueError("v2 analysis refuses infrastructure-invalid or recovered attempts")
+    initial = [row for row in terminal_rows if row["attempt"] == 0]
+    if len(initial) != 108:
+        raise ValueError("v2 analysis requires all 108 initial provider calls")
+    by_unit = {(row["task_id"], row["repetition"], row["arm"]): row for row in initial}
+    expected_retries = {
+        key for key, row in by_unit.items()
+        if row["terminal_status"] == "valid_task_failure_v1"
+    }
+    retry_rows = [row for row in terminal_rows if row["attempt"] == 1]
+    if {(row["task_id"], row["repetition"], row["arm"]) for row in retry_rows} != expected_retries:
+        raise ValueError("v2 analysis retry coverage is incomplete or replaced")
+    effect_rows = [{
+        "task_id": row["task_id"], "repetition": row["repetition"],
+        "arm": row["arm"], "attempt": row["attempt"],
+        "terminal_status": row["terminal_status"], "success": row["success"],
+        "tokens": row["primary_tokens"], "correction": row["correction"],
+        "retrieval": row["retrieval"],
+    } for row in terminal_rows]
+    terminal_by_unit = dict(by_unit)
+    for row in retry_rows:
+        terminal_by_unit[(row["task_id"], row["repetition"], row["arm"])] = row
+    binary_rows = [
+        {"task_id": row["task_id"], "repetition": row["repetition"],
+         "arm": row["arm"], "success": row["success"]}
+        for row in terminal_by_unit.values()
+        if row["arm"] in BENCHMARK_STUDY_V2_PRIMARY_CONTRAST
+    ]
+    inference = infer_benchmark_study_v2_binary(
+        binary_rows, task_order=manifest["inputs"]["task_ids"],
+        ni_margin=float(manifest["plan"]["noninferiority_margin"]),
+    )
+    effects = compute_benchmark_study_v2_effects(
+        effect_rows, task_order=manifest["inputs"]["task_ids"],
+    )
+    unavailable = {"available": False, "value": None, "reason": "observer_absent"}
+    return {
+        "schema_version": BENCHMARK_STUDY_V2_REPORT_SCHEMA_VERSION,
+        "study_version": "v2", "decision": "P1-F",
+        "manifest_sha256": manifest_sha256,
+        "record_count": len(terminal_rows), "initial_provider_calls": 108,
+        "retry_provider_calls": len(retry_rows),
+        "discarded_canary_provider_calls": 2,
+        "identity_state_counts": identity_state_counts,
+        "binary_inference": inference, "effects": effects,
+        "observers": {
+            "correction": dict(unavailable), "retrieval": dict(unavailable),
+            "shifted_cost": dict(unavailable),
+        },
+        "descriptive_only": True, "claim_allowed": False, "claim": None,
+        "claim_readiness": {
+            "claim_ready": False, "descriptive_only": True,
+            "claim_allowed": False, "unmet_gates": ["power"],
+        },
+        "provenance": {
+            "source": "direct_cli_plus_bound_checker",
+            "success_source": "provider_terminal_usage_and_bound_checker",
+            "provider_success_boolean_trusted": False,
+            "cli_binding_sha256": _study_domain_hash(
+                "contextguard.bench.v2.cli-binding.v1",
+                manifest["inputs"]["cli_binding"],
+            ),
+            "auth_context_sha256": _study_domain_hash(
+                "contextguard.bench.v2.auth-context.v1",
+                manifest["inputs"]["auth_context"],
+            ),
+            "cli_version_stdout_sha256": manifest["inputs"]["cli_binding"][
+                "probe"
+            ]["version_stdout_sha256"],
+            "backend_revision": "unavailable",
+            "model_revision": "unavailable",
+            "canary_evidence_sha256": canary_evidence_sha256,
+            "canary_discarded_from_analysis": True,
+        },
+    }
+
+
+BENCHMARK_STUDY_V2_NAMESPACE = "contextguard.bench.v2"
+
+
+def _benchmark_study_v2_task_ids_from_corpus(corpus_bytes: bytes) -> list[str]:
+    try:
+        corpus = json.loads(corpus_bytes.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise ValueError("v2 task corpus is invalid JSON") from exc
+    if not isinstance(corpus, list):
+        raise ValueError("v2 task corpus is not a list")
+    return _benchmark_study_v2_task_ids([
+        row.get("id") if isinstance(row, Mapping) else None for row in corpus
+    ])
+
+
+def _benchmark_study_v2_task_ids_sha256(task_ids: Sequence[str]) -> str:
+    return _study_domain_hash(
+        BENCHMARK_STUDY_V2_CORPUS_TASK_ORDER_DOMAIN,
+        _benchmark_study_v2_task_ids(task_ids),
+    )
+
+
+def benchmark_study_v2_checker_binding(checkers_dir: Path) -> dict[str, Any]:
+    """Hash an ordered relative filename/size/content-digest checker inventory."""
+    directory_fd = _ensure_directory_no_symlink(checkers_dir, create=False)
+    try:
+        names = sorted(
+            entry.name for entry in checkers_dir.iterdir()
+            if entry.name.endswith(".py") and entry.is_file() and not entry.is_symlink()
+        )
+    finally:
+        os.close(directory_fd)
+    if len(names) != 12:
+        raise ValueError("v2 checker directory must contain exactly 12 regular Python files")
+    files = []
+    for name in names:
+        raw = _read_bytes_no_follow(
+            checkers_dir / name, max_bytes=MAX_FIXTURE_FILE_BYTES,
+        )
+        files.append({
+            "filename": name,
+            "size": len(raw),
+            "sha256": _study_sha256_bytes(raw),
+        })
+    binding = {
+        "domain": BENCHMARK_STUDY_V2_CHECKER_BINDING_DOMAIN,
+        "files": files,
+        "sha256": _study_domain_hash(
+            BENCHMARK_STUDY_V2_CHECKER_BINDING_DOMAIN, files,
+        ),
+    }
+    validate_benchmark_study_v2_checker_binding(binding)
+    return binding
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--tasks", default=None, type=Path, help="task fixture JSON")
+    parser.add_argument("--variants", default=None, type=Path, help="variant fixture JSON")
+    parser.add_argument("--csv", default=None, type=Path,
+                        help="results CSV path (header is added on first write)")
+    parser.add_argument("--task-id", default=None, help="run only the named task id")
+    parser.add_argument("--variant", default=None, help="run only the named variant")
+    parser.add_argument("--claude-bin", default=os.environ.get("CLAUDE_BIN", "claude"),
+                        help="claude CLI executable (default: $CLAUDE_BIN or 'claude')")
+    parser.add_argument("--project-root", default=Path("."), type=Path,
+                        help="working directory used for success_command (default: cwd)")
+    parser.add_argument("--dry-run", action="store_true",
+                        help="print the claude command without invoking it")
+    parser.add_argument("--resume", action="store_true",
+                        help="skip (task_id, variant) rows already present in --csv")
+    parser.add_argument("--ledger-jsonl", default=None, type=Path,
+                        help="optional JSONL ledger path for cost-shift accounting per run")
+    parser.add_argument("--report-json", default=None, type=Path,
+                        help="optional A/B summary report JSON path generated from --csv after real runs")
+    parser.add_argument("--dashboard-md", default=None, type=Path,
+                        help="optional Markdown dashboard path generated from the benchmark report")
+    parser.add_argument("--evidence-jsonl", default=None, type=Path,
+                        help="optional validated run-evidence JSONL replay input; skips provider invocation")
+    parser.add_argument("--baseline-variant", default="baseline",
+                        help="variant name used as the report baseline (default: baseline)")
+    parser.add_argument("--measurement-study-plan", default=None, type=Path,
+                        help="exact S002 measurement study plan JSON")
+    parser.add_argument(
+        "--measurement-study-action",
+        default=None,
+        choices=("prepare", "run", "resume", "analyze"),
+        help="S002 measurement study action",
+    )
+    parser.add_argument("--measurement-study-output-root", default=None, type=Path,
+                        help="private S002 measurement study artifact directory")
+    parser.add_argument(
+        "--study-v2-action", default=None,
+        choices=("prepare", "canary", "run", "resume", "analyze"),
+        help="prepare, canary, run, resume, or analyze the executable additive v2 study",
+    )
+    parser.add_argument("--study-v2-plan", default=None, type=Path,
+                        help="canonical v2 study plan used only by --study-v2-action prepare")
+    parser.add_argument("--study-v2-tasks", default=None, type=Path,
+                        help="frozen v2 task corpus used only by --study-v2-action prepare")
+    parser.add_argument("--study-v2-checkers-dir", default=None, type=Path,
+                        help="frozen v2 checker directory used only by --study-v2-action prepare")
+    parser.add_argument("--study-v2-candidate-hash", default=None,
+                        help="exact candidate SHA-256 used only by --study-v2-action prepare")
+    parser.add_argument("--study-v2-source-commit", default=None,
+                        help="approved 40-hex source commit used only by --study-v2-action prepare")
+    parser.add_argument("--study-v2-retained-ref", default=None,
+                        help="retained candidate ref resolved during live v2 prepare")
+    parser.add_argument(
+        "--study-v2-offline-rehearsal", action="store_true",
+        help="mark provider-free fake-host rehearsal; never use for live prepare",
+    )
+    parser.add_argument("--study-v2-output-root", default=None, type=Path,
+                        help="private executable v2 lifecycle directory")
+    parser.add_argument("--study-v2-candidate-manifest", default=None, type=Path,
+                        help="canonical build-once npm candidate manifest used by v2 prepare")
+    parser.add_argument("--study-v2-candidate-checksums", default=None, type=Path,
+                        help="exact candidate checksum document (default: manifest sibling)")
+    parser.add_argument("--study-v2-npm-bin", default="npm",
+                        help="npm executable used once for the offline candidate install")
+    parser.add_argument(
+        "--study-v2-use-existing-login", action="store_true",
+        help=(
+            "allow executable v2 provider actions to reuse the exact CLI's "
+            "existing first-party login without importing credential environment variables"
+        ),
+    )
+    args = parser.parse_args(argv)
+
+    require_no_follow_file_ops_supported()
+    v2_values = (
+        args.study_v2_action, args.study_v2_plan, args.study_v2_tasks,
+        args.study_v2_checkers_dir, args.study_v2_candidate_hash,
+        args.study_v2_source_commit, args.study_v2_retained_ref,
+        args.study_v2_output_root, args.study_v2_candidate_manifest,
+        args.study_v2_candidate_checksums,
+    )
+    if args.study_v2_use_existing_login and args.study_v2_action is None:
+        parser.error("--study-v2-use-existing-login requires --study-v2-action")
+    if args.study_v2_offline_rehearsal and args.study_v2_action is None:
+        parser.error("--study-v2-offline-rehearsal requires --study-v2-action prepare")
+    if any(value is not None for value in v2_values):
+        if args.study_v2_action is None:
+            parser.error("--study-v2-action is required when any --study-v2-* option is used")
+        conflicts = [
+            name for name, active in (
+                ("--tasks", args.tasks is not None), ("--variants", args.variants is not None),
+                ("--csv", args.csv is not None), ("--task-id", args.task_id is not None),
+                ("--variant", args.variant is not None), ("--dry-run", args.dry_run),
+                ("--resume", args.resume), ("--ledger-jsonl", args.ledger_jsonl is not None),
+                ("--report-json", args.report_json is not None),
+                ("--dashboard-md", args.dashboard_md is not None),
+                ("--evidence-jsonl", args.evidence_jsonl is not None),
+                ("--measurement-study-plan", args.measurement_study_plan is not None),
+                ("--measurement-study-action", args.measurement_study_action is not None),
+                ("--measurement-study-output-root", args.measurement_study_output_root is not None),
+            ) if active
+        ]
+        if conflicts:
+            parser.error(f"v2 executable mode conflicts with {', '.join(conflicts)}")
+        if args.study_v2_output_root is None:
+            parser.error("v2 executable actions require --study-v2-output-root")
+        if (
+            args.study_v2_action != "analyze"
+            and not args.study_v2_use_existing_login
+        ):
+            parser.error(
+                "v2 prepare/canary/run/resume requires "
+                "--study-v2-use-existing-login"
+            )
+        auth_home = Path(os.environ.get("HOME", ""))
+        if args.study_v2_action == "prepare":
+            required = (
+                args.study_v2_plan, args.study_v2_tasks, args.study_v2_checkers_dir,
+                args.study_v2_candidate_hash, args.study_v2_source_commit,
+                args.study_v2_candidate_manifest,
+            )
+            forbidden = ()
+            if args.study_v2_offline_rehearsal:
+                if args.study_v2_retained_ref is not None:
+                    parser.error(
+                        "v2 offline rehearsal conflicts with --study-v2-retained-ref"
+                    )
+            elif args.study_v2_retained_ref is None:
+                parser.error("v2 live prepare requires --study-v2-retained-ref")
+        else:
+            required = (args.study_v2_output_root,)
+            forbidden = (
+                args.study_v2_plan, args.study_v2_tasks, args.study_v2_checkers_dir,
+                args.study_v2_candidate_hash, args.study_v2_source_commit,
+                args.study_v2_retained_ref, args.study_v2_candidate_manifest,
+                args.study_v2_candidate_checksums,
+            )
+            if args.study_v2_offline_rehearsal:
+                parser.error("--study-v2-offline-rehearsal is prepare-only")
+        if not all(value is not None for value in required) or any(value is not None for value in forbidden):
+            parser.error("v2 executable action has incomplete or conflicting arguments")
+        try:
+            if args.study_v2_action == "prepare":
+                prepare_benchmark_study_v2_executable(
+                    output_root=args.study_v2_output_root,
+                    plan_path=args.study_v2_plan, tasks_path=args.study_v2_tasks,
+                    checkers_dir=args.study_v2_checkers_dir,
+                    candidate_manifest_path=args.study_v2_candidate_manifest,
+                    candidate_checksum_path=args.study_v2_candidate_checksums,
+                    expected_candidate_hash=args.study_v2_candidate_hash,
+                    npm_bin=args.study_v2_npm_bin,
+                    claude_bin=args.claude_bin,
+                    auth_home=auth_home,
+                    approved_source_commit=args.study_v2_source_commit,
+                    retained_ref=args.study_v2_retained_ref,
+                    offline_rehearsal=args.study_v2_offline_rehearsal,
+                )
+                print(f"prepared executable v2 study: {args.study_v2_output_root}")
+            elif args.study_v2_action == "canary":
+                summary = execute_benchmark_study_v2_canary(
+                    output_root=args.study_v2_output_root,
+                    claude_bin=args.claude_bin,
+                    auth_home=auth_home,
+                )
+                print(json.dumps(summary, sort_keys=True, separators=(",", ":")))
+            elif args.study_v2_action in {"run", "resume"}:
+                summary = execute_benchmark_study_v2(
+                    output_root=args.study_v2_output_root,
+                    claude_bin=args.claude_bin,
+                    resume=args.study_v2_action == "resume",
+                    auth_home=auth_home,
+                )
+                print(json.dumps(summary, sort_keys=True, separators=(",", ":")))
+            else:
+                report = analyze_benchmark_study_v2_executable(
+                    output_root=args.study_v2_output_root,
+                    claude_bin=args.claude_bin,
+                )
+                report_name = _benchmark_study_v2_persist_analysis(
+                    output_root=args.study_v2_output_root, report=report,
+                )
+                print(
+                    "analyzed executable v2 study: "
+                    f"{args.study_v2_output_root / report_name}"
+                )
+                if report_name == "study-invalid-decision.json":
+                    return 3
+            return 0
+        except (OSError, SystemExit, TypeError, ValueError) as exc:
+            if args.study_v2_action in {"canary", "run", "resume"}:
+                _benchmark_study_v2_persist_invalid_after_refusal(
+                    output_root=args.study_v2_output_root,
+                    claude_bin=args.claude_bin,
+                )
+            print(f"v2 executable study refused: {exc}", file=sys.stderr)
+            return 2
+    if args.tasks is None or args.variants is None:
+        parser.error("--tasks and --variants are required outside study modes")
+    study_values = (
+        args.measurement_study_plan,
+        args.measurement_study_action,
+        args.measurement_study_output_root,
+    )
+    if any(value is not None for value in study_values):
+        if not all(value is not None for value in study_values):
+            parser.error(
+                "--measurement-study-plan, --measurement-study-action, and "
+                "--measurement-study-output-root are all-or-none"
+            )
+        conflicts = [
+            name for name, active in (
+                ("--task-id", args.task_id is not None),
+                ("--variant", args.variant is not None),
+                ("--resume", args.resume),
+                ("--evidence-jsonl", args.evidence_jsonl is not None),
+                ("--dry-run", args.dry_run),
+                ("--ledger-jsonl", args.ledger_jsonl is not None),
+                ("--report-json", args.report_json is not None),
+                ("--dashboard-md", args.dashboard_md is not None),
+                ("--csv", args.csv is not None),
+                ("--baseline-variant", args.baseline_variant != "baseline"),
+            ) if active
+        ]
+        if conflicts:
+            parser.error(f"measurement study mode conflicts with {', '.join(conflicts)}")
+        return run_measurement_study_action(args)
+    args.csv = args.csv or Path("bench/results.csv")
+    validate_distinct_output_paths(args.csv, args.ledger_jsonl, args.report_json, args.dashboard_md)
+
+    variants = parse_variants(args.variants)
+    tasks = parse_tasks(args.tasks, variants=variants)
+    targets = filter_targets(tasks, variants, args.task_id, args.variant)
+    if not targets:
+        if args.dry_run and (not tasks or not variants):
+            print("completed 0 run(s) (dry-run; no CSV writes)")
+            return 0
+        print("no (task, variant) targets matched the filters", file=sys.stderr)
+        return 1
+    target_task_ids = {task.id for task, _variant in targets}
+    load_task_fixture_trees(
+        [task for task in tasks if task.id in target_task_ids],
+        task_file_dir=args.tasks.parent,
+    )
     preflight_measurement_targets(
         targets,
         claude_bin=args.claude_bin,