Sync ctx a3fcda3 (part 2)

GitHub commit: a3fcda3b083d6c607f1b4e1a818fc77f9ea2ce50

qa/feature_status.csv

@@ -1,6 +1,6 @@
 feature_id,parent_feature_id,source_tracker,surface,feature,entrypoint_or_route,source_evidence,risk_level,user_story,expected_behavior,setup_preconditions,test_command_or_steps,verification_mode,status,evidence,bug_id,bug_summary,bug_repro,fix_status,retest_evidence,last_verified_at,owner_lane,notes,review_status,review_notes,fix_strategy,validation_status
 MAINT-015,,expert-lane/telemetry-release-governance,Maintainer,No-mistakes Codex launcher,scripts/no_mistakes_codex_env.sh,scripts/no_mistakes_codex_env.sh; src/tests/test_no_mistakes_env.py,High,As a maintainer I can run no-mistakes after the desktop app name or installation path changes,Launcher preserves the trusted project Python environment resolves explicit executable and resource known-app and PATH candidates and validates both explicit overrides independently,POSIX shell and an installed Codex executable,.venv/bin/python -m pytest -q --no-cov src/tests/test_no_mistakes_env.py,Automated Test,Needs Validation,PASS FOCUSED: commit 2f8393f6 validates both explicit overrides independently; 15 focused tests pass and the real launcher resolves codex-cli 0.145.0-alpha.18.,AUDIT-072,The combined explicit executable and missing resource override previously bypassed resource validation.,Set a runnable explicit executable and a missing explicit resource directory then run the wrapper.,Fixed,PASS FOCUSED: the invalid resource override is rejected independently and all launcher discovery regressions pass; final real no-mistakes integration is pending.,2026-07-20,QA/Test Gate Lane,POSIX wrapper tests are intentionally skipped on native Windows while GitHub validates the surrounding CI contract.,Approved locally pending integration gate,Focused regression and real launcher execution prove the fix; the final branch-wide no-mistakes run remains the integration proof.,Ponytail: validate both nonempty explicit overrides before discovery and retain the combined-boundary regression.,Pending the final real no-mistakes run after all benchmark work is committed
-"MAINT-016","","docs/qa/feature-user-story-status.csv","Maintainer","Adaptive ctx development benchmark","scripts/ctx_ab_benchmark.py","scripts/ctx_ab_benchmark.py; scripts/ctx_ab_exposure_ledger.py; scripts/ctx_ab_holdout.py; scripts/ctx_ab_holdout_acquire.py; scripts/ctx_ab_holdout_freeze.py; scripts/ctx_ab_holdout_materialize.py; scripts/ctx_ab_holdout_prepare.py; scripts/ctx_ab_swebench.py; benchmarks/ctx_ab/holdout-protocol-v1.json; benchmarks/ctx_ab/scenarios.yaml; src/tests/test_ctx_ab_benchmark.py; src/tests/test_ctx_ab_exposure_ledger.py; src/tests/test_ctx_ab_holdout_freeze.py; src/tests/test_ctx_ab_holdout_materialize.py; src/tests/test_ctx_ab_holdout_prepare.py; src/tests/test_ctx_ab_holdout_protocol.py; src/tests/test_ctx_ab_holdout_selection.py; src/tests/test_ctx_ab_swebench.py; qa/ctx_benchmark_status.csv","High","As a product owner I can compare the same feature development task with and without production CTX using reproducible quality, token, development-time, lifecycle, failure, and uncertainty evidence.","The confirmatory runner assigns ten hidden tasks from ten repositories to identical baseline and CTX arms, authenticates a frozen 30-pair schedule, evaluates both patches with the same blinded official SWE-bench Docker verifier, records exact provider usage and truthful CTX recommendation/load/use/unload evidence, and publishes no benefit claim unless every quality and evidence gate passes.","macOS Codex authentication, Python 3.12 environment, pinned official SWE-bench runtime and images, cached repositories, execution-frozen owner-only scenarios, and a clean committed head.","Run focused benchmark and holdout tests, authenticate the complete historical exposure inventory, materialize all ten official red/reference controls, freeze V2 before any selected task reaches CTX or a model, execute three paired repetitions per task sequentially with retries disabled, then inspect incidents, hidden evaluator results, exact usage, development time, lifecycle, and repository-clustered effects.","Automated Test plus Blinded Evaluation","Needs Validation","CURRENT CANDIDATE: framework PR #253 merged as 0e9289e4 after all required checks passed, including native Windows 3.12. The exact combined V2 suite passed 505/505 on framework code HEAD 547b80a5; exact-head preflight passed 19/19 on 78a003ac with 6,163 unit tests. Independent runtime, methodology, and CI reviewers returned MERGE. A fresh clean merged-main worktree, isolated Python 3.12.13 environment, and pinned Docker daemon pass dependency and amd64/arm64 conformance. Official evidence remains 0/10 controls, 0/30 pairs, and 0/60 arms.","BENCH-007; BENCH-008; BENCH-010; BENCH-011; BENCH-014; BENCH-021; BENCH-031; BENCH-032; BENCH-033; BENCH-034; BENCH-035; BENCH-036; BENCH-037; BENCH-038; BENCH-039; BENCH-040; BENCH-041; BENCH-042","The authenticated framework, native platform proof, merge, and local runtime conformance are complete; the complete historical exposure inventory, ten controls, 30 paired runs, failure classification, and honest product verdict remain open.","Authenticate every known historical exposure source, then execute all ten controls and 30 pairs sequentially from the clean merged-main worktree, classify every failure, and retain a valid not_beneficial verdict as final.","Framework integration, authenticated snapshots, historical-exposure rejection, source-closure enforcement, one-shot execution, merged-main identity, platform temporary-path rejection, authoritative verdict gates, task-disjoint-or-no-go generation, native Windows CI, and Docker/Python conformance are fixed; production execution remains pending.","CURRENT CANDIDATE 0e9289e4: merged-main identity is clean; required CI and native Windows passed; Python 3.12.13 and Docker amd64/arm64 conformance passed. Production execution remains 0/10 controls, 0/30 pairs, and 0/60 arms.","2026-07-30","QA/Test Gate Lane","Framework evidence proves mechanics and trust boundaries only; it does not prove CTX benefit. The confirmatory result is an intent-to-treat estimate and may honestly be not_beneficial. Any outcome-informed later study requires task-disjoint tasks and may require a new pinned universe.","Methodology, security, runtime-state, source-closure, exposure-ledger, and CI-policy scopes are approved; exposure inventory completeness and live product evidence remain pending.","Do not interpret green framework tests as product benefit. BENCH-034 and BENCH-035 remain open until the official controls and campaign finish; a valid not_beneficial result is final.","Ponytail: retain one evaluator and one frozen paired design; fix only reproduced harness or CTX defects, and require task-disjoint selection or a new pinned universe after outcome-informed changes.","Pending complete exposure inventory, ten controls, 30 pairs, 60 arms, independent result review, and publication of the honest verdict."
+"MAINT-016","","docs/qa/feature-user-story-status.csv","Maintainer","Adaptive ctx development benchmark","scripts/ctx_ab_benchmark.py","scripts/ctx_ab_benchmark.py; scripts/ctx_ab_exposure_ledger.py; scripts/ctx_ab_failure_evidence.py; scripts/ctx_ab_holdout.py; scripts/ctx_ab_holdout_acquire.py; scripts/ctx_ab_holdout_freeze.py; scripts/ctx_ab_holdout_materialize.py; scripts/ctx_ab_holdout_prepare.py; scripts/ctx_ab_swebench.py; benchmarks/ctx_ab/holdout-protocol-v1.json; benchmarks/ctx_ab/scenarios.yaml; src/tests/test_ctx_ab_benchmark.py; src/tests/test_ctx_ab_exposure_ledger.py; src/tests/test_ctx_ab_failure_evidence.py; src/tests/test_ctx_ab_holdout_freeze.py; src/tests/test_ctx_ab_holdout_materialize.py; src/tests/test_ctx_ab_holdout_prepare.py; src/tests/test_ctx_ab_holdout_protocol.py; src/tests/test_ctx_ab_holdout_selection.py; src/tests/test_ctx_ab_swebench.py; qa/ctx_benchmark_status.csv","High","As a product owner I can compare the same feature development task with and without production CTX using reproducible quality, token, development-time, lifecycle, failure, and uncertainty evidence.","The confirmatory runner assigns ten hidden tasks from ten repositories to identical baseline and CTX arms, authenticates a frozen 30-pair schedule, evaluates both patches with the same blinded official SWE-bench Docker verifier, records exact provider usage and truthful CTX recommendation/load/use/unload evidence, and publishes no benefit claim unless every quality and evidence gate passes.","macOS Codex authentication, Python 3.12 environment, pinned official SWE-bench runtime and images, cached repositories, execution-frozen owner-only scenarios, and a clean committed head.","Run focused benchmark and holdout tests, authenticate the complete historical exposure inventory, materialize all ten official red/reference controls, freeze V2 before any selected task reaches CTX or a model, execute three paired repetitions per task sequentially with retries disabled, then inspect incidents, hidden evaluator results, exact usage, development time, lifecycle, and repository-clustered effects.","Automated Test plus Blinded Evaluation","Needs Validation","CURRENT CANDIDATE: framework PR #253 merged as 0e9289e4 after all required checks passed, including native Windows 3.12. The exact combined V2 suite passed 505/505 on framework code HEAD 547b80a5; exact-head preflight passed 19/19 on 78a003ac with 6,163 unit tests. Independent runtime, methodology, and CI reviewers returned MERGE. A fresh clean merged-main worktree, isolated Python 3.12.13 environment, and pinned Docker daemon pass dependency and amd64/arm64 conformance. Official evidence remains 0/10 controls, 0/30 pairs, and 0/60 arms.","BENCH-007; BENCH-008; BENCH-010; BENCH-011; BENCH-014; BENCH-021; BENCH-031; BENCH-032; BENCH-033; BENCH-034; BENCH-035; BENCH-036; BENCH-037; BENCH-038; BENCH-039; BENCH-040; BENCH-041; BENCH-042","The authenticated framework, native platform proof, merge, and local runtime conformance are complete; the complete historical exposure inventory, ten controls, 30 paired runs, failure classification, and honest product verdict remain open.","Authenticate every known historical exposure source, then execute all ten controls and 30 pairs sequentially from the clean merged-main worktree, classify every failure, and retain a valid not_beneficial verdict as final.","Framework integration, authenticated snapshots, historical-exposure rejection, source-closure enforcement, one-shot execution, merged-main identity, platform temporary-path rejection, authoritative verdict gates, task-disjoint-or-no-go generation, native Windows CI, and Docker/Python conformance are fixed; production execution remains pending.","CURRENT CANDIDATE 0e9289e4: merged-main identity is clean; required CI and native Windows passed; Python 3.12.13 and Docker amd64/arm64 conformance passed. Production execution remains 0/10 controls, 0/30 pairs, and 0/60 arms.","2026-07-30","QA/Test Gate Lane","Framework evidence proves mechanics and trust boundaries only; it does not prove CTX benefit. The confirmatory result is an intent-to-treat estimate and may honestly be not_beneficial. Any outcome-informed later study requires task-disjoint tasks and may require a new pinned universe.","Methodology, security, runtime-state, source-closure, exposure-ledger, and CI-policy scopes are approved; exposure inventory completeness and live product evidence remain pending.","Do not interpret green framework tests as product benefit. BENCH-034 and BENCH-035 remain open until the official controls and campaign finish; a valid not_beneficial result is final.","Ponytail: retain one evaluator and one frozen paired design; fix only reproduced harness or CTX defects, and require task-disjoint selection or a new pinned universe after outcome-informed changes.","Pending complete exposure inventory, ten controls, 30 pairs, 60 arms, independent result review, and publication of the honest verdict."
 CLI-001,,docs/qa/feature-user-story-status.csv,CLI,Generic model run harness,ctx; python -m ctx,pyproject.toml project.scripts and src/ctx/__main__.py,High,As a user I can run or resume a model-agnostic ctx session,ctx and python -m ctx expose the same run/resume/sessions harness with configured provider tools secret-safe MCP attachment token budgets transcript ordering privacy-safe failure telemetry and persisted initial trace metadata,Provider credentials or dry-run/local test provider available,ctx --help; python -m ctx --help; focused run/resume smoke,Automated Test,Retested Pass,PASS: test_harness_cli_run.py focused suite reports 73 passed; test_package_scaffold.py covers python -m ctx --help.,AUDIT-018,Early ctx run/resume failures could exit without complete telemetry or trace correlation.,Trigger ctx run/resume early failure paths and inspect telemetry/session metadata.,Fixed,PASS: .venv/bin/pytest src/tests/test_harness_cli_run.py -q --tb=short -> 73 passed.,2026-07-05,CLI Lane,Updated for CLI failure telemetry trace metadata and inline MCP secret rejection.,Reviewed by no-mistakes,no-mistakes run 01KWSCY4EF01EXWSHYB5SGS4BC reached passed after review/test/document/lint/CI; post-merge stats cleanup PR #239 also passed.,Ponytail: telemetry-only hardening plus inline MCP secret rejection; no CLI behavior expansion.,Validated by focused regressions and no-mistakes run 01KWSCY4EF01EXWSHYB5SGS4BC on PR #238; PR merged as 90babdd and post-merge inventory cleanup merged as PR #239.
 CLI-002,,docs/qa/feature-user-story-status.csv,CLI,Repository recommendation,ctx-recommend,pyproject.toml project.scripts,Medium,As a user I can ask ctx for current repo recommendations,ctx returns capped relevant skill agent MCP recommendations from the shared graph engine,Graph installed and target repo available,ctx-recommend --help then sample repo recommendation,Automated Test,Tested Pass,recommend CLI/golden subset: 24 passed for ctx-recommend and shared recommendation surfaces.,,,,,,2026-06-23,CLI Lane,Validated in focused pytest or isolated temp CLI smoke during A-Z pass.,Reviewed by no-mistakes,Historical tracker import; current canonical row is covered by completed goal-loop review and no-mistakes gate.,Ponytail: no fix needed unless retest produces a concrete regression.,Validated by completed goal-loop and no-mistakes gate
 CLI-003,,docs/qa/feature-user-story-status.csv,CLI,Initial setup,ctx-init,pyproject.toml project.scripts,Medium,As a new user I can install hooks graph and model mode from one command,ctx-init installs requested pieces idempotently and reports failures with non-zero exit,Writable user config directory,ctx-init --model-mode skip --graph,CLI Smoke,Retested Pass,"PASS: final wheel 1b435d9b installs the runtime graph and actionable pack in a fresh home; independent clean-install and descriptor-pinned filesystem reviews pass.",AUDIT-087; AUDIT-088,"The previous clean-install path could delete unrelated converted wiki content, accept a symlinked ancestor, and expose too little actionable skill, agent, and MCP context.",Install the real runtime archive or wheel into a temporary home containing a private converted skill and a symlinked .claude ancestor; run ctx-init repeatedly and inspect recommendations and install paths.,"Fixed in commits 3b50bfd6, 9dec65c7, and 09d157a1.","PASS: final archive and wheel clean installs, preservation, containment, idempotence, and skill, agent, and MCP actionability smokes pass.",2026-07-27,CLI Lane,The final wheel was imported from its installed site-packages path outside the repository.,Approved by independent clean-install and filesystem reviewers,"No P0-P3 remains in the clean-home, path containment, or artifact actionability boundary.","Preserve user-owned wiki content, reject unsafe ancestors, and ship an attested project-owned context pack.","Validated by independent reviews and final wheel 1b435d9b A-Z smoke"

scripts/ctx_ab_failure_evidence.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Atomically preserve owner-only private evidence for CTX A/B failures."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import stat
+import tempfile
+import traceback
+from typing import Any
+
+
+FAILURE_GUARD = "ctx-ab-private-failure-v1"
+FAILURE_MANIFEST = "artifact-manifest.json"
+
+
+class FailureEvidenceError(RuntimeError):
+    """Private failure evidence could not be published safely."""
+
+
+def _canonical_bytes(value: Any) -> bytes:
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
+
+
+def _sha256(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def _private_write(path: Path, data: bytes) -> None:
+    descriptor = os.open(
+        path,
+        os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0),
+        0o600,
+    )
+    with os.fdopen(descriptor, "wb") as handle:
+        handle.write(data)
+
+
+def _exception_chain(exc: BaseException) -> list[dict[str, str]]:
+    chain: list[dict[str, str]] = []
+    current: BaseException | None = exc
+    seen: set[int] = set()
+    while current is not None and id(current) not in seen:
+        seen.add(id(current))
+        chain.append({"message": str(current), "type": type(current).__name__})
+        current = current.__cause__ or (
+            None if current.__suppress_context__ else current.__context__
+        )
+    return chain
+
+
+def _harden_private_tree(root: Path) -> None:
+    os.chmod(root, 0o700)
+    for path in root.rglob("*"):
+        metadata = path.lstat()
+        if stat.S_ISLNK(metadata.st_mode):
+            continue
+        if stat.S_ISDIR(metadata.st_mode):
+            os.chmod(path, 0o700)
+        elif stat.S_ISREG(metadata.st_mode):
+            os.chmod(path, 0o700 if metadata.st_mode & 0o111 else 0o600)
+        else:
+            raise FailureEvidenceError("private failure evidence contains a special file")
+
+
+def _artifact_manifest(root: Path) -> dict[str, Any]:
+    entries: list[dict[str, Any]] = []
+    for path in sorted(root.rglob("*"), key=lambda item: item.relative_to(root).as_posix()):
+        relative = path.relative_to(root).as_posix()
+        if relative == FAILURE_MANIFEST:
+            continue
+        metadata = path.lstat()
+        record: dict[str, Any] = {
+            "mode": stat.S_IMODE(metadata.st_mode),
+            "path": relative,
+        }
+        if stat.S_ISDIR(metadata.st_mode):
+            record["type"] = "directory"
+        elif stat.S_ISREG(metadata.st_mode):
+            data = path.read_bytes()
+            record.update(
+                {
+                    "bytes": len(data),
+                    "sha256": _sha256(data),
+                    "type": "file",
+                }
+            )
+        elif stat.S_ISLNK(metadata.st_mode):
+            record.update(
+                {
+                    "sha256": _sha256(os.fsencode(os.readlink(path))),
+                    "type": "symlink",
+                }
+            )
+        else:
+            raise FailureEvidenceError("private failure evidence contains a special file")
+        entries.append(record)
+    return {
+        "entries": entries,
+        "entry_count": len(entries),
+        "guard": FAILURE_GUARD,
+        "manifest_sha256": _sha256(_canonical_bytes(entries)),
+        "schema_version": 1,
+    }
+
+
+def validate_destination(destination: Path, *, repository_root: Path) -> None:
+    if not destination.is_absolute():
+        raise FailureEvidenceError("failure evidence destination must be absolute")
+    resolved = destination.resolve(strict=False)
+    private_root = (repository_root / ".gate" / "ctx-ab-private").resolve()
+    if repository_root.resolve() in resolved.parents and private_root not in resolved.parents:
+        raise FailureEvidenceError(
+            "failure evidence inside the repository must use the private root"
+        )
+    destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    if destination.exists() or destination.is_symlink():
+        raise FailureEvidenceError("failure evidence destination already exists")
+
+
+def publish_failure(
+    *,
+    destination: Path,
+    operation: str,
+    exc: BaseException,
+    repository_root: Path,
+    staging: Path | None = None,
+) -> dict[str, Any]:
+    """Publish a private immutable exception bundle, optionally with staged raw evidence."""
+
+    validate_destination(destination, repository_root=repository_root)
+    owns_staging = staging is None
+    if staging is None:
+        staging = Path(tempfile.mkdtemp(prefix=".ctx-ab-failure-", dir=destination.parent))
+        os.chmod(staging, 0o700)
+    elif staging.is_symlink() or not staging.is_dir():
+        raise FailureEvidenceError("failure evidence staging root is unsafe")
+
+    failure = {
+        "exception_chain": _exception_chain(exc),
+        "guard": FAILURE_GUARD,
+        "operation": operation,
+        "schema_version": 1,
+        "traceback": "".join(traceback.format_exception(exc)),
+    }
+    try:
+        _harden_private_tree(staging)
+        _private_write(staging / "failure.json", _canonical_bytes(failure))
+        manifest = _artifact_manifest(staging)
+        _private_write(staging / FAILURE_MANIFEST, _canonical_bytes(manifest))
+        staging.rename(destination)
+    except BaseException:
+        # Never delete a partially captured failure. A hidden owner-only staging
+        # directory is safer than destroying the only root-cause evidence.
+        if owns_staging and staging.exists():
+            os.chmod(staging, 0o700)
+        raise
+    return manifest
+
+
+def already_preserved(destination: Path) -> bool:
+    return (
+        destination.is_dir()
+        and not destination.is_symlink()
+        and (destination / "failure.json").is_file()
+        and (destination / FAILURE_MANIFEST).is_file()
+    )

scripts/ctx_ab_holdout_freeze.py

@@ -21,6 +21,7 @@ from typing import Any
 
 from scripts import ctx_ab_benchmark as benchmark
 from scripts import ctx_ab_exposure_ledger as exposure_ledger
+from scripts import ctx_ab_failure_evidence as failure_evidence
 from scripts import ctx_ab_holdout as holdout
 
 
@@ -1520,6 +1521,7 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--environment", type=Path, required=True)
     parser.add_argument("--schedule", type=Path, required=True)
     parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--failure-evidence-output", type=Path, required=True)
     parser.add_argument(
         "--expected-acquisition-protocol-sha256",
         required=True,
@@ -1529,6 +1531,13 @@ def main(argv: list[str] | None = None) -> int:
         default=datetime.now(UTC).isoformat().replace("+00:00", "Z"),
     )
     args = parser.parse_args(argv)
+    try:
+        failure_evidence.validate_destination(
+            args.failure_evidence_output,
+            repository_root=ROOT,
+        )
+    except failure_evidence.FailureEvidenceError:
+        parser.exit(2, "execution freeze precondition failed; evidence=unavailable\n")
     try:
         hashes = freeze_protocol(
             protocol_path=args.protocol,
@@ -1545,8 +1554,21 @@ def main(argv: list[str] | None = None) -> int:
             frozen_at=args.frozen_at,
             expected_acquisition_protocol_sha256=args.expected_acquisition_protocol_sha256,
         )
-    except (FreezeError, ValueError, OSError, KeyError, TypeError) as exc:
-        parser.exit(2, f"execution freeze failed ({type(exc).__name__})\n")
+    except BaseException as exc:
+        try:
+            failure_evidence.publish_failure(
+                destination=args.failure_evidence_output,
+                operation="holdout-execution-freeze",
+                exc=exc,
+                repository_root=ROOT,
+            )
+            evidence_status = "preserved"
+        except BaseException:
+            evidence_status = "unavailable"
+        parser.exit(
+            2,
+            f"execution freeze failed ({type(exc).__name__}); evidence={evidence_status}\n",
+        )
     print(
         "execution-frozen "
         + " ".join(

scripts/ctx_ab_holdout_materialize.py

@@ -27,6 +27,7 @@ if str(ROOT) not in sys.path:
 
 from scripts import ctx_ab_benchmark as benchmark  # noqa: E402
 from scripts import ctx_ab_exposure_ledger as exposure_ledger  # noqa: E402
+from scripts import ctx_ab_failure_evidence as failure_evidence  # noqa: E402
 from scripts import ctx_ab_holdout as holdout  # noqa: E402
 from scripts import ctx_ab_holdout_freeze as freezer  # noqa: E402
 from scripts import ctx_ab_swebench as swebench  # noqa: E402
@@ -776,8 +777,26 @@ def _write_artifacts(
                 raise MaterializationError("private artifact permissions are unsafe")
         retained_evidence.rename(temp / VERIFICATION_DIR)
         temp.rename(output)
-    except Exception:
-        shutil.rmtree(temp, ignore_errors=True)
+    except BaseException as exc:
+        cleanup_temp = True
+        published_verification = temp / VERIFICATION_DIR
+        if published_verification.exists() and not retained_evidence.exists():
+            try:
+                published_verification.rename(retained_evidence)
+            except BaseException as rollback_exc:
+                try:
+                    temp.rename(retained_evidence)
+                except BaseException as fallback_exc:
+                    cleanup_temp = False
+                    exc.add_note(
+                        "materialization rollback failed; staged evidence retained at "
+                        f"{temp} ({type(rollback_exc).__name__}, "
+                        f"{type(fallback_exc).__name__})"
+                    )
+                else:
+                    temp = retained_evidence / ".published-output-staging"
+        if cleanup_temp and temp.exists():
+            shutil.rmtree(temp, ignore_errors=True)
         raise
 
 
@@ -792,6 +811,7 @@ def materialize(
     runtime_availability_path: Path,
     catalog_archive_path: Path,
     output: Path,
+    failure_evidence_output: Path,
     swebench_checkout: Path,
     swebench_python: Path,
     docker_cli: Path,
@@ -812,6 +832,7 @@ def materialize(
                 "runtime availability": runtime_availability_path,
                 "catalog archive": catalog_archive_path,
                 "output": output,
+                "failure evidence output": failure_evidence_output,
             }
         )
     except freezer.FreezeError as exc:
@@ -890,6 +911,13 @@ def materialize(
     )
     _validate_runtime(runtime)
     _validate_output_destination(output)
+    try:
+        failure_evidence.validate_destination(
+            failure_evidence_output,
+            repository_root=ROOT,
+        )
+    except failure_evidence.FailureEvidenceError as exc:
+        raise MaterializationError("private failure evidence destination is invalid") from exc
 
     scenario_rows: list[dict[str, Any]] = []
     scenarios: list[benchmark.Scenario] = []
@@ -897,9 +925,11 @@ def materialize(
     reconstructed: dict[str, str] = {}
     retained_evidence = Path(tempfile.mkdtemp(prefix=".official-verification-", dir=output.parent))
     os.chmod(retained_evidence, 0o700)
+    preserve_retained_evidence = False
     try:
-        with tempfile.TemporaryDirectory(prefix="ctx-holdout-materialize-") as raw_work:
-            work_root = Path(raw_work)
+        work_root = Path(tempfile.mkdtemp(prefix=".ctx-holdout-materialize-", dir=output.parent))
+        os.chmod(work_root, 0o700)
+        try:
             source_preflight_deadline = time.monotonic() + float(timeout)
             for source_bundle in sources.values():
                 _validate_source_bundle_heads(
@@ -925,6 +955,17 @@ def materialize(
                 scenarios.append(scenario)
                 controls[scenario_id] = control
                 reconstructed[scenario_id] = reconstructed_source
+        except BaseException as exc:
+            try:
+                work_root.rename(retained_evidence / "raw-control-work")
+            except BaseException as capture_exc:
+                exc.add_note(
+                    "raw control worktree publication failed; "
+                    f"staging retained at {work_root} ({type(capture_exc).__name__})"
+                )
+            raise
+        else:
+            shutil.rmtree(work_root)
 
         scenario_pack_bytes = _canonical_bytes({"scenarios": scenario_rows, "version": 1})
         scenario_pack_sha256 = _sha256(scenario_pack_bytes)
@@ -970,8 +1011,18 @@ def materialize(
             retained_evidence=retained_evidence,
         )
         return {key: _sha256(value) for key, value in artifacts.items()}
+    except BaseException as exc:
+        preserve_retained_evidence = True
+        failure_evidence.publish_failure(
+            staging=retained_evidence,
+            destination=failure_evidence_output,
+            operation="holdout-materialization",
+            exc=exc,
+            repository_root=ROOT,
+        )
+        raise
     finally:
-        if retained_evidence.exists():
+        if retained_evidence.exists() and not preserve_retained_evidence:
             shutil.rmtree(retained_evidence, ignore_errors=True)
 
 
@@ -986,11 +1037,19 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--runtime-availability", type=Path, required=True)
     parser.add_argument("--catalog-archive", type=Path, required=True)
     parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--failure-evidence-output", type=Path, required=True)
     parser.add_argument("--swebench-checkout", type=Path, required=True)
     parser.add_argument("--swebench-python", type=Path, required=True)
     parser.add_argument("--docker-cli", type=Path, required=True)
     parser.add_argument("--docker-host", required=True)
     args = parser.parse_args(argv)
+    try:
+        failure_evidence.validate_destination(
+            args.failure_evidence_output,
+            repository_root=ROOT,
+        )
+    except failure_evidence.FailureEvidenceError:
+        parser.exit(2, "materialization precondition failed; evidence=unavailable\n")
     try:
         hashes = materialize(
             protocol_path=args.protocol,
@@ -1002,6 +1061,7 @@ def main(argv: list[str] | None = None) -> int:
             runtime_availability_path=args.runtime_availability,
             catalog_archive_path=args.catalog_archive,
             output=args.output,
+            failure_evidence_output=args.failure_evidence_output,
             swebench_checkout=args.swebench_checkout,
             swebench_python=args.swebench_python,
             docker_cli=args.docker_cli,
@@ -1009,9 +1069,22 @@ def main(argv: list[str] | None = None) -> int:
         )
         controls = _load_json(args.output / OUTPUT_FILES["controls"])
         scenario_count = controls["scenario_count"]
-    except (MaterializationError, ValueError, OSError, KeyError) as exc:
+    except BaseException as exc:
+        evidence_status = "preserved"
+        if not failure_evidence.already_preserved(args.failure_evidence_output):
+            try:
+                failure_evidence.publish_failure(
+                    destination=args.failure_evidence_output,
+                    operation="holdout-materialization",
+                    exc=exc,
+                    repository_root=ROOT,
+                )
+            except BaseException:
+                evidence_status = "unavailable"
         parser.exit(
-            2, f"materialization failed; private details suppressed ({type(exc).__name__})\n"
+            2,
+            "materialization failed; private details suppressed "
+            f"({type(exc).__name__}); evidence={evidence_status}\n",
         )
     print(
         f"materialized {scenario_count} private scenarios; "

scripts/ctx_ab_holdout_prepare.py

@@ -29,6 +29,7 @@ if str(ROOT) not in sys.path:
     sys.path.insert(0, str(ROOT))
 
 from scripts import ctx_ab_benchmark as benchmark  # noqa: E402
+from scripts import ctx_ab_failure_evidence as failure_evidence  # noqa: E402
 from scripts import ctx_ab_holdout as holdout  # noqa: E402
 from scripts import ctx_ab_holdout_freeze as freezer  # noqa: E402
 from scripts import ctx_ab_swebench as swebench  # noqa: E402
@@ -1673,6 +1674,10 @@ def _add_verifier_arguments(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--docker-host", required=True)
 
 
+def _add_failure_evidence_argument(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--failure-evidence-output", type=Path, required=True)
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     subparsers = parser.add_subparsers(dest="command", required=True)
@@ -1684,6 +1689,7 @@ def main(argv: list[str] | None = None) -> int:
     protocol_parser.add_argument("--exposure-ledger", type=Path, required=True)
     protocol_parser.add_argument("--frozen-at", default=_default_timestamp())
     _add_verifier_arguments(protocol_parser)
+    _add_failure_evidence_argument(protocol_parser)
 
     sources_parser = subparsers.add_parser("sources")
     sources_parser.add_argument("--protocol", type=Path, required=True)
@@ -1694,6 +1700,7 @@ def main(argv: list[str] | None = None) -> int:
     sources_parser.add_argument("--cache-root", type=Path, required=True)
     sources_parser.add_argument("--output", type=Path, required=True)
     sources_parser.add_argument("--workers", type=int, choices=range(1, 9), default=4)
+    _add_failure_evidence_argument(sources_parser)
 
     environment_parser = subparsers.add_parser("environment")
     environment_parser.add_argument("--protocol", type=Path, required=True)
@@ -1715,8 +1722,16 @@ def main(argv: list[str] | None = None) -> int:
     environment_parser.add_argument("--codex", type=Path, required=True)
     environment_parser.add_argument("--python", type=Path, default=Path(sys.executable))
     _add_verifier_arguments(environment_parser)
+    _add_failure_evidence_argument(environment_parser)
 
     args = parser.parse_args(argv)
+    try:
+        failure_evidence.validate_destination(
+            args.failure_evidence_output,
+            repository_root=ROOT,
+        )
+    except failure_evidence.FailureEvidenceError:
+        parser.exit(2, "benchmark preparation precondition failed; evidence=unavailable\n")
     try:
         if args.command == "protocol":
             digest = create_protocol(
@@ -1764,8 +1779,21 @@ def main(argv: list[str] | None = None) -> int:
                 docker_host=args.docker_host,
             )
             print(f"prepared execution environment sha256={digest}")
-    except Exception as exc:
-        parser.exit(2, f"benchmark preparation failed ({type(exc).__name__})\n")
+    except BaseException as exc:
+        try:
+            failure_evidence.publish_failure(
+                destination=args.failure_evidence_output,
+                operation=f"holdout-prepare-{args.command}",
+                exc=exc,
+                repository_root=ROOT,
+            )
+            evidence_status = "preserved"
+        except BaseException:
+            evidence_status = "unavailable"
+        parser.exit(
+            2,
+            f"benchmark preparation failed ({type(exc).__name__}); evidence={evidence_status}\n",
+        )
     return 0