from __future__ import annotations import csv import hashlib import importlib.util import io import json import os import stat import subprocess import sys import tarfile import tempfile import threading import time import tomllib from dataclasses import replace from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from pathlib import Path from typing import Any import pytest import yaml from ctx.adapters.generic.adaptive_runtime import secure_skill_reads_available ROOT = Path(__file__).resolve().parents[2] SCRIPT = ROOT / "scripts" / "ctx_ab_benchmark.py" SPEC = importlib.util.spec_from_file_location("ctx_ab_benchmark", SCRIPT) assert SPEC is not None and SPEC.loader is not None benchmark = importlib.util.module_from_spec(SPEC) sys.modules[SPEC.name] = benchmark SPEC.loader.exec_module(benchmark) CODEX_RUNTIME_CONTRACT = { "arms": ["baseline", "ctx-light"], "model_auto_compact_token_limit": 200_000, "model_reasoning_effort": "high", } def _pid_is_running(pid: int) -> bool: proc_stat = Path(f"/proc/{pid}/stat") if proc_stat.is_file(): try: state = proc_stat.read_text(encoding="utf-8").rsplit(")", 1)[1].split()[0] except (IndexError, OSError): state = "" if state == "Z": return False try: os.kill(pid, 0) except ProcessLookupError: return False return True def test_scenarios_are_pinned_and_have_all_ctx_entity_types() -> None: scenarios = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml") assert [scenario.id for scenario in scenarios] == [ "click-echo-json", "requests-json-or", ] assert all(len(scenario.commit) == 40 for scenario in scenarios) assert {scenario.benchmark_class for scenario in scenarios} == {"trivial"} assert all( {item["type"] for item in scenario.context} == {"skill", "agent", "mcp-server"} for scenario in scenarios ) assert [scenario.expected_test_count for scenario in scenarios] == [5, 3] assert all(scenario.reference_patch and scenario.allowed_changes for scenario in scenarios) def test_runtime_pack_independence_accepts_generic_context(tmp_path: Path) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] availability = tmp_path / "runtime-availability.json" availability.write_text( json.dumps( { "entries": [ { "id": "skill:generic-python-testing", "body": "Inspect the target code, add a focused regression, and run tests.", } ] } ), encoding="utf-8", ) attestation = benchmark.validate_runtime_pack_scenario_independence( [scenario], availability_path=availability, ) assert attestation["guard"] == "runtime-pack-distinctive-evidence-v1" assert ( attestation["runtime_availability_sha256"] == hashlib.sha256(availability.read_bytes()).hexdigest() ) @pytest.mark.parametrize( ("field", "value"), [ ("scenario_id", lambda scenario: scenario.id), ( "repository", lambda scenario: "/".join(scenario.repo_url.removesuffix(".git").rsplit("/", 2)[-2:]), ), ("commit", lambda scenario: scenario.commit), ("query", lambda scenario: scenario.query), ("task", lambda scenario: scenario.task), ("test_path", lambda scenario: scenario.test_path), ("test_body", lambda scenario: scenario.test_body), ("reference_patch", lambda scenario: scenario.reference_patch), ("allowed_change", lambda scenario: scenario.allowed_changes[0]), ("context_body", lambda scenario: next(iter(scenario.context))["body"]), ], ) def test_runtime_pack_independence_rejects_frozen_scenario_evidence( tmp_path: Path, field: str, value: Any, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] availability = tmp_path / "runtime-availability.json" availability.write_text( json.dumps({"entries": [{"body": value(scenario)}]}), encoding="utf-8", ) with pytest.raises(ValueError, match=rf":{field}") as exc_info: benchmark.validate_runtime_pack_scenario_independence( [scenario], availability_path=availability, ) assert scenario.id not in str(exc_info.value) def test_runtime_pack_independence_accepts_common_repository_words(tmp_path: Path) -> None: scenarios = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml") availability = tmp_path / "runtime-availability.json" availability.write_text( json.dumps( { "entries": [ { "body": ( "Click requests rich testing output from Python through " "the shared ctx-wiki." ) } ] } ), encoding="utf-8", ) benchmark.validate_runtime_pack_scenario_independence( scenarios, availability_path=availability, ) @pytest.mark.parametrize( "transform", [ str.upper, lambda value: value.replace("/", "\\"), lambda value: value.replace("/", " /\r\n "), lambda value: f"https://github.com/{value}.git", lambda value: value.replace("pallets", "ｐａｌｌｅｔｓ"), ], ) def test_runtime_pack_independence_normalizes_repository_variants( tmp_path: Path, transform: Any, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] repository = "/".join(scenario.repo_url.removesuffix(".git").rsplit("/", 2)[-2:]) availability = tmp_path / "runtime-availability.json" availability.write_text( json.dumps({"entries": [{"body": transform(repository)}]}), encoding="utf-8", ) with pytest.raises(ValueError, match=":repository"): benchmark.validate_runtime_pack_scenario_independence( [scenario], availability_path=availability, ) def test_runtime_pack_independence_rejects_distinctive_partial_test_body( tmp_path: Path, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] availability = tmp_path / "runtime-availability.json" availability.write_text( json.dumps( { "entries": [ { "body": ( "def test_echo_json_is_public_sorted_unicode_output(): " 'output = StringIO() click.echo_json({"z": 1, "mark": "x"}, ' "file=output)" ) } ] } ), encoding="utf-8", ) with pytest.raises(ValueError, match=":test_body"): benchmark.validate_runtime_pack_scenario_independence( [scenario], availability_path=availability, ) def test_scenario_independence_attestation_rejects_mutation(tmp_path: Path) -> None: scenario_source = tmp_path / "scenarios.yaml" scenario_source.write_bytes((ROOT / "benchmarks/ctx_ab/scenarios.yaml").read_bytes()) availability = tmp_path / "runtime-availability.json" availability.write_text('{"entries": []}\n', encoding="utf-8") archive = tmp_path / "catalog.tar.gz" archive.write_bytes(b"catalog") scenarios = benchmark.load_scenarios(scenario_source) attestation = benchmark.validate_runtime_pack_scenario_independence( scenarios, availability_path=availability, scenarios_path=scenario_source, archive_path=archive, ) snapshot = benchmark.CatalogSnapshot( wiki_dir=tmp_path, provenance={ "runtime_availability_sha256": hashlib.sha256(availability.read_bytes()).hexdigest(), "archive_sha256": hashlib.sha256(archive.read_bytes()).hexdigest(), }, ) benchmark.verify_scenario_independence_attestation( attestation, scenarios_path=scenario_source, snapshot=snapshot, ) scenario_source.write_text( scenario_source.read_text(encoding="utf-8") + "\n", encoding="utf-8", ) with pytest.raises(ValueError, match="scenarios_sha256"): benchmark.verify_scenario_independence_attestation( attestation, scenarios_path=scenario_source, snapshot=snapshot, ) @pytest.mark.parametrize( "field", ["runtime_availability_sha256", "archive_sha256"], ) def test_scenario_independence_attestation_rejects_catalog_input_mismatch( tmp_path: Path, field: str, ) -> None: scenario_source = tmp_path / "scenarios.yaml" scenario_source.write_bytes((ROOT / "benchmarks/ctx_ab/scenarios.yaml").read_bytes()) availability = tmp_path / "runtime-availability.json" availability.write_text('{"entries": []}\n', encoding="utf-8") archive = tmp_path / "catalog.tar.gz" archive.write_bytes(b"catalog") scenarios = benchmark.load_scenarios(scenario_source) attestation = benchmark.validate_runtime_pack_scenario_independence( scenarios, availability_path=availability, scenarios_path=scenario_source, archive_path=archive, ) provenance = { "runtime_availability_sha256": attestation["runtime_availability_sha256"], "archive_sha256": attestation["catalog_archive_sha256"], } provenance[field] = "0" * 64 snapshot = benchmark.CatalogSnapshot( wiki_dir=tmp_path, provenance=provenance, ) with pytest.raises(ValueError, match=field.replace("archive", "catalog_archive")): benchmark.verify_scenario_independence_attestation( attestation, scenarios_path=scenario_source, snapshot=snapshot, ) def test_click_regression_verification_covers_import_contract() -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] assert any("tests/test_imports.py" in command for command in scenario.regression_verify) assert "+ import json" in scenario.reference_patch assert "\n+import json\n" not in scenario.reference_patch def test_task_prompt_is_stable_when_ctx_treatment_is_added() -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] base = benchmark.task_prompt(scenario) skill = next(item for item in scenario.context if item["type"] == "skill") reviewer = next(item for item in scenario.context if item["type"] == "agent") light = base + benchmark.context_prompt(scenario, "ctx-light") full = base + benchmark.context_prompt(scenario, "ctx-full") assert light.startswith(base) assert full.startswith(base) assert "CTX TREATMENT" not in base assert scenario.test_path in base assert str(skill["body"]).strip() in light assert str(reviewer["body"]).strip() not in light assert "ctx__wiki_get" not in light assert str(reviewer["body"]).strip() in full assert "ctx__wiki_get" in full assert f"CTX_REVIEWER:{reviewer['slug']}" in full assert str(skill["body"]).strip() not in full def test_three_arm_schedule_is_stable_and_counterbalanced() -> None: scenarios = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml") full_schedule = benchmark.trial_schedule(scenarios, benchmark.TREATMENT_ARMS, trials=6) for scenario in scenarios: orders = [tuple(row["arms"]) for row in full_schedule if row["scenario"] == scenario.id] assert set(orders) == set(benchmark.ARM_PERMUTATIONS) assert benchmark.trial_schedule([scenario], benchmark.TREATMENT_ARMS, trials=6) == [ row for row in full_schedule if row["scenario"] == scenario.id ] def test_two_arm_schedule_alternates_order_three_times_each() -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] arms = ("baseline", "ctx-light") orders = [tuple(row["arms"]) for row in benchmark.trial_schedule([scenario], arms, trials=6)] assert orders == [ ("baseline", "ctx-light"), ("ctx-light", "baseline"), ("baseline", "ctx-light"), ("ctx-light", "baseline"), ("baseline", "ctx-light"), ("ctx-light", "baseline"), ] def test_adaptive_policy_uses_expensive_tools_only_for_full_or_escalation() -> None: assert benchmark.treatment_policy_valid( "ctx-light", skill_used=True, mcp_used=False, agent_attempted=False, agent_used=False, ) assert not benchmark.treatment_policy_valid( "ctx-light", skill_used=False, mcp_used=False, agent_attempted=False, agent_used=False, ) assert not benchmark.treatment_policy_valid( "ctx-light", skill_used=True, mcp_used=False, agent_attempted=True, agent_used=False, ) assert benchmark.treatment_policy_valid( "ctx-full", skill_used=True, mcp_used=True, agent_attempted=True, agent_used=True, ) assert not benchmark.treatment_policy_valid( "ctx-full", skill_used=True, mcp_used=True, agent_attempted=True, agent_used=False, ) assert ( benchmark.next_treatment_level( "ctx-light", "ctx-light", agent_returncode=0, agent_timed_out=False, policy_valid=True, verification_returncode=1, ) == "ctx-full" ) assert ( benchmark.next_treatment_level( "ctx-light", "ctx-light", agent_returncode=124, agent_timed_out=True, policy_valid=True, verification_returncode=1, ) == "ctx-light" ) assert ( benchmark.next_treatment_level( "ctx-light", "ctx-light", agent_returncode=0, agent_timed_out=False, policy_valid=True, verification_returncode=70, ) == "ctx-light" ) def test_extract_token_usage_uses_only_terminal_complete_record() -> None: output = "\n".join( [ json.dumps({"type": "turn.started", "usage": {"input_tokens": 10}}), json.dumps( { "type": "turn.completed", "usage": { "input_tokens": 120, "cached_input_tokens": 20, "output_tokens": 30, "total_tokens": 150, }, } ), ] ) usage = benchmark.extract_token_usage(output) assert usage == { "attribution": "exact", "attribution_source": "terminal turn.completed.usage", "usage_event_index": 1, "input_tokens": 120, "cached_input_tokens": 20, "uncached_input_tokens": 100, "output_tokens": 30, "total_tokens": 150, } def test_extract_token_usage_is_honest_when_absent() -> None: assert benchmark.extract_token_usage('{"type":"item.completed"}') == { "attribution": "unavailable", "reason": "Codex JSONL exposed no usage", } def test_extract_token_usage_rejects_partial_terminal_record() -> None: output = json.dumps( {"type": "turn.completed", "usage": {"input_tokens": 120, "output_tokens": 30}} ) assert benchmark.extract_token_usage(output) == { "attribution": "unavailable", "reason": "terminal turn.completed usage was incomplete", } def test_trace_efficiency_counts_tool_output_and_failures() -> None: output = "\n".join( [ json.dumps( { "type": "item.completed", "item": { "type": "command_execution", "command": "rg src", "exit_code": 0, "aggregated_output": "abc", }, } ), json.dumps( { "type": "item.completed", "item": { "type": "command_execution", "command": "rg src", "exit_code": 1, "aggregated_output": "failure", }, } ), json.dumps( { "type": "item.completed", "item": {"type": "agent_message", "text": "done"}, } ), json.dumps({"type": "turn.completed", "usage": {}}), ] ) assert benchmark.extract_trace_efficiency(output) == { "descriptive_record_schema_version": 1, "descriptive_trace_complete": True, "completed_item_count": 3, "tool_command_count": 2, "tool_command_exit_code_known_count": 2, "tool_command_output_known_count": 2, "tool_command_text_known_count": 2, "tool_failure_count": 1, "tool_output_bytes": 10, "max_tool_output_bytes": 7, "oversized_tool_output_count": 0, "repeated_tool_command_count": 1, "agent_message_count": 1, "agent_message_bytes": 4, } def test_trace_efficiency_flags_oversized_tool_output() -> None: output = json.dumps( { "type": "item.completed", "item": { "type": "command_execution", "command": "rg everything", "exit_code": 0, "aggregated_output": "x" * (benchmark.PRODUCTION_TOOL_OUTPUT_LIMIT_BYTES + 1), }, } ) output += "\n" + json.dumps({"type": "turn.completed", "usage": {}}) metrics = benchmark.extract_trace_efficiency(output) assert metrics["max_tool_output_bytes"] == benchmark.PRODUCTION_TOOL_OUTPUT_LIMIT_BYTES + 1 assert metrics["oversized_tool_output_count"] == 1 def test_trace_efficiency_keeps_unknown_command_evidence_missing() -> None: output = "\n".join( [ json.dumps( { "type": "item.completed", "item": {"type": "command_execution"}, } ), json.dumps({"type": "turn.completed", "usage": {}}), ] ) metrics = benchmark.extract_trace_efficiency(output) assert metrics["descriptive_trace_complete"] is True assert metrics["tool_command_count"] == 1 assert metrics["tool_command_exit_code_known_count"] == 0 assert metrics["tool_command_output_known_count"] == 0 assert metrics["tool_command_text_known_count"] == 0 assert metrics["tool_failure_count"] is None assert metrics["tool_output_bytes"] is None assert metrics["repeated_tool_command_count"] is None def test_trace_efficiency_marks_malformed_or_unclosed_jsonl_incomplete() -> None: malformed = benchmark.extract_trace_efficiency('{"type":"turn.completed","usage":{}}\nnot-json') unclosed = benchmark.extract_trace_efficiency( json.dumps( { "type": "item.completed", "item": { "type": "command_execution", "command": "pytest", "exit_code": 0, "aggregated_output": "ok", }, } ) ) corrupt_item = benchmark.extract_trace_efficiency( "\n".join( [ json.dumps({"type": "item.completed", "item": "corrupt"}), json.dumps({"type": "turn.completed", "usage": {}}), ] ) ) corrupt_item_types = [ benchmark.extract_trace_efficiency( "\n".join( [ json.dumps({"type": "item.completed", "item": item}), json.dumps({"type": "turn.completed", "usage": {}}), ] ) ) for item in ({}, {"type": ""}, {"type": 7}) ] post_terminal = benchmark.extract_trace_efficiency( "\n".join( [ json.dumps({"type": "turn.completed", "usage": {}}), json.dumps( { "type": "item.completed", "item": { "type": "command_execution", "command": "late command", "exit_code": 0, "aggregated_output": "late output", }, } ), ] ) ) assert malformed["descriptive_trace_complete"] is False assert malformed["tool_command_count"] is None assert unclosed["descriptive_trace_complete"] is False assert unclosed["tool_command_count"] is None assert corrupt_item["descriptive_trace_complete"] is False assert corrupt_item["tool_command_count"] is None assert all(result["descriptive_trace_complete"] is False for result in corrupt_item_types) assert all(result["tool_command_count"] is None for result in corrupt_item_types) assert post_terminal["descriptive_trace_complete"] is False assert post_terminal["tool_command_count"] is None def test_mcp_use_requires_an_mcp_typed_json_event() -> None: expected = { "slug": "click-public-api-feature", "entity_type": "skill", "body": "Use Click echo.", } prompt_event = json.dumps({"type": "user_message", "text": "use ctx-wiki"}) failed_event = json.dumps( { "type": "item.completed", "item": { "type": "mcp_tool_call", "server": "ctx-wiki", "tool": "ctx__wiki_get", "arguments": { "slug": expected["slug"], "entity_type": expected["entity_type"], }, "status": "failed", "error": {"message": "boom"}, }, } ) successful_event = json.dumps( { "type": "item.completed", "item": { "type": "mcp_tool_call", "server": "ctx-wiki", "tool": "ctx__wiki_get", "arguments": { "slug": expected["slug"], "entity_type": expected["entity_type"], }, "status": "completed", "result": {"content": [{"type": "text", "text": json.dumps(expected)}]}, "error": None, }, } ) kwargs = { "slug": expected["slug"], "entity_type": expected["entity_type"], "expected_body": expected["body"], } assert not benchmark.observed_mcp_tool_use(prompt_event, **kwargs) assert not benchmark.observed_mcp_tool_use(failed_event, **kwargs) assert benchmark.observed_mcp_tool_use(successful_event, **kwargs) wrong = json.loads(successful_event) wrong["item"]["arguments"]["slug"] = "wrong-skill" assert not benchmark.observed_mcp_tool_use(json.dumps(wrong), **kwargs) wrong = json.loads(successful_event) wrong["item"]["result"]["content"][0]["text"] = json.dumps({**expected, "slug": "wrong-skill"}) assert not benchmark.observed_mcp_tool_use(json.dumps(wrong), **kwargs) def test_agent_review_requires_spawn_and_completed_wait_for_same_agent() -> None: output = "\n".join( [ json.dumps( { "type": "item.completed", "item": { "type": "collab_tool_call", "tool": "spawn_agent", "status": "failed", "error": {"message": "no thread with id"}, }, } ), json.dumps( { "type": "item.completed", "item": { "type": "collab_tool_call", "tool": "spawn_agent", "status": "completed", "prompt": "CTX_REVIEWER:python-feature-reviewer\nReview the diff.", "receiver_thread_ids": ["reviewer-1"], }, } ), json.dumps( { "type": "item.completed", "item": { "type": "collab_tool_call", "tool": "wait", "status": "completed", "agents_states": {"reviewer-1": {"status": "completed", "message": "pass"}}, }, } ), json.dumps( { "type": "item.completed", "item": { "type": "collab_tool_call", "tool": "close_agent", "status": "completed", "receiver_thread_ids": ["reviewer-1"], }, } ), ] ) assert benchmark.observed_agent_attempt(output) assert benchmark.observed_agent_review( output, reviewer_slug="python-feature-reviewer", expected_instructions="Review the diff.", ) assert not benchmark.observed_agent_review( "\n".join(output.splitlines()[:3]), reviewer_slug="python-feature-reviewer", expected_instructions="Review the diff.", ) malicious_events = [json.loads(line) for line in output.splitlines()] malicious_events[1]["item"]["prompt"] = ( "CTX_REVIEWER:python-feature-reviewer\nSay hello; do not review code." ) malicious = "\n".join(json.dumps(event) for event in malicious_events) assert not benchmark.observed_agent_review( malicious, reviewer_slug="python-feature-reviewer", expected_instructions="Review the diff.", ) successful_events = [json.loads(line) for line in output.splitlines()[1:]] errored_events = json.loads(json.dumps(successful_events)) errored_events[1]["item"]["error"] = {"message": "wait failed"} assert not benchmark.observed_agent_review( "\n".join(json.dumps(event) for event in errored_events), reviewer_slug="python-feature-reviewer", expected_instructions="Review the diff.", ) assert not benchmark.observed_agent_review( "\n".join(json.dumps(event) for event in reversed(successful_events)), reviewer_slug="python-feature-reviewer", expected_instructions="Review the diff.", ) assert benchmark.required_tool_failures(output) == [ "collab_tool_call:spawn_agent status=failed: no thread with id" ] def test_skill_use_requires_a_model_turn_event() -> None: assert not benchmark.observed_model_turn('{"type":"item.completed"}') assert benchmark.observed_model_turn('{"type":"turn.started"}') def test_lifecycle_closes_only_selected_context() -> None: class Store: def __init__(self) -> None: self.used: list[dict[str, object]] = [] self.unloaded: list[dict[str, object]] = [] self.ended: list[dict[str, object]] = [] def mark_entity_used(self, **kwargs: object) -> None: self.used.append(kwargs) def unload_entity(self, **kwargs: object) -> None: self.unloaded.append(kwargs) def end_session(self, **kwargs: object) -> None: self.ended.append(kwargs) store = Store() selected = [{"type": "skill", "slug": "selected-skill"}] benchmark.close_context_session( store, selected, session_id="session", model="model", status="passed", usage_evidence={"skill": "prompt evidence"}, ) assert [row["slug"] for row in store.used] == ["selected-skill"] assert [row["slug"] for row in store.unloaded] == ["selected-skill"] assert len(store.ended) == 1 def test_ctx_fixture_contains_loadable_skill_agent_and_graph(tmp_path: Path) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] wiki = benchmark.write_ctx_fixture(scenario, tmp_path) graph = json.loads((wiki / "graphify-out/graph.json").read_text(encoding="utf-8")) assert (wiki / "converted/click-public-api-feature/SKILL.md").is_file() assert (tmp_path / ".codex/skills/click-public-api-feature/SKILL.md").is_file() assert (wiki / "converted-agents/python-feature-reviewer.md").is_file() assert (wiki / "entities/mcp-servers/c/ctx-wiki.md").is_file() assert {node["type"] for node in graph["nodes"]} == {"skill", "agent", "mcp-server"} assert len(graph["edges"]) == 2 def _catalog_snapshot(tmp_path: Path) -> Any: wiki = tmp_path / "catalog" / ".claude" / "skill-wiki" wiki.mkdir(parents=True) wiki.chmod(0o550) return benchmark.CatalogSnapshot( wiki_dir=wiki, provenance={ "archive_sha256": "a" * 64, "runtime_availability_sha256": "d" * 64, "graph_export_id": "export-1", "graph_export_manifest_sha256": "b" * 64, "overlay_sha256": "c" * 64, "overlay_records": [ { "overlay_id": "ctx-runtime-availability-v1", "source": "ctx-runtime-availability", } ], }, ) @pytest.mark.parametrize( ("matching_tags", "language", "decision", "reason"), [ (["python"], "python", "abstain", "language_only_match"), (["Py"], "PYTHON", "abstain", "language_only_match"), (["python", "pytest"], "python", "load", "intent_match"), (["javascript"], "python", "abstain", "conflicting_language_match"), ( ["python", "javascript"], "python", "abstain", "conflicting_language_match", ), (["python", "local"], "python", "abstain", "constraint_only_match"), (None, "python", "abstain", "insufficient_match_evidence"), ([], "python", "abstain", "insufficient_match_evidence"), (["python", "python"], "python", "abstain", "insufficient_match_evidence"), (["python", 1], "python", "abstain", "insufficient_match_evidence"), ], ) def test_catalog_match_evidence_requires_intent_beyond_language( matching_tags: object, language: str, decision: str, reason: str, ) -> None: result = benchmark.classify_catalog_match_evidence( {"matching_tags": matching_tags}, language=language, ) assert result["decision"] == decision assert result["reason"] == reason def test_production_catalog_recommendation_records_candidates_selection_and_body_provenance( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] snapshot = _catalog_snapshot(tmp_path) body = "Use focused pytest, then run the repository import contract." calls: list[tuple[str, dict[str, object]]] = [] class Client: def __enter__(self) -> "Client": return self def __exit__(self, *_exc: object) -> None: return None def call_tool(self, name: str, arguments: dict[str, object]) -> str: calls.append((name, arguments)) if name == "ctx__recommend_bundle": return json.dumps( { "results": [ { "id": "skill:ctx-python-testing", "name": "ctx-python-testing", "type": "skill", "installable": True, "load_status": "local-wiki", "matching_tags": ["python", "pytest"], "source": "ctx-runtime-availability", "source_path": "converted/ctx-python-testing/SKILL.md", }, { "id": "agent:ctx-python-reviewer", "name": "ctx-python-reviewer", "type": "agent", "installable": True, "load_status": "available", "tags": ["local", "no-api-key", "python", "security"], "permissions": ["diff:read"], "risk": "low", "external": False, "requires_api_keys": False, "source": "ctx-runtime-availability", "source_path": "entities/agents/ctx-python-reviewer.md", }, ], "context_policy": { "initial_load": ["skill:ctx-python-testing"], "deferred": ["agent:ctx-python-reviewer"], }, } ) assert name == "ctx__wiki_get" return json.dumps( { "slug": "ctx-python-testing", "entity_type": "skill", "path": "entities/skills/ctx-python-testing.md", "frontmatter": { "source": "ctx-runtime-availability", "license": "MIT", }, "body": body, } ) monkeypatch.setattr(benchmark, "_catalog_mcp_client", lambda **_kwargs: Client()) catalog = benchmark.recommend_production_catalog( scenario, home=tmp_path / "home", lifecycle_root=tmp_path / "lifecycle", session_id="catalog-session", snapshot=snapshot, ) evidence_path = tmp_path / "recommendations.json" benchmark.write_catalog_recommendation_evidence( evidence_path, catalog, used_ids=[], snapshot=snapshot, ) evidence = json.loads(evidence_path.read_text(encoding="utf-8")) assert [name for name, _arguments in calls] == [ "ctx__recommend_bundle", "ctx__wiki_get", ] recommendation_args = calls[0][1] assert recommendation_args["local_code_task"] is True assert recommendation_args["no_api_keys"] is True assert recommendation_args["language"] == "python" assert "session_id" not in recommendation_args assert evidence["candidate_ids"] == [ "skill:ctx-python-testing", "agent:ctx-python-reviewer", ] assert evidence["selected_ids"] == ["skill:ctx-python-testing"] assert evidence["used_ids"] == [] assert evidence["deferred_activation"] == catalog["deferred_activation"] assert catalog["deferred_activation"] == { "decision": "deny", "selected_ids": [], "reason": "policy_disabled_default_deny", "deferred_candidates": [ { "id": "agent:ctx-python-reviewer", "type": "agent", "loadability": True, "permissions": ["diff:read"], "risk": "low", "tags": ["local", "no-api-key", "python", "security"], "external": False, "requires_api_keys": False, "provenance": { "source": "ctx-runtime-availability", "source_path": "entities/agents/ctx-python-reviewer.md", }, } ], } assert catalog["selected_item"]["body"] == body assert catalog["body_provenance"] == { "surface": "ctx MCP ctx__wiki_get", "wiki_path": "entities/skills/ctx-python-testing.md", "wiki_response_sha256": hashlib.sha256( json.dumps( { "slug": "ctx-python-testing", "entity_type": "skill", "path": "entities/skills/ctx-python-testing.md", "frontmatter": { "source": "ctx-runtime-availability", "license": "MIT", }, "body": body, } ).encode("utf-8") ).hexdigest(), "body_sha256": hashlib.sha256(body.encode("utf-8")).hexdigest(), "body_bytes": len(body.encode("utf-8")), "frontmatter_source": "ctx-runtime-availability", "frontmatter_license": "MIT", "candidate_source": "ctx-runtime-availability", "candidate_source_path": "converted/ctx-python-testing/SKILL.md", "catalog_archive_sha256": "a" * 64, "catalog_graph_export_id": "export-1", } def test_production_catalog_language_only_match_abstains_before_body_fetch( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] calls: list[str] = [] class Client: def __enter__(self) -> "Client": return self def __exit__(self, *_exc: object) -> None: return None def call_tool(self, name: str, _arguments: dict[str, object]) -> str: calls.append(name) if name != "ctx__recommend_bundle": raise AssertionError("language-only match must not fetch a wiki body") return json.dumps( { "results": [ { "id": "skill:ctx-python-testing", "name": "ctx-python-testing", "type": "skill", "installable": True, "load_status": "local-wiki", "matching_tags": ["python"], "source": "ctx-runtime-availability", "source_path": "converted/ctx-python-testing/SKILL.md", } ], "context_policy": { "initial_load": ["skill:ctx-python-testing"], "deferred": [], }, } ) monkeypatch.setattr(benchmark, "_catalog_mcp_client", lambda **_kwargs: Client()) catalog = benchmark.recommend_production_catalog( scenario, home=tmp_path / "home", lifecycle_root=tmp_path / "lifecycle", session_id="language-only", snapshot=_catalog_snapshot(tmp_path), ) assert calls == ["ctx__recommend_bundle"] assert catalog["selected_ids"] == [] assert catalog["selected_item"] is None assert catalog["body_provenance"] is None assert catalog["body_fetch_seconds"] == 0.0 assert catalog["selection_skip_reason"] == "language_only_match" assert catalog["policy_abstention"] == { "candidate_id": "skill:ctx-python-testing", "decision": "abstain", "reason": "language_only_match", "language": "python", "matching_tags": ["python"], } prompt_hash = hashlib.sha256(b"unchanged").hexdigest() lifecycle_events = [ { "action": "dev_event", "event_type": "catalog_recommendation", "payload": { "candidate_ids": catalog["candidate_ids"], "selected_ids": [], "context_policy": catalog["context_policy"], }, }, {"action": "session_end", "status": "passed"}, ] assert benchmark.verify_production_policy_abstention( catalog, language="python", task_prompt_sha256=prompt_hash, delivered_prompt_sha256=prompt_hash, model_turn_observed=True, evaluator_isolation_verified=True, mcp_used=False, agent_attempted=False, lifecycle_events=lifecycle_events, ) spoofed = json.loads(json.dumps(catalog)) spoofed["selected_ids"] = ["skill:ctx-python-testing"] assert not benchmark.verify_production_policy_abstention( spoofed, language="python", task_prompt_sha256=prompt_hash, delivered_prompt_sha256=prompt_hash, model_turn_observed=True, evaluator_isolation_verified=True, mcp_used=False, agent_attempted=False, lifecycle_events=lifecycle_events, ) wrong_policy = json.loads(json.dumps(catalog)) wrong_policy["candidates"].insert( 0, { "id": "skill:intent-specific", "name": "intent-specific", "type": "skill", "installable": True, "matching_tags": ["python", "pytest"], }, ) wrong_policy["candidate_ids"].insert(0, "skill:intent-specific") wrong_policy["context_policy"]["initial_load"].insert(0, "skill:intent-specific") wrong_policy["policy_initial_load_ids"].insert(0, "skill:intent-specific") assert not benchmark.verify_production_policy_abstention( wrong_policy, language="python", task_prompt_sha256=prompt_hash, delivered_prompt_sha256=prompt_hash, model_turn_observed=True, evaluator_isolation_verified=True, mcp_used=False, agent_attempted=False, ) for field, value in (("type", "agent"), ("installable", False)): invalid = json.loads(json.dumps(catalog)) invalid["candidates"][0][field] = value assert not benchmark.verify_production_policy_abstention( invalid, language="python", task_prompt_sha256=prompt_hash, delivered_prompt_sha256=prompt_hash, model_turn_observed=True, evaluator_isolation_verified=True, mcp_used=False, agent_attempted=False, ) malformed_policy = json.loads(json.dumps(catalog)) malformed_policy["policy_initial_load_ids"] = "skill:ctx-python-testing" assert not benchmark.verify_production_policy_abstention( malformed_policy, language="python", task_prompt_sha256=prompt_hash, delivered_prompt_sha256=prompt_hash, model_turn_observed=True, evaluator_isolation_verified=True, mcp_used=False, agent_attempted=False, ) boolean_timing = json.loads(json.dumps(catalog)) boolean_timing["body_fetch_seconds"] = False assert not benchmark.verify_production_policy_abstention( boolean_timing, language="python", task_prompt_sha256=prompt_hash, delivered_prompt_sha256=prompt_hash, model_turn_observed=True, evaluator_isolation_verified=True, mcp_used=False, agent_attempted=False, ) assert not benchmark.verify_production_policy_abstention( catalog, language="python", task_prompt_sha256="a", delivered_prompt_sha256="a", model_turn_observed=True, evaluator_isolation_verified=True, mcp_used=False, agent_attempted=False, ) tampered_events = json.loads(json.dumps(lifecycle_events)) tampered_events[0]["payload"]["candidate_ids"] = [] assert not benchmark.verify_production_policy_abstention( catalog, language="python", task_prompt_sha256=prompt_hash, delivered_prompt_sha256=prompt_hash, model_turn_observed=True, evaluator_isolation_verified=True, mcp_used=False, agent_attempted=False, lifecycle_events=tampered_events, ) for candidate_ids in ([], ["skill:phantom"]): coordinated_catalog = json.loads(json.dumps(catalog)) coordinated_catalog["candidate_ids"] = candidate_ids coordinated_events = json.loads(json.dumps(lifecycle_events)) coordinated_events[0]["payload"]["candidate_ids"] = candidate_ids assert not benchmark.verify_production_policy_abstention( coordinated_catalog, language="python", task_prompt_sha256=prompt_hash, delivered_prompt_sha256=prompt_hash, model_turn_observed=True, evaluator_isolation_verified=True, mcp_used=False, agent_attempted=False, lifecycle_events=coordinated_events, ) def _deferred_candidate( entity_id: str = "mcp-server:ctx-core", *, entity_type: str = "mcp-server", tags: list[str] | None = None, permissions: list[str] | None = None, risk: str = "low", ) -> dict[str, object]: return { "id": entity_id, "type": entity_type, "installable": True, "load_status": "available", "tags": tags or ["lifecycle", "local", "no-api-key"], "permissions": permissions or ["graph:read"], "risk": risk, "external": False, "requires_api_keys": False, "source": "ctx-runtime-availability", "source_path": f"entities/{entity_type}s/{entity_id.partition(':')[2]}.md", } def _activation_policy( *entity_ids: str, entity_type: str = "mcp-server", permissions: list[str] | None = None, max_risk: str = "medium", ) -> dict[str, object]: return { "enabled": True, "allowed_entity_types": [entity_type], "allowed_tools": list(entity_ids), "allowed_permissions": permissions or ["graph:read"], "max_risk": max_risk, } def _public_task_evidence(*, risks: list[str] | None = None) -> dict[str, object]: return { "language": "python", "task_category": "lifecycle", "predeclared_risks": risks or [], "local_code_task": True, "no_api_keys": True, "repository_paths": ["src/package.py"], "tags": ["lifecycle"], } def test_deferred_activation_defaults_to_deny_and_retains_normalized_evidence() -> None: candidate = _deferred_candidate() decision = benchmark.decide_deferred_activation( stage="pre-solve", candidates=[candidate], context_policy={"deferred": [candidate["id"]]}, task_evidence=_public_task_evidence(), ) assert decision["decision"] == "deny" assert decision["reason"] == "policy_disabled_default_deny" assert decision["selected_ids"] == [] assert decision["deferred_candidates"][0] == { "id": "mcp-server:ctx-core", "type": "mcp-server", "loadability": True, "permissions": ["graph:read"], "risk": "low", "tags": ["lifecycle", "local", "no-api-key"], "external": False, "requires_api_keys": False, "provenance": { "source": "ctx-runtime-availability", "source_path": "entities/mcp-servers/ctx-core.md", }, } @pytest.mark.parametrize( ("candidate_updates", "policy_updates", "reason"), [ ({"installable": False}, {}, "not_loadable"), ({"load_status": "external-install-required"}, {}, "not_loadable"), ({"tags": ["lifecycle"]}, {}, "not_local_no_key"), ({"external": True}, {}, "not_local_no_key"), ({"external": "false"}, {}, "not_local_no_key"), ({"requires_api_keys": True}, {}, "not_local_no_key"), ({"requires_api_keys": 0}, {}, "not_local_no_key"), ({"permissions": ["repo:write"]}, {}, "permission_denied"), ({"risk": "high"}, {"max_risk": "low"}, "risk_exceeds_policy"), ({}, {"allowed_entity_types": []}, "type_not_allowed"), ({}, {"allowed_tools": []}, "tool_not_allowed"), ], ) def test_deferred_activation_enforces_host_gates( candidate_updates: dict[str, object], policy_updates: dict[str, object], reason: str, ) -> None: candidate = _deferred_candidate() candidate.update(candidate_updates) policy = _activation_policy(str(candidate["id"])) policy.update(policy_updates) decision = benchmark.decide_deferred_activation( stage="pre-solve", candidates=[candidate], context_policy={"deferred": [candidate["id"]]}, task_evidence=_public_task_evidence(), activation_policy=policy, ) assert decision["decision"] == "deny" assert decision["reason"] == reason assert decision["selected_ids"] == [] def test_deferred_activation_denies_missing_explicit_safety_flags() -> None: candidate = _deferred_candidate() candidate.pop("requires_api_keys") decision = benchmark.decide_deferred_activation( stage="pre-solve", candidates=[candidate], context_policy={"deferred": [candidate["id"]]}, task_evidence=_public_task_evidence(), activation_policy=_activation_policy(str(candidate["id"])), ) assert decision["decision"] == "deny" assert decision["reason"] == "not_local_no_key" def test_deferred_activation_rejects_duplicate_and_malformed_candidate_ids() -> None: candidate = _deferred_candidate() with pytest.raises(ValueError, match="must be unique"): benchmark.decide_deferred_activation( stage="pre-solve", candidates=[candidate, dict(candidate)], context_policy={"deferred": [candidate["id"]]}, task_evidence=_public_task_evidence(), ) with pytest.raises(ValueError, match="invalid id or type"): benchmark.decide_deferred_activation( stage="pre-solve", candidates=[candidate, {"id": "", "type": "agent"}], context_policy={"deferred": [candidate["id"]]}, task_evidence=_public_task_evidence(), ) def test_deferred_activation_retains_null_provenance_as_unloadable() -> None: candidate = _deferred_candidate() candidate["source_path"] = None decision = benchmark.decide_deferred_activation( stage="pre-solve", candidates=[candidate], context_policy={"deferred": [candidate["id"]]}, task_evidence=_public_task_evidence(), activation_policy=_activation_policy(str(candidate["id"])), ) assert decision["decision"] == "deny" assert decision["reason"] == "not_loadable" assert decision["deferred_candidates"][0]["loadability"] is False assert decision["deferred_candidates"][0]["provenance"]["source_path"] is None def test_deferred_activation_selects_at_most_one_natural_mcp() -> None: first = _deferred_candidate() second = _deferred_candidate("mcp-server:ctx-secondary") decision = benchmark.decide_deferred_activation( stage="pre-solve", candidates=[first, second], context_policy={"deferred": [first["id"], second["id"]]}, task_evidence=_public_task_evidence(), activation_policy=_activation_policy(str(first["id"]), str(second["id"])), ) assert decision["decision"] == "select" assert decision["reason"] == "selected_pre-solve" assert decision["selected_ids"] == ["mcp-server:ctx-core"] def test_deferred_activation_requires_diff_and_risk_for_natural_reviewer() -> None: reviewer = _deferred_candidate( "agent:ctx-python-reviewer", entity_type="agent", tags=["local", "no-api-key", "python", "security"], permissions=["diff:read"], risk="medium", ) policy = _activation_policy( str(reviewer["id"]), entity_type="agent", permissions=["diff:read"], ) denied = benchmark.decide_deferred_activation( stage="post-solve", candidates=[reviewer], context_policy={"deferred": [reviewer["id"]]}, task_evidence=_public_task_evidence(risks=["security"]), activation_policy=policy, run_evidence={"diff_non_empty": False, "changed_paths": []}, ) selected = benchmark.decide_deferred_activation( stage="post-solve", candidates=[reviewer], context_policy={"deferred": [reviewer["id"]]}, task_evidence=_public_task_evidence(risks=["security"]), activation_policy=policy, run_evidence={"diff_non_empty": True, "changed_paths": ["src/package.py"]}, ) assert denied["reason"] == "post_solve_requires_diff_and_predeclared_risk" assert denied["selected_ids"] == [] assert selected["reason"] == "selected_post-solve" assert selected["selected_ids"] == ["agent:ctx-python-reviewer"] def test_deferred_activation_rejects_hidden_oracle_keys() -> None: candidate = _deferred_candidate() with pytest.raises(ValueError, match="hidden-oracle"): benchmark.decide_deferred_activation( stage="pre-solve", candidates=[candidate], context_policy={"deferred": [candidate["id"]]}, task_evidence={ **_public_task_evidence(), "tags": [{"reference_patch": "secret"}], }, ) with pytest.raises(ValueError, match="hidden-oracle"): benchmark.decide_deferred_activation( stage="pre-solve", candidates=[candidate], context_policy={"deferred": [candidate["id"]]}, task_evidence={ **_public_task_evidence(), "repository_paths": ["hidden/reference.patch"], }, ) with pytest.raises(ValueError, match="hidden-oracle"): benchmark.decide_deferred_activation( stage="post-solve", candidates=[candidate], context_policy={"deferred": [candidate["id"]]}, task_evidence=_public_task_evidence(risks=["security"]), run_evidence={"hidden_tests": ["secret"]}, ) @pytest.mark.parametrize( ("field", "updates"), [ ("task", {"unknown_task_field": True}), ("activation", {"unknown_policy_field": True}), ("context", {"unknown_context_field": []}), ], ) def test_deferred_activation_rejects_unknown_policy_fields( field: str, updates: dict[str, object], ) -> None: candidate = _deferred_candidate() task_evidence = _public_task_evidence() activation_policy: dict[str, object] = {} context_policy: dict[str, object] = {"deferred": [candidate["id"]]} target = { "task": task_evidence, "activation": activation_policy, "context": context_policy, }[field] target.update(updates) with pytest.raises(ValueError, match="unsupported keys"): benchmark.decide_deferred_activation( stage="pre-solve", candidates=[candidate], context_policy=context_policy, task_evidence=task_evidence, activation_policy=activation_policy, ) def test_deferred_policy_does_not_change_production_task_prompt_hash() -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] candidate = _deferred_candidate() before = hashlib.sha256(benchmark.production_catalog_task_prompt(scenario).encode()).hexdigest() benchmark.decide_deferred_activation( stage="pre-solve", candidates=[candidate], context_policy={"deferred": [candidate["id"]]}, task_evidence=_public_task_evidence(), activation_policy=_activation_policy(str(candidate["id"])), ) after = hashlib.sha256(benchmark.production_catalog_task_prompt(scenario).encode()).hexdigest() assert before == after == "edec6d52378da164473ea090c12bf19b1ca4173d1c257e5278fd91575d60f90e" def test_production_catalog_recommendation_allows_no_selection( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] calls: list[str] = [] class Client: def __enter__(self) -> "Client": return self def __exit__(self, *_exc: object) -> None: return None def call_tool(self, name: str, _arguments: dict[str, object]) -> str: calls.append(name) return json.dumps( { "results": [ { "id": "agent:ctx-python-reviewer", "name": "ctx-python-reviewer", "type": "agent", "installable": True, } ], "context_policy": {"initial_load": []}, } ) monkeypatch.setattr(benchmark, "_catalog_mcp_client", lambda **_kwargs: Client()) catalog = benchmark.recommend_production_catalog( scenario, home=tmp_path / "home", lifecycle_root=tmp_path / "lifecycle", session_id="no-selection", snapshot=_catalog_snapshot(tmp_path), ) assert calls == ["ctx__recommend_bundle"] assert catalog["candidate_ids"] == ["agent:ctx-python-reviewer"] assert catalog["selected_ids"] == [] assert catalog["selected_item"] is None assert catalog["body_provenance"] is None assert benchmark.production_catalog_context_prompt(catalog) == "" def test_production_skill_use_reason_distinguishes_no_delivery() -> None: assert ( benchmark.production_skill_use_evidence_reason( production_catalog=True, ctx_enabled=True, context_delivery_verified=False, policy_abstention_verified=True, ) == "policy_abstained_before_context_delivery" ) assert ( benchmark.production_skill_use_evidence_reason( production_catalog=True, ctx_enabled=True, context_delivery_verified=False, ) == "no_skill_delivered" ) assert ( benchmark.production_skill_use_evidence_reason( production_catalog=True, ctx_enabled=True, context_delivery_verified=True, ) == "provider_does_not_expose_semantic_context_attribution" ) assert ( benchmark.production_skill_use_evidence_reason( production_catalog=True, ctx_enabled=False, context_delivery_verified=False, ) is None ) def test_production_catalog_dry_run_never_writes_scenario_fixture( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] snapshot = _catalog_snapshot(tmp_path) production_body = "Production catalog body, not scenario fixture text." def fake_prepare( _scenario: object, _cache: Path, destination: Path, *, include_evaluator_test: bool, ) -> str: assert include_evaluator_test is False destination.mkdir(parents=True) return hashlib.sha256(scenario.test_body.encode("utf-8")).hexdigest() def fixture_forbidden(*_args: object, **_kwargs: object) -> None: raise AssertionError("write_ctx_fixture must not run for the production catalog engine") catalog = { "query": scenario.query, "candidates": [ { "id": "skill:ctx-python-testing", "name": "ctx-python-testing", "type": "skill", "installable": True, }, { "id": "agent:ctx-python-reviewer", "name": "ctx-python-reviewer", "type": "agent", "installable": True, }, ], "candidate_ids": [ "skill:ctx-python-testing", "agent:ctx-python-reviewer", ], "context_policy": {"initial_load": ["skill:ctx-python-testing"]}, "policy_field": "initial_load", "policy_initial_load_ids": ["skill:ctx-python-testing"], "selected_item": { "id": "skill:ctx-python-testing", "type": "skill", "slug": "ctx-python-testing", "body": production_body, }, "selected_ids": ["skill:ctx-python-testing"], "body_provenance": { "surface": "ctx MCP ctx__wiki_get", "body_sha256": hashlib.sha256(production_body.encode()).hexdigest(), }, "selection_skip_reason": None, "recommendation_response_sha256": "d" * 64, "recommendation_seconds": 0.01, "body_fetch_seconds": 0.02, "surface_seconds": 0.03, } monkeypatch.setattr(benchmark, "prepare_workspace", fake_prepare) monkeypatch.setattr(benchmark, "write_ctx_fixture", fixture_forbidden) monkeypatch.setattr( benchmark, "recommend_production_catalog", lambda *_args, **_kwargs: catalog, ) result = benchmark.run_trial( scenario, arm="ctx-light", treatment_level="ctx-light", attempt=1, trial=1, retry=0, cache=tmp_path / "cache", output=tmp_path / "output", codex="codex", model="gpt-test", timeout=10, dry_run=True, incidents=benchmark.IncidentLog(tmp_path / "incidents.csv"), catalog_snapshot=snapshot, ) prompt = Path(result["artifact_dir"], "prompt.txt").read_text(encoding="utf-8") assert result["engine"] == benchmark.PRODUCTION_CATALOG_ENGINE assert result["candidate_ids"] == catalog["candidate_ids"] assert result["selected_ids"] == ["skill:ctx-python-testing"] assert result["used_ids"] == [] assert production_body in prompt fixture_body = next(item["body"] for item in scenario.context if item["type"] == "skill") assert fixture_body.strip() not in prompt assert scenario.test_path not in prompt assert result["lifecycle_actions"] == [ "dev_event", "load_requested", "load_applied", "unload_requested", "unload_applied", "session_end", ] assert result["final_loaded"] == [] def test_production_catalog_delivery_precedes_terminal_digest( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], context=(), ) snapshot = _catalog_snapshot(tmp_path) production_body = "Use focused pytest and preserve the public import contract." selected_id = "skill:ctx-python-testing" catalog = { "query": scenario.query, "candidates": [ { "id": selected_id, "name": "ctx-python-testing", "type": "skill", "installable": True, } ], "candidate_ids": [selected_id], "context_policy": {"initial_load": [selected_id]}, "policy_field": "initial_load", "policy_initial_load_ids": [selected_id], "selected_item": { "id": selected_id, "type": "skill", "slug": "ctx-python-testing", "body": production_body, }, "selected_ids": [selected_id], "body_provenance": { "surface": "ctx MCP ctx__wiki_get", "body_sha256": hashlib.sha256(production_body.encode()).hexdigest(), }, "selection_skip_reason": None, "recommendation_response_sha256": "d" * 64, "recommendation_seconds": 0.01, "body_fetch_seconds": 0.02, "surface_seconds": 0.03, } def fake_prepare( _scenario: object, _cache: Path, destination: Path, *, include_evaluator_test: bool, ) -> str: assert include_evaluator_test is False destination.mkdir(parents=True) return hashlib.sha256(scenario.test_body.encode("utf-8")).hexdigest() def fake_process(command: list[str], **_kwargs: object) -> Any: if command[0] == "codex": stdout = "\n".join( [ json.dumps({"type": "turn.started"}), json.dumps( { "type": "turn.completed", "usage": { "input_tokens": 12, "cached_input_tokens": 2, "output_tokens": 3, }, } ), ] ) return benchmark.CommandResult(0, stdout, "", 0.25) return benchmark.CommandResult(0, "", "", 0.01) def fake_prepare_home(home: Path, **_kwargs: object) -> Path: home.mkdir(parents=True) return home monkeypatch.setattr(benchmark, "prepare_workspace", fake_prepare) monkeypatch.setattr(benchmark, "bind_catalog_snapshot", lambda *_args: None) monkeypatch.setattr( benchmark, "recommend_production_catalog", lambda *_args, **_kwargs: catalog, ) monkeypatch.setattr(benchmark, "prepare_isolated_codex_home", fake_prepare_home) monkeypatch.setattr( benchmark, "verify_agent_sandbox_isolation", lambda **_kwargs: {"verified": True}, ) monkeypatch.setattr(benchmark, "run_process", fake_process) monkeypatch.setattr( benchmark, "_verify_pinned_head", lambda *_args: benchmark.CommandResult(0, "", "", 0.01), ) monkeypatch.setattr( benchmark, "verify_workspace", lambda *_args: benchmark.CommandResult(0, "passed", "", 0.01), ) result = benchmark.run_trial( scenario, arm="ctx-light", treatment_level="ctx-light", attempt=1, trial=1, retry=0, cache=tmp_path / "cache", output=tmp_path / "output", codex="codex", model="gpt-test", timeout=10, dry_run=False, incidents=benchmark.IncidentLog(tmp_path / "incidents.csv"), catalog_snapshot=snapshot, ) lifecycle_path = Path(result["lifecycle_events"]) lifecycle_bytes = lifecycle_path.read_bytes() event_lines = lifecycle_bytes.splitlines(keepends=True) events = [json.loads(line) for line in event_lines] delivery_index = next( index for index, event in enumerate(events) if event.get("event_type") == "context_delivered" ) session_end_index = next( index for index, event in enumerate(events) if event.get("action") == "session_end" ) without_delivery = b"".join( line for line, event in zip(event_lines, events, strict=True) if event.get("event_type") != "context_delivered" ) without_session_end = b"".join(event_lines[:session_end_index]) assert delivery_index < session_end_index == len(events) - 1 assert result["lifecycle_sha256"] == hashlib.sha256(lifecycle_bytes).hexdigest() assert result["lifecycle_sha256"] != hashlib.sha256(without_delivery).hexdigest() assert result["lifecycle_sha256"] != hashlib.sha256(without_session_end).hexdigest() assert result["used_ids"] == [] assert result["skill_use_observed"] is None assert result["skill_use_evidence_unavailable_reason"] == ( "provider_does_not_expose_semantic_context_attribution" ) assert all(event.get("action") != "used" for event in events) @pytest.mark.parametrize( ("matching_tags", "reason", "efficiency_eligible", "evidence_level"), [ ( ["python"], "language_only_match", True, benchmark.PRODUCTION_POLICY_ABSTENTION_LEVEL, ), ( None, "insufficient_match_evidence", False, "production_catalog_ctx_noop", ), ], ) def test_production_catalog_live_abstention_is_policy_valid( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, matching_tags: object, reason: str, efficiency_eligible: bool, evidence_level: str, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] snapshot = _catalog_snapshot(tmp_path) selected_id = "skill:ctx-python-testing" candidate = { "id": selected_id, "name": "ctx-python-testing", "type": "skill", "installable": True, "matching_tags": matching_tags, } policy_abstention = { "candidate_id": selected_id, **benchmark.classify_catalog_match_evidence(candidate, language="python"), } catalog = { "query": scenario.query, "candidates": [candidate], "candidate_ids": [selected_id], "context_policy": {"initial_load": [selected_id]}, "policy_field": "initial_load", "policy_initial_load_ids": [selected_id], "deferred_activation": { "decision": "deny", "selected_ids": [], "reason": "no_deferred_candidates", "deferred_candidates": [], }, "selected_item": None, "selected_ids": [], "body_provenance": None, "policy_abstention": policy_abstention, "selection_skip_reason": reason, "recommendation_response_sha256": "d" * 64, "recommendation_seconds": 0.01, "body_fetch_seconds": 0.0, "surface_seconds": 0.01, } def fake_prepare( _scenario: object, _cache: Path, destination: Path, *, include_evaluator_test: bool, ) -> str: assert include_evaluator_test is False destination.mkdir(parents=True) return hashlib.sha256(scenario.test_body.encode("utf-8")).hexdigest() def fake_process(command: list[str], **_kwargs: object) -> Any: if command[0] == "codex": stdout = "\n".join( [ json.dumps({"type": "turn.started"}), json.dumps( { "type": "turn.completed", "usage": { "input_tokens": 12, "cached_input_tokens": 2, "output_tokens": 3, }, } ), ] ) return benchmark.CommandResult(0, stdout, "", 0.25) return benchmark.CommandResult(0, "", "", 0.01) def fake_prepare_home(home: Path, **_kwargs: object) -> Path: home.mkdir(parents=True) return home monkeypatch.setattr(benchmark, "prepare_workspace", fake_prepare) monkeypatch.setattr(benchmark, "bind_catalog_snapshot", lambda *_args: None) monkeypatch.setattr( benchmark, "recommend_production_catalog", lambda *_args, **_kwargs: catalog, ) monkeypatch.setattr(benchmark, "prepare_isolated_codex_home", fake_prepare_home) monkeypatch.setattr( benchmark, "verify_agent_sandbox_isolation", lambda **_kwargs: {"verified": True}, ) monkeypatch.setattr(benchmark, "run_process", fake_process) monkeypatch.setattr( benchmark, "_verify_pinned_head", lambda *_args: benchmark.CommandResult(0, "", "", 0.01), ) monkeypatch.setattr( benchmark, "verify_workspace", lambda *_args: benchmark.CommandResult(0, "passed", "", 0.01), ) result = benchmark.run_trial( scenario, arm="ctx-light", treatment_level="ctx-light", attempt=1, trial=1, retry=0, cache=tmp_path / "cache", output=tmp_path / "output", codex="codex", model="gpt-test", timeout=10, dry_run=False, incidents=benchmark.IncidentLog(tmp_path / "incidents.csv"), catalog_snapshot=snapshot, ) assert result["status"] == "passed" assert result["policy_valid"] is True assert result["production_efficiency_eligible"] is efficiency_eligible assert result["evidence_level"] == evidence_level assert result["policy_abstention_applied"] is True assert result["policy_abstention_verified"] is efficiency_eligible assert result["policy_abstention_reason"] == reason assert result["catalog_recommendation_lifecycle_verified"] is True assert result["context_delivery_verified"] is False assert result["task_prompt_sha256"] == result["delivered_prompt_sha256"] assert result["selected_ids"] == result["delivered_ids"] == result["used_ids"] == [] assert result["body_fetch_seconds"] == 0.0 assert result["lifecycle_actions"] == ["dev_event", "session_end"] assert result["final_loaded"] == [] def test_catalog_archive_validation_rejects_traversal(tmp_path: Path) -> None: archive = tmp_path / "wiki-graph.tar.gz" with tarfile.open(archive, "w:gz") as tf: member = tarfile.TarInfo("../outside.txt") payload = b"escape" member.size = len(payload) tf.addfile(member, io.BytesIO(payload)) with pytest.raises(ValueError, match="unsafe graph archive path"): benchmark.validate_catalog_archive(archive) def _write_runtime_availability( path: Path, *, content: str, version: int = 1, ) -> None: path.write_text( json.dumps( { "version": version, "entries": [ { "id": "skill:ctx-python-testing", "files": [ { "path": "converted/ctx-python-testing/SKILL.md", "content": content, } ], } ], } ) + "\n", encoding="utf-8", ) def test_remove_catalog_staging_makes_read_only_files_writable( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: staging = tmp_path / "staging" frozen = staging / "nested" / "catalog.json" frozen.parent.mkdir(parents=True) frozen.write_text("{}\n", encoding="utf-8") frozen.chmod(0o400) real_rmtree = benchmark.shutil.rmtree def checked_rmtree(path: Path) -> None: assert frozen.stat().st_mode & benchmark.stat.S_IWUSR real_rmtree(path) monkeypatch.setattr(benchmark.shutil, "rmtree", checked_rmtree) benchmark._remove_catalog_staging(staging) assert not staging.exists() def test_production_catalog_cache_uses_shipped_installer_once( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: archive = tmp_path / "wiki-graph.tar.gz" with tarfile.open(archive, "w:gz") as tf: member = tarfile.TarInfo("index.md") payload = b"# catalog\n" member.size = len(payload) tf.addfile(member, io.BytesIO(payload)) availability = tmp_path / "runtime-availability.json" runtime_content = "source: ctx-runtime-availability\n" _write_runtime_availability(availability, content=runtime_content) monkeypatch.setattr(benchmark, "PRODUCTION_RUNTIME_AVAILABILITY", availability) install_calls: list[Path] = [] def install(claude_dir: Path, *, archive: Path) -> int: assert archive == tmp_path / "wiki-graph.tar.gz" install_calls.append(claude_dir) wiki = claude_dir / "skill-wiki" graph = wiki / "graphify-out" runtime_skill = wiki / "converted" / "ctx-python-testing" / "SKILL.md" graph.mkdir(parents=True) runtime_skill.parent.mkdir(parents=True) (graph / "graph-export-manifest.json").write_text( json.dumps({"version": 1, "export_id": "frozen-export"}), encoding="utf-8", ) (graph / "entity-overlays.jsonl").write_text( json.dumps( { "overlay_id": "ctx-runtime-availability-v1", "source": "ctx-runtime-availability", } ) + "\n", encoding="utf-8", ) (graph / "graph-store.sqlite3").write_bytes(b"graph-store") runtime_skill.write_bytes(runtime_content.encode("utf-8")) return 0 monkeypatch.setattr(benchmark, "_install_shipped_catalog", install) cache_root = tmp_path / "cache" first = benchmark.prepare_production_catalog(cache_root, archive=archive) second = benchmark.prepare_production_catalog(cache_root, archive=archive) assert len(install_calls) == 1 assert first.cache_hit is False assert second.cache_hit is True assert first.wiki_dir == second.wiki_dir assert first.provenance["installer"] == "ctx_init.build_graph" assert first.provenance["install_mode"] == "runtime" assert first.provenance["archive_sha256"] == hashlib.sha256(archive.read_bytes()).hexdigest() assert ( first.provenance["runtime_availability_sha256"] == hashlib.sha256(availability.read_bytes()).hexdigest() ) assert first.provenance["graph_export_id"] == "frozen-export" assert first.provenance["overlay_records"] == [ { "overlay_id": "ctx-runtime-availability-v1", "source": "ctx-runtime-availability", } ] assert first.provenance["runtime_availability_files"] == [ { "path": "converted/ctx-python-testing/SKILL.md", "sha256": hashlib.sha256(runtime_content.encode()).hexdigest(), "size_bytes": len(runtime_content.encode()), } ] assert not first.wiki_dir.stat().st_mode & 0o222 _write_runtime_availability(availability, content=runtime_content, version=2) third = benchmark.prepare_production_catalog(cache_root, archive=archive) assert len(install_calls) == 2 assert third.cache_hit is False assert third.wiki_dir != first.wiki_dir benchmark._remove_catalog_staging(cache_root / "production-catalog") def test_production_catalog_cache_rejects_content_tampering( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: archive = tmp_path / "wiki-graph.tar.gz" with tarfile.open(archive, "w:gz") as tf: member = tarfile.TarInfo("index.md") payload = b"# catalog\n" member.size = len(payload) tf.addfile(member, io.BytesIO(payload)) availability = tmp_path / "runtime-availability.json" runtime_content = "# testing\n" _write_runtime_availability(availability, content=runtime_content) monkeypatch.setattr(benchmark, "PRODUCTION_RUNTIME_AVAILABILITY", availability) def install(claude_dir: Path, *, archive: Path) -> int: assert archive.is_file() wiki = claude_dir / "skill-wiki" graph = wiki / "graphify-out" skill = wiki / "converted" / "ctx-python-testing" / "SKILL.md" graph.mkdir(parents=True) skill.parent.mkdir(parents=True) (graph / "graph-export-manifest.json").write_text( json.dumps({"export_id": "frozen-export"}), encoding="utf-8", ) (graph / "entity-overlays.jsonl").write_text( json.dumps({"overlay_id": "runtime"}) + "\n", encoding="utf-8", ) (graph / "graph-store.sqlite3").write_bytes(b"graph-store") skill.write_bytes(runtime_content.encode("utf-8")) return 0 monkeypatch.setattr(benchmark, "_install_shipped_catalog", install) cache_root = tmp_path / "cache" snapshot = benchmark.prepare_production_catalog(cache_root, archive=archive) skill = snapshot.wiki_dir / "converted" / "ctx-python-testing" / "SKILL.md" skill.chmod(0o600) skill.write_text("# tampered\n", encoding="utf-8") skill.chmod(0o440) with pytest.raises(ValueError, match="does not match availability pack"): benchmark.prepare_production_catalog(cache_root, archive=archive) benchmark._remove_catalog_staging(snapshot.wiki_dir.parents[1]) def test_production_catalog_rejects_installer_availability_mismatch( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: archive = tmp_path / "wiki-graph.tar.gz" with tarfile.open(archive, "w:gz") as tf: member = tarfile.TarInfo("index.md") member.size = 0 tf.addfile(member, io.BytesIO()) availability = tmp_path / "runtime-availability.json" _write_runtime_availability(availability, content="# expected\n") monkeypatch.setattr(benchmark, "PRODUCTION_RUNTIME_AVAILABILITY", availability) def install(claude_dir: Path, *, archive: Path) -> int: assert archive.is_file() wiki = claude_dir / "skill-wiki" graph = wiki / "graphify-out" skill = wiki / "converted" / "ctx-python-testing" / "SKILL.md" graph.mkdir(parents=True) skill.parent.mkdir(parents=True) (graph / "graph-export-manifest.json").write_text( json.dumps({"export_id": "frozen-export"}), encoding="utf-8", ) (graph / "entity-overlays.jsonl").write_text( json.dumps({"overlay_id": "runtime"}) + "\n", encoding="utf-8", ) (graph / "graph-store.sqlite3").write_bytes(b"graph-store") skill.write_bytes(b"# expected\r\n") return 0 monkeypatch.setattr(benchmark, "_install_shipped_catalog", install) with pytest.raises(ValueError, match="does not match availability pack"): benchmark.prepare_production_catalog(tmp_path / "cache", archive=archive) def test_incident_log_appends_machine_readable_rows(tmp_path: Path) -> None: path = tmp_path / "incidents.csv" incidents = benchmark.IncidentLog(path) incidents.add( scenario="click-echo-json", arm="ctx-light", attempt=1, stage="verification", failure_class="evaluator", message="focused test failed", root_cause="official evaluator returned exit 1", repro="rerun the frozen evaluator command", risk="quality could be scored incorrectly", fix="repair the evaluator boundary and rerun", evidence="exit 1", ) with path.open(newline="", encoding="utf-8") as fh: rows = list(csv.DictReader(fh)) assert rows[0]["scenario"] == "click-echo-json" assert rows[0]["failure_class"] == "evaluator" assert rows[0]["risk"] == "quality could be scored incorrectly" assert rows[0]["fix"] == "repair the evaluator boundary and rerun" assert rows[0]["status"] == "open" assert rows[0]["incident_id"].startswith("inc-") assert rows[0]["fix_commit"] == "pending" assert rows[0]["rerun_of"] == "initial-run" assert rows[0]["protocol_id"] == "legacy-unfrozen" assert rows[0]["protocol_invalidation"] == "not_applicable" assert rows[0]["protocol_invalidation_reason"] duplicate_path = tmp_path / "duplicate-incidents.csv" duplicate = benchmark.IncidentLog(duplicate_path) duplicate.add( scenario="click-echo-json", arm="ctx-light", attempt=1, stage="verification", failure_class="evaluator", message="different diagnostic prose", root_cause="same incident identity", repro="same repro", evidence="new evidence", ) with duplicate_path.open(newline="", encoding="utf-8") as fh: duplicate_row = next(csv.DictReader(fh)) assert duplicate_row["incident_id"] == rows[0]["incident_id"] assert ( incidents.resolve_attempts( scenario="click-echo-json", arm="ctx-light", attempts={1}, resolved_by=2, ) == 1 ) assert incidents.unresolved_count() == 0 with path.open(newline="", encoding="utf-8") as fh: resolved = list(csv.DictReader(fh)) assert resolved[0]["status"] == "resolved" assert resolved[0]["fix_commit"] == "recovered-without-code-change" assert resolved[0]["rerun_of"] == resolved[0]["incident_id"] assert "recovered by attempt 2" in resolved[0]["evidence"] def test_incident_log_fails_closed_on_incomplete_protocol_linkage(tmp_path: Path) -> None: path = tmp_path / "incidents.csv" incidents = benchmark.IncidentLog(path) with pytest.raises(ValueError, match="linkage fields"): incidents.add( scenario="owner__repo", arm="baseline", attempt=1, stage="verification", failure_class="model", message="no patch", root_cause="model returned no patch", repro="run the frozen assignment", evidence="empty patch", protocol_id="production-graph-holdout-v2", protocol_invalidation="not_invalidated", protocol_invalidation_reason="", ) incidents.add( scenario="owner__repo", arm="baseline", attempt=1, stage="verification", failure_class="model", message="no patch", root_cause="model returned no patch", repro="run the frozen assignment", evidence="empty patch", protocol_id="production-graph-holdout-v2", protocol_invalidation="not_invalidated", status="observed", ) with path.open(newline="", encoding="utf-8") as fh: rows = list(csv.DictReader(fh)) rows[0]["fix_commit"] = "" with path.open("w", newline="", encoding="utf-8") as fh: writer = csv.DictWriter(fh, fieldnames=benchmark.INCIDENT_FIELDS) writer.writeheader() writer.writerows(rows) assert incidents.unresolved_count() == 1 def _sealed_production_rows( rows: list[dict[str, Any]], ) -> list[dict[str, Any]]: sealed: list[dict[str, Any]] = [] for row in rows: result = benchmark._VerifiedProductionResult( { **row, "repository_state_matches_start_at_end": True, "environment_manifest_matches_start_at_end": True, } ) result.seal() sealed.append(result) return sealed def test_production_summary_stays_pending_until_final_attestation(tmp_path: Path) -> None: result = benchmark._VerifiedProductionResult( { "scenario": "scenario", "arm": "baseline", "trial": 1, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "passed", "production_efficiency_eligible": True, "total_seconds": 1.0, "token_attribution": "exact", "total_tokens": 10, } ) with pytest.raises(RuntimeError, match="before final attestation"): result.seal() benchmark.write_summary(tmp_path, [result]) pending = json.loads((tmp_path / "summary.json").read_text(encoding="utf-8")) assert pending[0]["production_efficiency_eligible"] is False assert pending[0]["evidence_level"] == "attestation_pending" assert json.loads((tmp_path / "aggregate.json").read_text(encoding="utf-8")) == [] result["repository_state_matches_start_at_end"] = True result["environment_manifest_matches_start_at_end"] = True result.seal() benchmark.write_summary(tmp_path, [result]) final = json.loads((tmp_path / "summary.json").read_text(encoding="utf-8")) assert final[0]["production_efficiency_eligible"] is True assert json.loads((tmp_path / "aggregate.json").read_text(encoding="utf-8")) == [ { "scenario": "scenario", "arm": "baseline", "trial": 1, "attempts": 1, "first_attempt_passed": True, "eventual_passed": True, "retries_used": 0, "cumulative_seconds": 1.0, "cumulative_exact_tokens": 10, } ] def test_production_summary_preserves_failed_attestation_reason(tmp_path: Path) -> None: result = benchmark._VerifiedProductionResult( { "scenario": "scenario", "arm": "baseline", "trial": 1, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "passed", "production_efficiency_eligible": False, "evidence_level": "run_attestation_changed", "repository_state_matches_start_at_end": False, "environment_manifest_matches_start_at_end": True, } ) benchmark.write_summary(tmp_path, [result]) summary = json.loads((tmp_path / "summary.json").read_text(encoding="utf-8")) assert summary[0]["production_efficiency_eligible"] is False assert summary[0]["evidence_level"] == "run_attestation_changed" assert json.loads((tmp_path / "aggregate.json").read_text(encoding="utf-8")) == [] def test_performance_gate_rejects_slow_evidence_run() -> None: def rows(light_ratio: float) -> list[dict[str, object]]: values: list[dict[str, object]] = [] for trial in range(1, 7): for arm, ratio in (("baseline", 1.0), ("ctx-light", light_ratio)): values.append( { "scenario": "scenario", "arm": arm, "trial": trial, "status": "passed", "measured_phase_seconds": 10 * ratio, "total_seconds": 10 * ratio, "token_attribution": "exact", "total_tokens": int(1000 * ratio), "uncached_input_tokens": int(800 * ratio), "team_token_completeness": "not_applicable", "production_efficiency_eligible": True, } ) return values passing = benchmark.build_performance_report( rows(1.05), scenario_ids=["scenario"], trials=6, arms=("baseline", "ctx-light"), ) failing = benchmark.build_performance_report( rows(100.0), scenario_ids=["scenario"], trials=6, arms=("baseline", "ctx-light"), ) incomplete_rows = rows(1.0) incomplete_rows[0]["team_token_completeness"] = "unknown" incomplete = benchmark.build_performance_report( incomplete_rows, scenario_ids=["scenario"], trials=6, arms=("baseline", "ctx-light"), ) assert passing["gate_passed"] is True assert passing["median_time_ratio"] == 1.05 assert failing["gate_passed"] is False assert failing["status"] == "failed" assert incomplete["gate_passed"] is False assert incomplete["evidence_complete"] is False def test_production_catalog_benefit_verdict_is_stricter_than_non_regression() -> None: def rows(time_ratio: float, token_ratio: float) -> list[dict[str, Any]]: values: list[dict[str, Any]] = [] for trial in range(1, 7): for arm, seconds, tokens in ( ("baseline", 10.0, 1000), ("ctx-light", 10.0 * time_ratio, int(1000 * token_ratio)), ): values.append( { "scenario": "scenario", "arm": arm, "trial": trial, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "passed", "repo_url": "https://example.test/repo.git", "measured_phase_seconds": seconds, "total_seconds": seconds, "token_attribution": "exact", "total_tokens": tokens, "uncached_input_tokens": tokens, "team_token_completeness": "not_applicable", "production_efficiency_eligible": True, "evaluator_isolation_verified": True, "context_delivery_verified": arm == "ctx-light", } ) return _sealed_production_rows(values) beneficial = benchmark.build_performance_report( rows(0.85, 1.05), scenario_ids=["scenario"], trials=6, arms=("baseline", "ctx-light"), ) non_regressing = benchmark.build_performance_report( rows(1.05, 1.05), scenario_ids=["scenario"], trials=6, arms=("baseline", "ctx-light"), ) tradeoff_too_large = benchmark.build_performance_report( rows(0.80, 1.11), scenario_ids=["scenario"], trials=6, arms=("baseline", "ctx-light"), ) assert beneficial["gate_passed"] is True assert beneficial["benefit_verdict"] == "beneficial" assert beneficial["beneficial"] is True assert non_regressing["gate_passed"] is True assert non_regressing["benefit_verdict"] == "not_beneficial" assert non_regressing["beneficial"] is False assert tradeoff_too_large["gate_passed"] is False assert tradeoff_too_large["benefit_verdict"] == "not_beneficial" def test_production_report_keeps_asymmetric_failure_in_intent_to_treat() -> None: rows: list[dict[str, Any]] = [] for trial in range(1, 7): for arm in ("baseline", "ctx-light"): rows.append( { "scenario": "scenario", "repo_url": "https://example.test/repo.git", "arm": arm, "trial": trial, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "failed" if arm == "ctx-light" and trial == 3 else "passed", "measured_phase_seconds": 10.0, "harness_total_seconds": 11.0, "token_attribution": "exact", "total_tokens": 1000, "uncached_input_tokens": 800, "team_token_completeness": "not_applicable", "production_efficiency_eligible": True, "evaluator_isolation_verified": True, "context_delivery_verified": arm == "ctx-light", } ) report = benchmark.build_performance_report( _sealed_production_rows(rows), scenario_ids=["scenario"], trials=6, arms=("baseline", "ctx-light"), ) assert report["assignment_complete"] is True assert report["intent_to_treat"]["baseline"]["pass_rate"] == 1.0 assert report["intent_to_treat"]["ctx-light"]["pass_rate"] == pytest.approx(5 / 6) assert report["quality_preserved"] is False assert report["benefit_verdict"] == "not_beneficial" assert report["beneficial"] is False def test_production_report_scores_verified_abstention_as_policy_overhead_only() -> None: prompt_hash = "a" * 64 rows: list[dict[str, Any]] = [] for trial in range(1, 7): rows.append( { "scenario": "scenario", "repo_url": "https://github.com/example/repo.git", "arm": "baseline", "trial": trial, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "passed", "measured_phase_seconds": 10.0, "harness_total_seconds": 10.5, "token_attribution": "exact", "total_tokens": 1000, "uncached_input_tokens": 800, "team_token_completeness": "not_applicable", "production_efficiency_eligible": True, "evaluator_isolation_verified": True, } ) rows.append( { "scenario": "scenario", "repo_url": "https://github.com/example/repo.git", "arm": "ctx-light", "trial": trial, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "passed", "measured_phase_seconds": 10.1, "harness_total_seconds": 10.6, "token_attribution": "exact", "total_tokens": 1005, "uncached_input_tokens": 804, "team_token_completeness": "not_applicable", "production_efficiency_eligible": True, "evaluator_isolation_verified": True, "context_delivery_verified": False, "policy_abstention_applied": True, "policy_abstention_verified": True, "policy_abstention_reason": "language_only_match", "evidence_level": benchmark.PRODUCTION_POLICY_ABSTENTION_LEVEL, "policy_valid": True, "selected_ids": [], "delivered_ids": [], "adopted_ids": [], "used_ids": [], "task_prompt_sha256": prompt_hash, "delivered_prompt_sha256": prompt_hash, "body_fetch_seconds": 0.0, "lifecycle_actions": ["dev_event", "session_end"], "lifecycle_session_status": "passed", "catalog_recommendation_lifecycle_verified": True, "pinned_head_verified": True, "repository_state_matches_start_at_end": True, "environment_manifest_matches_start_at_end": True, } ) forged = benchmark.build_performance_report( rows, scenario_ids=["scenario"], trials=6, arms=("baseline", "ctx-light"), ) sealed_rows = _sealed_production_rows(rows) report = benchmark.build_performance_report( sealed_rows, scenario_ids=["scenario"], trials=6, arms=("baseline", "ctx-light"), expected_repositories={ "scenario": "https://github.com/example/repo.git", }, ) tampered_rows = _sealed_production_rows(rows) tampered_rows[1]["total_tokens"] = 999999 tampered = benchmark.build_performance_report( tampered_rows, scenario_ids=["scenario"], trials=6, arms=("baseline", "ctx-light"), ) assert forged["production_efficiency_claim_allowed"] is False assert forged["ctx_policy_outcomes"]["verified_abstentions"] == 0 assert forged["ctx_policy_outcomes"]["untrusted_assignments"] == 6 assert tampered["production_efficiency_claim_allowed"] is False assert tampered["ctx_policy_outcomes"]["verified_abstentions"] == 5 assert tampered["ctx_policy_outcomes"]["untrusted_assignments"] == 1 assert tampered["ctx_policy_outcomes"]["abstention_rate"] == pytest.approx(5 / 6) assert report["production_efficiency_claim_allowed"] is True assert report["evidence_complete"] is True assert report["gate_passed"] is True assert report["beneficial"] is None assert report["benefit_verdict"] == "policy_abstention_only" assert report["product_benefit_verdict"] == "insufficient_cross_repo_evidence" assert report["ctx_policy_outcomes"] == { "assigned": 6, "context_delivered": 0, "verified_abstentions": 6, "unverified_noops": 0, "untrusted_assignments": 0, "activation_rate": 0.0, "abstention_rate": 1.0, } def test_policy_activation_rate_rejects_post_seal_mutation() -> None: rows = _sealed_production_rows( [ { "scenario": "scenario", "arm": "baseline", "trial": 1, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "passed", "measured_phase_seconds": 10.0, "harness_total_seconds": 10.5, "token_attribution": "exact", "total_tokens": 1000, "uncached_input_tokens": 800, "team_token_completeness": "not_applicable", "production_efficiency_eligible": True, "evaluator_isolation_verified": True, }, { "scenario": "scenario", "arm": "ctx-light", "trial": 1, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "passed", "measured_phase_seconds": 9.0, "harness_total_seconds": 9.5, "token_attribution": "exact", "total_tokens": 900, "uncached_input_tokens": 700, "team_token_completeness": "not_applicable", "production_efficiency_eligible": True, "evaluator_isolation_verified": True, "context_delivery_verified": True, }, ] ) rows[1]["total_tokens"] = 899 report = benchmark.build_performance_report( rows, scenario_ids=["scenario"], trials=1, arms=("baseline", "ctx-light"), ) assert report["ctx_policy_outcomes"] == { "assigned": 1, "context_delivered": 0, "verified_abstentions": 0, "unverified_noops": 0, "untrusted_assignments": 1, "activation_rate": 0.0, "abstention_rate": 0.0, } def test_product_claim_requires_exact_complete_expected_schedule() -> None: scenario_ids = [f"scenario-{index}" for index in range(6)] expected_repositories = { scenario: f"https://github.com/example/repo-{index % 5}.git" for index, scenario in enumerate(scenario_ids) } rows: list[dict[str, Any]] = [ { "scenario": scenario, "repo_url": expected_repositories[scenario], "arm": arm, "trial": trial, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "passed", "measured_phase_seconds": 10.0, "harness_total_seconds": 10.5, "token_attribution": "exact", "total_tokens": 1000, "uncached_input_tokens": 800, "team_token_completeness": "not_applicable", "production_efficiency_eligible": True, "evaluator_isolation_verified": True, "context_delivery_verified": arm == "ctx-light", } for index, scenario in enumerate(scenario_ids) for trial in range(1, 7) for arm in ("baseline", "ctx-light") ] control = benchmark.build_performance_report( _sealed_production_rows(rows), scenario_ids=scenario_ids, trials=6, arms=("baseline", "ctx-light"), expected_repositories=expected_repositories, ) rows.append( { **rows[-1], "scenario": "unexpected", "repo_url": "https://github.com/example/repo-extra.git", "trial": 6, } ) report = benchmark.build_performance_report( _sealed_production_rows(rows), scenario_ids=scenario_ids, trials=6, arms=("baseline", "ctx-light"), expected_repositories=expected_repositories, ) assert control["product_claim_eligible"] is True assert report["assignment_complete"] is False assert report["evidence_complete"] is False assert report["gate_passed"] is False assert report["product_claim_eligible"] is False assert report["claim_scope"] == "scenario_set_only" assert report["distinct_repository_count"] == 5 assert report["ctx_policy_outcomes"]["assigned"] == 36 def test_product_claim_accepts_complete_five_repository_schedule() -> None: scenario_ids = [f"scenario-{index}" for index in range(6)] expected_repositories = { scenario: f"https://github.com/example/repo-{index % 5}.git" for index, scenario in enumerate(scenario_ids) } rows: list[dict[str, Any]] = [ { "scenario": scenario, "repo_url": f"https://github.com/example/repo-{index % 5}.git", "arm": arm, "trial": trial, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "passed", "measured_phase_seconds": 10.0, "harness_total_seconds": 10.5, "token_attribution": "exact", "total_tokens": 1000, "uncached_input_tokens": 800, "team_token_completeness": "not_applicable", "production_efficiency_eligible": True, "evaluator_isolation_verified": True, "context_delivery_verified": arm == "ctx-light", } for index, scenario in enumerate(scenario_ids) for trial in range(1, 7) for arm in ("baseline", "ctx-light") ] report = benchmark.build_performance_report( _sealed_production_rows(rows), scenario_ids=scenario_ids, trials=6, arms=("baseline", "ctx-light"), expected_repositories=expected_repositories, ) missing_repository_rows = [dict(row) for row in rows] missing_repository_rows[0]["repo_url"] = "" missing_repository = benchmark.build_performance_report( _sealed_production_rows(missing_repository_rows), scenario_ids=scenario_ids, trials=6, arms=("baseline", "ctx-light"), expected_repositories=expected_repositories, ) retry_relabelled_rows = [ *rows, { **rows[0], "repo_url": "https://github.com/example/relabelled.git", }, ] retry_relabelled = benchmark.build_performance_report( _sealed_production_rows(retry_relabelled_rows), scenario_ids=scenario_ids, trials=6, arms=("baseline", "ctx-light"), expected_repositories=expected_repositories, ) malformed_mapping = { **expected_repositories, scenario_ids[0]: "not-a-github-url", } malformed = benchmark.build_performance_report( _sealed_production_rows(rows), scenario_ids=scenario_ids, trials=6, arms=("baseline", "ctx-light"), expected_repositories=malformed_mapping, ) aliased_scenario = scenario_ids[4] aliased_repository = "https://github.com/EXAMPLE/REPO-0.git" aliased_mapping = { **expected_repositories, aliased_scenario: aliased_repository, } aliased_rows = [ { **row, "repo_url": ( aliased_repository if row["scenario"] == aliased_scenario else row["repo_url"] ), } for row in rows ] aliased = benchmark.build_performance_report( _sealed_production_rows(aliased_rows), scenario_ids=scenario_ids, trials=6, arms=("baseline", "ctx-light"), expected_repositories=aliased_mapping, ) assert report["assignment_complete"] is True assert report["evidence_complete"] is True assert report["product_claim_eligible"] is True assert report["claim_scope"] == "product_pilot" assert report["distinct_repository_count"] == 5 assert report["product_beneficial"] is False assert report["product_benefit_verdict"] == "not_beneficial" assert report["repository_cluster_analysis"]["benefit_support_p_value"] == 1.0 assert missing_repository["product_claim_eligible"] is False assert missing_repository["repository_cluster_analysis"]["complete"] is False assert retry_relabelled["product_claim_eligible"] is False assert retry_relabelled["repository_identity"]["verified_for_all_attempts"] is False assert malformed["product_claim_eligible"] is False assert malformed["repository_identity"]["predeclared_mapping_valid"] is False assert aliased["product_claim_eligible"] is False assert aliased["repository_identity"]["predeclared_mapping_valid"] is False assert aliased["repository_cluster_analysis"]["benefit_support_p_value"] is None def test_product_claim_rejects_three_repository_pseudoreplication() -> None: scenario_ids = [f"scenario-{index}" for index in range(6)] rows: list[dict[str, Any]] = [] for index, scenario in enumerate(scenario_ids): for trial in range(1, 7): for arm, ratio in (("baseline", 1.0), ("ctx-light", 0.8)): rows.append( { "scenario": scenario, "repo_url": f"https://github.com/example/repo-{index % 3}.git", "arm": arm, "trial": trial, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "passed", "measured_phase_seconds": 10.0 * ratio, "harness_total_seconds": 10.5 * ratio, "token_attribution": "exact", "total_tokens": int(1000 * ratio), "uncached_input_tokens": int(800 * ratio), "team_token_completeness": "not_applicable", "production_efficiency_eligible": True, "evaluator_isolation_verified": True, "context_delivery_verified": arm == "ctx-light", } ) report = benchmark.build_performance_report( _sealed_production_rows(rows), scenario_ids=scenario_ids, trials=6, arms=("baseline", "ctx-light"), expected_repositories={ scenario: f"https://github.com/example/repo-{index % 3}.git" for index, scenario in enumerate(scenario_ids) }, ) cluster = report["repository_cluster_analysis"] assert report["benefit_verdict"] == "beneficial" assert report["product_claim_eligible"] is False assert report["product_benefit_verdict"] == "insufficient_cross_repo_evidence" assert cluster["complete"] is False assert cluster["independent_repository_count"] == 3 assert cluster["benefit_support_count"] == 3 assert cluster["benefit_support_p_value"] == 0.125 assert cluster["repeated_trials_count_as_independent_units"] is False def test_product_claim_requires_repository_cluster_support() -> None: repositories = [ "https://github.com/example/repo-a.git", "https://github.com/example/repo-b.git", "https://github.com/example/repo-c.git", "https://github.com/example/repo-d.git", "https://github.com/example/repo-e.git", ] scenario_repositories = [repositories[0]] * 5 + repositories[1:] scenario_ids = [f"scenario-{index}" for index in range(len(scenario_repositories))] rows: list[dict[str, Any]] = [] for scenario, repository in zip(scenario_ids, scenario_repositories, strict=True): ctx_ratio = 0.8 if repository == repositories[0] else 1.0 for trial in range(1, 7): for arm, ratio in (("baseline", 1.0), ("ctx-light", ctx_ratio)): rows.append( { "scenario": scenario, "repo_url": repository, "arm": arm, "trial": trial, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "passed", "measured_phase_seconds": 10.0 * ratio, "harness_total_seconds": 10.5 * ratio, "token_attribution": "exact", "total_tokens": int(1000 * ratio), "uncached_input_tokens": int(800 * ratio), "team_token_completeness": "not_applicable", "production_efficiency_eligible": True, "evaluator_isolation_verified": True, "context_delivery_verified": arm == "ctx-light", } ) report = benchmark.build_performance_report( _sealed_production_rows(rows), scenario_ids=scenario_ids, trials=6, arms=("baseline", "ctx-light"), expected_repositories=dict(zip(scenario_ids, scenario_repositories, strict=True)), ) cluster = report["repository_cluster_analysis"] assert report["median_time_ratio"] == 0.8 assert report["benefit_verdict"] == "beneficial" assert report["product_claim_eligible"] is True assert report["product_beneficial"] is False assert report["product_benefit_verdict"] == "not_beneficial" assert cluster["complete"] is True assert cluster["benefit_support_count"] == 1 assert cluster["benefit_support_p_value"] == 0.96875 def test_product_claim_accepts_consistent_five_repository_benefit() -> None: scenario_ids = [f"scenario-{index}" for index in range(6)] rows: list[dict[str, Any]] = [] for index, scenario in enumerate(scenario_ids): for trial in range(1, 7): for arm, ratio in (("baseline", 1.0), ("ctx-light", 0.8)): rows.append( { "scenario": scenario, "repo_url": f"https://github.com/example/repo-{index % 5}.git", "arm": arm, "trial": trial, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "passed", "measured_phase_seconds": 10.0 * ratio, "harness_total_seconds": 10.5 * ratio, "token_attribution": "exact", "total_tokens": int(1000 * ratio), "uncached_input_tokens": int(800 * ratio), "team_token_completeness": "not_applicable", "production_efficiency_eligible": True, "evaluator_isolation_verified": True, "context_delivery_verified": arm == "ctx-light", } ) report = benchmark.build_performance_report( _sealed_production_rows(rows), scenario_ids=scenario_ids, trials=6, arms=("baseline", "ctx-light"), expected_repositories={ scenario: f"https://github.com/example/repo-{index % 5}.git" for index, scenario in enumerate(scenario_ids) }, ) cluster = report["repository_cluster_analysis"] assert report["product_claim_eligible"] is True assert report["product_beneficial"] is True assert report["product_benefit_verdict"] == "beneficial" assert cluster["benefit_support_count"] == 5 assert cluster["benefit_support_p_value"] == 0.03125 def test_production_report_excludes_ctx_noop_and_missing_measured_phase() -> None: common = { "scenario": "scenario", "repo_url": "https://example.test/repo.git", "trial": 1, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "passed", "token_attribution": "exact", "total_tokens": 100, "uncached_input_tokens": 80, "team_token_completeness": "not_applicable", "production_efficiency_eligible": True, "evaluator_isolation_verified": True, } rows = [ { **common, "arm": "baseline", "total_seconds": 10.0, }, { **common, "arm": "ctx-light", "measured_phase_seconds": 9.0, "total_seconds": 9.0, "context_delivery_verified": False, "evidence_level": "production_catalog_ctx_noop", }, ] report = benchmark.build_performance_report( rows, scenario_ids=["scenario"], trials=1, arms=("baseline", "ctx-light"), ) assert report["production_efficiency_claim_allowed"] is False assert report["excluded_result_count"] == 2 assert report["pairs"][0]["reason"] == "paired evidence ineligible" def test_repository_drift_evidence_is_ineligible_for_product_claims() -> None: scenario_ids = [f"scenario-{index}" for index in range(6)] rows = [ { "scenario": scenario, "repo_url": f"https://example.test/repo-{index % 3}.git", "arm": arm, "trial": 1, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "status": "passed", "measured_phase_seconds": 1.0, "total_seconds": 1.0, "token_attribution": "exact", "total_tokens": 10, "uncached_input_tokens": 8, "team_token_completeness": "not_applicable", "production_efficiency_eligible": False, "evidence_level": "run_attestation_changed", "repository_state_matches_start_at_end": False, "environment_manifest_matches_start_at_end": True, "evaluator_isolation_verified": True, "context_delivery_verified": arm == "ctx-light", } for index, scenario in enumerate(scenario_ids) for arm in ("baseline", "ctx-light") ] report = benchmark.build_performance_report( rows, scenario_ids=scenario_ids, trials=3, arms=("baseline", "ctx-light"), ) assert report["status"] == "functional_only" assert report["production_efficiency_claim_allowed"] is False assert report["excluded_result_count"] == 12 assert report["excluded_evidence_levels"] == ["run_attestation_changed"] assert report["product_claim_eligible"] is False assert report["claim_scope"] == "scenario_set_only" def test_unverified_custom_endpoint_evidence_is_excluded_from_efficiency_aggregates( tmp_path: Path, ) -> None: classification = benchmark.classify_production_evidence( base_url="http://127.0.0.1:8000/v1", dry_run=False, ) rows = [ { "scenario": "scenario", "arm": arm, "trial": 1, "status": "passed", "measured_phase_seconds": 1.0, "total_seconds": 1.0, "token_attribution": "exact", "total_tokens": 10, **classification, } for arm in ("baseline", "ctx-light") ] report = benchmark.build_performance_report( rows, scenario_ids=["scenario"], trials=1, arms=("baseline", "ctx-light"), ) benchmark.write_summary(tmp_path, rows) assert classification == { "endpoint_class": "custom_endpoint", "evidence_level": "functional_only", "production_efficiency_eligible": False, } assert report["status"] == "functional_only" assert report["production_efficiency_claim_allowed"] is False assert report["gate_passed"] is None assert report["excluded_result_count"] == 2 assert report["median_time_ratio"] is None assert json.loads((tmp_path / "aggregate.json").read_text(encoding="utf-8")) == [] assert len(json.loads((tmp_path / "summary.json").read_text(encoding="utf-8"))) == 2 def test_verified_custom_endpoint_evidence_is_efficiency_eligible() -> None: assert benchmark.classify_production_evidence( base_url="https://provider.example/v1", dry_run=False, provider_provenance={ "provider_identity_verified": True, "provider_endpoint_verified": True, "provider_authentication_verified": True, "provider_response_success": True, }, ) == { "endpoint_class": "custom_endpoint", "evidence_level": "live_provider", "production_efficiency_eligible": True, } def test_codex_controlled_evidence_never_claims_shipped_provider_proof() -> None: assert benchmark.classify_codex_controlled_evidence(dry_run=False) == { "endpoint_class": "codex_controlled", "evidence_level": "controlled_context_delivery", "production_efficiency_eligible": False, } assert benchmark.classify_codex_controlled_evidence(dry_run=True) == { "endpoint_class": "codex_controlled", "evidence_level": "controlled_wiring_only", "production_efficiency_eligible": False, } def test_codex_production_catalog_evidence_is_scored_only_for_live_runs() -> None: assert benchmark.classify_codex_production_catalog_evidence(dry_run=False) == { "endpoint_class": "codex_cli_oauth", "evidence_level": "production_catalog_context_delivery", "production_efficiency_eligible": True, } assert benchmark.classify_codex_production_catalog_evidence(dry_run=True) == { "endpoint_class": "codex_cli_oauth", "evidence_level": "production_catalog_wiring_only", "production_efficiency_eligible": False, } def test_codex_controlled_dry_run_result_is_explicitly_non_production( tmp_path: Path, monkeypatch: pytest.MonkeyPatch ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] def fake_prepare(_scenario: object, _cache: Path, destination: Path) -> str: destination.mkdir(parents=True) return "test-hash" monkeypatch.setattr(benchmark, "prepare_workspace", fake_prepare) result = benchmark.run_trial( scenario, arm="baseline", treatment_level="baseline", attempt=1, trial=1, retry=0, cache=tmp_path / "cache", output=tmp_path / "output", codex="codex", model="gpt-test", timeout=10, dry_run=True, incidents=benchmark.IncidentLog(tmp_path / "incidents.csv"), ) assert result["engine"] == "codex-controlled" assert result["endpoint_class"] == "codex_controlled" assert result["evidence_level"] == "controlled_wiring_only" assert result["production_efficiency_eligible"] is False def test_codex_controlled_empty_context_fails_before_workspace_setup( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], context=(), ) def workspace_setup_forbidden(*_args: object, **_kwargs: object) -> str: raise AssertionError("workspace setup must not run for invalid controlled context") monkeypatch.setattr(benchmark, "prepare_workspace", workspace_setup_forbidden) with pytest.raises(ValueError, match="require skill and agent context"): benchmark.run_trial( scenario, arm="baseline", treatment_level="baseline", attempt=1, trial=1, retry=0, cache=tmp_path / "cache", output=tmp_path / "output", codex="codex", model="gpt-test", timeout=10, dry_run=True, incidents=benchmark.IncidentLog(tmp_path / "incidents.csv"), ) assert not (tmp_path / "output").exists() def test_invalid_treatment_fails_before_workspace_or_codex( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] def side_effect_forbidden(*_args: object, **_kwargs: object) -> object: raise AssertionError("invalid treatment must fail before external work") monkeypatch.setattr(benchmark, "prepare_workspace", side_effect_forbidden) monkeypatch.setattr(benchmark, "run_process", side_effect_forbidden) with pytest.raises(ValueError, match="unsupported treatment level"): benchmark.run_trial( scenario, arm="baseline", treatment_level="unknown", attempt=1, trial=1, retry=0, cache=tmp_path / "cache", output=tmp_path / "output", codex="codex", model="gpt-test", timeout=10, dry_run=False, incidents=benchmark.IncidentLog(tmp_path / "incidents.csv"), ) assert not (tmp_path / "output").exists() def test_official_arm_mismatch_fails_before_workspace_or_codex( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: holdout_root = tmp_path / "holdout" holdout_root.mkdir() holdout, _ = _official_holdout_fixture(holdout_root) scenario = holdout.scenarios[0] def side_effect_forbidden(*_args: object, **_kwargs: object) -> object: raise AssertionError("arm mismatch must fail before external work") monkeypatch.setattr(benchmark, "prepare_official_workspace", side_effect_forbidden) monkeypatch.setattr(benchmark, "run_process", side_effect_forbidden) with pytest.raises(ValueError, match="arm does not match"): benchmark.run_trial( scenario, arm="baseline", treatment_level="ctx-light", attempt=1, trial=1, retry=0, cache=tmp_path / "cache", output=tmp_path / "output", codex="codex", model="gpt-5.5", timeout=900, dry_run=False, incidents=benchmark.IncidentLog(tmp_path / "incidents.csv"), catalog_snapshot=benchmark.CatalogSnapshot(tmp_path / "catalog", {}), official_holdout=holdout, official_runtime=benchmark.OfficialVerifierRuntime( dataset_path=tmp_path / "dataset.jsonl", swebench_checkout=tmp_path / "swebench", swebench_python=tmp_path / "swebench-python", docker_cli=tmp_path / "docker", docker_host="unix:///tmp/docker.sock", ), official_source=holdout.source_bundles[scenario.repo_url], ) assert not (tmp_path / "output").exists() def test_codex_controlled_dry_run_is_accepted_as_complete() -> None: result = { "scenario": "scenario-a", "arm": "baseline", "trial": 1, "status": "wiring_only", "evidence_level": "controlled_wiring_only", } assert benchmark.dry_run_results_complete( [result], expected_keys={("scenario-a", "baseline", 1)}, engine="codex-controlled", ) assert not benchmark.dry_run_results_complete( [{**result, "evidence_level": "wiring_only"}], expected_keys={("scenario-a", "baseline", 1)}, engine="codex-controlled", ) def test_production_catalog_dry_run_requires_catalog_evidence_level() -> None: result = { "scenario": "scenario-a", "arm": "baseline", "trial": 1, "status": "wiring_only", "evidence_level": "production_catalog_wiring_only", } assert benchmark.dry_run_results_complete( [result], expected_keys={("scenario-a", "baseline", 1)}, engine=benchmark.PRODUCTION_CATALOG_ENGINE, ) def test_no_base_url_and_success_do_not_infer_live_provider() -> None: assert benchmark.classify_production_evidence( base_url=None, dry_run=False, provider_provenance={ "provider_identity": "openai", "provider_identity_verified": False, "provider_endpoint_verified": False, "provider_authentication_verified": False, "provider_response_success": True, }, ) == { "endpoint_class": "provider_default_unverified", "evidence_level": "functional_unverified", "production_efficiency_eligible": False, } assert benchmark.classify_production_evidence(base_url=None, dry_run=False) == { "endpoint_class": "provider_default_unverified", "evidence_level": "functional_unverified", "production_efficiency_eligible": False, } def test_aggregation_excludes_missing_and_error_eligibility(tmp_path: Path) -> None: rows = [ { "scenario": "eligible", "arm": "baseline", "trial": 1, "status": "passed", "measured_phase_seconds": 1.0, "total_seconds": 1.0, "token_attribution": "exact", "total_tokens": 10, "production_efficiency_eligible": True, }, { "scenario": "missing", "arm": "baseline", "trial": 1, "status": "failed", "total_seconds": 2.0, "token_attribution": "unavailable", }, { "scenario": "error", "arm": "baseline", "trial": 1, "status": "harness_error", "evidence_level": "harness_error", "production_efficiency_eligible": False, "provider_response_success": False, }, ] benchmark.write_summary(tmp_path, rows) aggregate = json.loads((tmp_path / "aggregate.json").read_text(encoding="utf-8")) report = benchmark.build_performance_report( rows, scenario_ids=["eligible"], trials=1, arms=("baseline",), ) assert [row["scenario"] for row in aggregate] == ["eligible"] assert report["production_efficiency_claim_allowed"] is False assert report["excluded_result_count"] == 2 def test_codex_command_keeps_control_flags_equal(tmp_path: Path) -> None: baseline = benchmark.codex_command( codex="codex", model="model", workspace=tmp_path, prompt="task", with_ctx=False, runtime_contract=CODEX_RUNTIME_CONTRACT, ) treated = benchmark.codex_command( codex="codex", model="model", workspace=tmp_path, prompt="task", with_ctx=True, runtime_contract=CODEX_RUNTIME_CONTRACT, ) assert treated[treated.index("exec") :] == baseline[baseline.index("exec") :] assert baseline[:5] == ["codex", "-a", "never", "--disable", "multi_agent"] assert treated[:5] == ["codex", "-a", "never", "--enable", "multi_agent"] assert baseline[5:7] == ["-c", 'web_search="disabled"'] assert 'model_provider="openai"' in baseline for command in (baseline, treated): assert command.count('model_reasoning_effort="high"') == 1 assert command.count("model_auto_compact_token_limit=200000") == 1 assert "--ephemeral" in baseline assert "--ignore-user-config" in baseline assert "ctx-wiki" not in " ".join(baseline) treated_config = " ".join(treated) assert "ctx-wiki" in treated_config assert 'default_tools_approval_mode="approve"' in treated_config assert 'enabled_tools=["ctx__wiki_get"]' in treated_config assert "mcp_servers.ctx-wiki.required=true" in treated_config with pytest.raises(ValueError, match="frozen OpenAI provider"): benchmark.codex_command( codex="codex", model="model", workspace=tmp_path, prompt="task", with_ctx=False, provider="other", ) mismatched = {**CODEX_RUNTIME_CONTRACT, "arms": ["ctx-light", "baseline"]} with pytest.raises(ValueError, match="arm mismatch"): benchmark.codex_command( codex="codex", model="model", workspace=tmp_path, prompt="task", with_ctx=False, runtime_contract=mismatched, ) def test_agent_command_uses_isolated_named_profile(tmp_path: Path) -> None: workspace = tmp_path / "repo" home = tmp_path / "home" workspace.mkdir() home.mkdir() command = benchmark.codex_command( codex="codex", model="model", workspace=workspace, prompt="task", with_ctx=False, agent_home=home, isolate_evaluator=True, ) assert command[:5] == ["codex", "-a", "never", "--disable", "multi_agent"] assert command[command.index("exec") + 1] == "--strict-config" assert "--ignore-user-config" not in command assert "--sandbox" not in command assert command[-1] == "task" assert 'web_search="disabled"' in command def test_isolated_codex_home_denies_credentials_oracles_and_network( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: original = tmp_path / "original-codex" original.mkdir() (original / "auth.json").write_text('{"token":"secret"}\n', encoding="utf-8") monkeypatch.setattr(benchmark, "ORIGINAL_CODEX_HOME", str(original)) workspace = tmp_path / "repo" workspace.mkdir() forbidden = tmp_path / "private-scenarios.yaml" forbidden.write_text("oracle\n", encoding="utf-8") home = tmp_path / "agent-home" benchmark.prepare_isolated_codex_home( home, workspace=workspace, forbidden_reads={ "scenario_source": forbidden, "same_scenario_from_frozen_inputs": forbidden, }, ) config = (home / "config.toml").read_text(encoding="utf-8") parsed = tomllib.loads(config) assert 'default_permissions = "ctx_benchmark"' in config assert f'{json.dumps(str(workspace))} = "write"' in config assert f'{benchmark._toml_key(forbidden)} = "deny"' in config assert config.count(f'{benchmark._toml_key(forbidden)} = "deny"') == 1 assert parsed["permissions"]["ctx_benchmark"]["filesystem"][str(forbidden.resolve())] == "deny" assert f'{benchmark._toml_key(home / "auth.json")} = "deny"' in config assert f'{benchmark._toml_key(home / "config.toml")} = "deny"' in config assert "[permissions.ctx_benchmark.network]\nenabled = false" in config assert home.stat().st_mode & 0o777 == 0o700 assert (home / "auth.json").stat().st_mode & 0o777 == 0o600 assert (home / "config.toml").stat().st_mode & 0o777 == 0o600 def test_production_agent_env_prefers_checkout_and_neutralizes_color_flags( tmp_path: Path, ) -> None: home = tmp_path / "codex-home" workspace = tmp_path / "repo" env = benchmark.production_agent_env( {"PATH": "/usr/bin", "NO_COLOR": "1", "FORCE_COLOR": "1"}, home=home, workspace=workspace, ) assert env["PYTHONPATH"].split(os.pathsep) == [ str(workspace / "src"), str(workspace), ] assert env["NO_COLOR"] == "" assert env["FORCE_COLOR"] == "" assert env["PYTEST_DISABLE_PLUGIN_AUTOLOAD"] == "1" assert env["PATH"].split(os.pathsep)[0] == str(Path(sys.executable).parent) def test_agent_sandbox_preflight_requires_allowed_write_and_denied_oracle( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: workspace = tmp_path / "repo" home = tmp_path / "home" forbidden = tmp_path / "private" / "reference.patch" workspace.mkdir() home.mkdir() forbidden.parent.mkdir() (workspace / "source.py").write_text("VALUE = 1\n", encoding="utf-8") forbidden.write_text("secret\n", encoding="utf-8") (home / "auth.json").write_text("secret\n", encoding="utf-8") (home / "config.toml").write_text("profile\n", encoding="utf-8") observed: list[list[str]] = [] sensitive = {forbidden, home / "auth.json", home / "config.toml"} def fake_run(argv: list[str], **_kwargs: object) -> object: observed.append(argv) if "/usr/bin/touch" in argv: Path(argv[-1]).touch() return benchmark.CommandResult(0, "", "", 0.01) if Path(argv[-1]) in sensitive: return benchmark.CommandResult(1, "", "Operation not permitted", 0.01) return benchmark.CommandResult(0, "", "", 0.01) monkeypatch.setattr(benchmark, "run_process", fake_run) monkeypatch.setattr( benchmark, "_probe_loopback_network", lambda **_kwargs: { "parent_returncode": 0, "parent_connected": True, "sandbox_returncode": 1, "sandbox_connected": False, }, ) evidence = benchmark.verify_agent_sandbox_isolation( codex="codex", workspace=workspace, home=home, env={}, forbidden_reads={"oracle": forbidden}, project_check=("python", "-m", "pytest", "-q"), ) assert evidence["verified"] is True assert all(argv[argv.index("-P") + 1] == "ctx_benchmark" for argv in observed) assert evidence["git_canary_returncode"] == 0 assert evidence["project_canary_returncode"] == 0 assert evidence["network"] == "restricted" assert evidence["network_canary_returncode"] == 1 assert evidence["forbidden_reads"] == [ {"label": "credentials", "denied": True, "returncode": 1}, {"label": "sandbox_config", "denied": True, "returncode": 1}, {"label": "oracle", "denied": True, "returncode": 1}, ] assert str(forbidden) not in json.dumps(evidence) def test_agent_sandbox_preflight_rejects_unrelated_command_failure( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: workspace = tmp_path / "repo" home = tmp_path / "home" forbidden = tmp_path / "private-scenarios.yaml" workspace.mkdir() home.mkdir() (workspace / "source.py").write_text("VALUE = 1\n", encoding="utf-8") forbidden.write_text("oracle\n", encoding="utf-8") (home / "auth.json").write_text("secret\n", encoding="utf-8") (home / "config.toml").write_text("profile\n", encoding="utf-8") def fake_run(argv: list[str], **_kwargs: object) -> object: if "/usr/bin/touch" in argv: Path(argv[-1]).touch() return benchmark.CommandResult(0, "", "", 0.01) if argv[-1] == str(workspace / "source.py"): return benchmark.CommandResult(0, "", "", 0.01) return benchmark.CommandResult(1, "", "No such file or directory", 0.01) monkeypatch.setattr(benchmark, "run_process", fake_run) monkeypatch.setattr( benchmark, "_probe_loopback_network", lambda **_kwargs: { "parent_returncode": 0, "parent_connected": True, "sandbox_returncode": 1, "sandbox_connected": False, }, ) with pytest.raises(RuntimeError, match="isolation preflight failed"): benchmark.verify_agent_sandbox_isolation( codex="codex", workspace=workspace, home=home, env={}, forbidden_reads={"scenario_source": forbidden}, project_check=("python", "-m", "pytest", "-q"), ) def test_production_output_must_use_private_gate_root() -> None: private_output = benchmark.PRODUCTION_PRIVATE_RUN_ROOT / "unit-run" platform_temp = Path(tempfile.gettempdir()) / "private-scenarios.yaml" assert benchmark._validate_production_output_path(private_output) == private_output.resolve() assert benchmark._is_system_temp_path(platform_temp) assert not benchmark._is_system_temp_path(Path("/opt/ctx/private-scenarios.yaml")) with pytest.raises(ValueError, match="system temporary"): benchmark._validate_production_scenarios_path(platform_temp, live=False) with pytest.raises(ValueError, match="output must be beneath"): benchmark._validate_production_output_path(Path("/tmp/ctx-ab-run")) def test_live_production_scenarios_are_private_and_owner_only( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: private_root = tmp_path / "private" private_root.mkdir() private_root.chmod(0o700) source = private_root / "scenarios.yaml" source.write_text("version: 1\nscenarios: []\n", encoding="utf-8") source.chmod(0o600) monkeypatch.setattr(benchmark, "PRODUCTION_PRIVATE_SCENARIO_ROOT", private_root) monkeypatch.setattr(benchmark, "_is_system_temp_path", lambda _path: False) assert benchmark._validate_production_scenarios_path(source, live=True) == source.resolve() source.chmod(0o644) with pytest.raises(ValueError, match="owner-only"): benchmark._validate_production_scenarios_path(source, live=True) private_root.chmod(0o755) with pytest.raises(ValueError, match="root must be an owner-only directory"): benchmark._validate_production_scenarios_path(source, live=True) private_root.chmod(0o700) with pytest.raises(ValueError, match="must be beneath"): benchmark._validate_production_scenarios_path(tmp_path / "public.yaml", live=True) def test_live_production_requires_clean_committed_harness() -> None: dirty = {"clean": False, "status": [" M scripts/ctx_ab_benchmark.py"]} with pytest.raises(ValueError, match="clean committed harness"): benchmark.require_clean_production_repository(dirty, live=True) benchmark.require_clean_production_repository(dirty, live=False) benchmark.require_clean_production_repository({"clean": True, "status": []}, live=True) def test_final_repository_attestation_detects_mid_run_drift( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: initial = { "head": "a" * 40, "clean": True, "status": [], "tracked_diff_sha256": hashlib.sha256(b"").hexdigest(), } final = { "head": "a" * 40, "clean": False, "status": [" M scripts/ctx_ab_benchmark.py"], "tracked_diff_sha256": hashlib.sha256(b"diff").hexdigest(), } initial_manifest = {"repository_state": initial, "model": "gpt-test"} (tmp_path / "environment.json").write_bytes( (json.dumps(initial_manifest, indent=2) + "\n").encode("utf-8") ) monkeypatch.setattr(benchmark, "collect_repository_state", lambda: final) state_matches, manifest_matches, observed = benchmark.write_final_repository_attestation( tmp_path, initial, initial_manifest, ) manifest_bytes = (tmp_path / "environment.json").read_bytes() manifest = json.loads(manifest_bytes) assert b"\r\n" not in manifest_bytes assert state_matches is False assert manifest_matches is True assert observed == final assert manifest["repository_state_end"] == final assert manifest["repository_state_matches_start_at_end"] is False assert manifest["environment_manifest_matches_start_at_end"] is True def test_final_repository_attestation_rejects_valid_manifest_tampering( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: state = { "head": "a" * 40, "clean": True, "status": [], "tracked_diff_sha256": hashlib.sha256(b"").hexdigest(), } initial_manifest = { "repository_state": state, "model": "gpt-original", "scenarios_sha256": "b" * 64, } tampered = { **initial_manifest, "model": "gpt-tampered", "scenarios_sha256": "c" * 64, } (tmp_path / "environment.json").write_text( json.dumps(tampered, indent=2) + "\n", encoding="utf-8", ) monkeypatch.setattr(benchmark, "collect_repository_state", lambda: state) state_matches, manifest_matches, observed = benchmark.write_final_repository_attestation( tmp_path, state, initial_manifest, ) manifest = json.loads((tmp_path / "environment.json").read_text(encoding="utf-8")) assert state_matches is True assert manifest_matches is False assert observed == state assert manifest["model"] == "gpt-original" assert manifest["scenarios_sha256"] == "b" * 64 assert manifest["environment_manifest_matches_start_at_end"] is False def test_evaluator_controls_scrub_solved_workspaces_and_reference_patch( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] def fake_prepare( _scenario: object, _cache: Path, workspace: Path, **_kwargs: object, ) -> str: workspace.mkdir(parents=True) (workspace / "marker.txt").write_text("workspace\n", encoding="utf-8") return "test-hash" monkeypatch.setattr(benchmark, "prepare_workspace", fake_prepare) monkeypatch.setattr( benchmark, "_focused_verification", lambda *_args, **_kwargs: benchmark.CommandResult( 1, scenario.red_failure_contains, "", 0.1, ), ) monkeypatch.setattr( benchmark, "verify_workspace", lambda *_args, **_kwargs: benchmark.CommandResult(0, "passed\n", "", 0.2), ) monkeypatch.setattr( benchmark, "run_process", lambda *_args, **_kwargs: benchmark.CommandResult(0, "", "", 0.01), ) result = benchmark.validate_evaluator_controls( scenario, cache=tmp_path / "cache", output=tmp_path / "output", ) controls = tmp_path / "output" / scenario.id / "controls" assert result["status"] == "passed" assert (controls / "control.json").is_file() assert not (controls / "reference.patch").exists() assert not (controls / "reference").exists() assert not (controls / "red").exists() def test_isolated_codex_home_cleanup_removes_credentials_and_rejects_symlink( tmp_path: Path, ) -> None: home = tmp_path / "codex-home" home.mkdir() (home / "auth.json").write_text("secret\n", encoding="utf-8") benchmark.remove_isolated_codex_home(home) assert not home.exists() target = tmp_path / "target" target.mkdir() home.symlink_to(target, target_is_directory=True) with pytest.raises(RuntimeError, match="replaced by a symlink"): benchmark.remove_isolated_codex_home(home) assert target.is_dir() assert not home.exists() def test_pinned_head_guard_rejects_agent_commit(tmp_path: Path) -> None: workspace = tmp_path / "repo" workspace.mkdir() subprocess.run(["git", "init", "-q"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.email", "ctx@example.test"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.name", "ctx benchmark"], cwd=workspace, check=True) source = workspace / "source.py" source.write_text("VALUE = 1\n", encoding="utf-8") subprocess.run(["git", "add", "source.py"], cwd=workspace, check=True) subprocess.run(["git", "commit", "-qm", "parent"], cwd=workspace, check=True) pinned = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout.strip() scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], commit=pinned, ) assert benchmark._verify_pinned_head(scenario, workspace).returncode == 0 source.write_text("VALUE = 2\n", encoding="utf-8") subprocess.run(["git", "commit", "-qam", "agent commit"], cwd=workspace, check=True) result = benchmark._verify_pinned_head(scenario, workspace) assert result.returncode == 1 assert "agent changed pinned HEAD" in result.stderr def test_tracked_evaluator_test_is_reconstructed_only_from_pristine_base( tmp_path: Path, ) -> None: workspace = tmp_path / "repo" workspace.mkdir() subprocess.run(["git", "init", "-q"], cwd=workspace, check=True) subprocess.run(["git", "config", "core.autocrlf", "false"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.email", "ctx@example.test"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.name", "ctx benchmark"], cwd=workspace, check=True) source = workspace / "source.py" source.write_text("VALUE = 1\n", encoding="utf-8") tests = workspace / "tests" tests.mkdir() evaluator_test = tests / "test_feature.py" evaluator_test.write_text("def test_old():\n assert True\n", encoding="utf-8") subprocess.run(["git", "add", "."], cwd=workspace, check=True) subprocess.run(["git", "commit", "-qm", "parent"], cwd=workspace, check=True) pinned = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout.strip() scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], commit=pinned, test_path="tests/test_feature.py", test_body="def test_new():\n assert True\n", allowed_changes=("source.py",), ) expected_hash = hashlib.sha256(scenario.test_body.encode()).hexdigest() benchmark.materialize_evaluator_test( scenario, workspace, expected_hash=expected_hash, require_pristine=True, ) source.write_text("VALUE = 2\n", encoding="utf-8") assert ( benchmark._materialize_untracked_changes(scenario, workspace, expected_hash).returncode == 0 ) subprocess.run( ["git", "checkout", "--detach", "--force", pinned], cwd=workspace, check=True, capture_output=True, ) evaluator_test.write_text("def test_agent_change():\n assert False\n", encoding="utf-8") with pytest.raises(RuntimeError, match="agent changed"): benchmark.materialize_evaluator_test( scenario, workspace, expected_hash=expected_hash, require_pristine=True, ) def test_tracked_evaluator_rejects_cached_only_mutation(tmp_path: Path) -> None: workspace = tmp_path / "repo" workspace.mkdir() subprocess.run(["git", "init", "-q"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.email", "ctx@example.test"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.name", "ctx benchmark"], cwd=workspace, check=True) evaluator_test = workspace / "test_feature.py" base_body = "def test_old():\n assert True\n" evaluator_test.write_text(base_body, encoding="utf-8") subprocess.run(["git", "add", "."], cwd=workspace, check=True) subprocess.run(["git", "commit", "-qm", "parent"], cwd=workspace, check=True) pinned = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout.strip() scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], commit=pinned, test_path="test_feature.py", test_body="def test_hidden():\n assert True\n", ) expected_hash = hashlib.sha256(scenario.test_body.encode()).hexdigest() evaluator_test.write_text("def test_staged():\n assert False\n", encoding="utf-8") subprocess.run(["git", "add", "test_feature.py"], cwd=workspace, check=True) evaluator_test.write_text(base_body, encoding="utf-8") with pytest.raises(RuntimeError, match="git index"): benchmark.materialize_evaluator_test( scenario, workspace, expected_hash=expected_hash, require_pristine=True, ) @pytest.mark.parametrize( "add_args", [("add",), ("add", "-N")], ids=("staged", "intent-to-add"), ) def test_untracked_evaluator_rejects_agent_index_entry( tmp_path: Path, add_args: tuple[str, ...], ) -> None: workspace = tmp_path / "repo" workspace.mkdir() subprocess.run(["git", "init", "-q"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.email", "ctx@example.test"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.name", "ctx benchmark"], cwd=workspace, check=True) source = workspace / "source.py" source.write_text("VALUE = 1\n", encoding="utf-8") subprocess.run(["git", "add", "source.py"], cwd=workspace, check=True) subprocess.run(["git", "commit", "-qm", "parent"], cwd=workspace, check=True) pinned = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout.strip() scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], commit=pinned, test_path="test_feature.py", test_body="def test_hidden():\n assert True\n", allowed_changes=("source.py",), ) expected_hash = hashlib.sha256(scenario.test_body.encode()).hexdigest() benchmark.materialize_evaluator_test( scenario, workspace, expected_hash=expected_hash, ) subprocess.run(["git", *add_args, "test_feature.py"], cwd=workspace, check=True) result = benchmark._materialize_untracked_changes(scenario, workspace, expected_hash) assert result.returncode == 1 assert "benchmark-owned test" in result.stderr assert "git index" in result.stderr def test_production_evaluator_rejects_deleted_intent_to_add_entry(tmp_path: Path) -> None: workspace = tmp_path / "repo" workspace.mkdir() subprocess.run(["git", "init", "-q"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.email", "ctx@example.test"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.name", "ctx benchmark"], cwd=workspace, check=True) source = workspace / "source.py" source.write_text("VALUE = 1\n", encoding="utf-8") subprocess.run(["git", "add", "source.py"], cwd=workspace, check=True) subprocess.run(["git", "commit", "-qm", "parent"], cwd=workspace, check=True) pinned = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout.strip() scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], commit=pinned, test_path="test_feature.py", test_body="def test_hidden():\n assert True\n", ) evaluator = workspace / scenario.test_path evaluator.write_text("agent placeholder\n", encoding="utf-8") subprocess.run(["git", "add", "-N", scenario.test_path], cwd=workspace, check=True) evaluator.unlink() with pytest.raises(RuntimeError, match="git index"): benchmark.materialize_evaluator_test( scenario, workspace, expected_hash=hashlib.sha256(scenario.test_body.encode()).hexdigest(), require_pristine=True, ) @pytest.mark.parametrize("flag", ["--assume-unchanged", "--skip-worktree"]) def test_tracked_evaluator_rejects_index_flag_hidden_mutation( tmp_path: Path, flag: str, ) -> None: workspace = tmp_path / "repo" workspace.mkdir() subprocess.run(["git", "init", "-q"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.email", "ctx@example.test"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.name", "ctx benchmark"], cwd=workspace, check=True) evaluator = workspace / "test_feature.py" evaluator.write_text("def test_base():\n assert True\n", encoding="utf-8") subprocess.run(["git", "add", "."], cwd=workspace, check=True) subprocess.run(["git", "commit", "-qm", "parent"], cwd=workspace, check=True) pinned = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout.strip() scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], commit=pinned, test_path="test_feature.py", test_body="def test_hidden():\n assert True\n", ) subprocess.run(["git", "update-index", flag, scenario.test_path], cwd=workspace, check=True) evaluator.write_text("def test_agent():\n assert False\n", encoding="utf-8") with pytest.raises(RuntimeError, match="agent changed"): benchmark.materialize_evaluator_test( scenario, workspace, expected_hash=hashlib.sha256(scenario.test_body.encode()).hexdigest(), require_pristine=True, ) def test_evaluator_pristine_check_fails_closed_on_git_error( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: workspace = tmp_path / "repo" workspace.mkdir() scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], test_path="test_feature.py", test_body="def test_hidden():\n assert True\n", ) monkeypatch.setattr( benchmark, "run_process", lambda *_args, **_kwargs: benchmark.CommandResult(128, "", "fatal: broken git", 0.0), ) with pytest.raises(RuntimeError, match="could not inspect"): benchmark.materialize_evaluator_test( scenario, workspace, expected_hash=hashlib.sha256(scenario.test_body.encode()).hexdigest(), require_pristine=True, ) def test_evaluator_test_rejects_symlink_escape(tmp_path: Path) -> None: workspace = tmp_path / "repo" workspace.mkdir() outside = tmp_path / "outside" outside.mkdir() (workspace / "tests").symlink_to(outside, target_is_directory=True) scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], test_path="tests/test_feature.py", test_body="def test_new():\n assert True\n", ) with pytest.raises(RuntimeError, match="unsafe component|escapes the workspace"): benchmark.materialize_evaluator_test( scenario, workspace, expected_hash=hashlib.sha256(scenario.test_body.encode()).hexdigest(), ) def test_focused_verification_rejects_evaluator_symlink(tmp_path: Path) -> None: workspace = tmp_path / "repo" workspace.mkdir() outside = tmp_path / "outside.py" body = "def test_hidden():\n assert True\n" outside.write_text(body, encoding="utf-8") (workspace / "test_feature.py").symlink_to(outside) scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], test_path="test_feature.py", test_body=body, ) result = benchmark._focused_verification( scenario, workspace, hashlib.sha256(body.encode()).hexdigest(), ) assert result.returncode == 1 assert "symlink" in result.stderr def test_evaluator_materialization_detects_parent_swap_without_external_write( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: workspace = tmp_path / "repo" workspace.mkdir() tests = workspace / "tests" tests.mkdir() outside = tmp_path / "outside" outside.mkdir() outside_test = outside / "test_feature.py" outside_test.write_text("outside sentinel\n", encoding="utf-8") scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], test_path="tests/test_feature.py", test_body="def test_hidden():\n assert True\n", ) original_replace = os.replace swapped = False def swap_parent_before_replace( source: str | bytes, destination: str | bytes, *, src_dir_fd: int | None = None, dst_dir_fd: int | None = None, ) -> None: nonlocal swapped if not swapped and src_dir_fd is not None and dst_dir_fd is not None: tests.rename(workspace / "original-tests") tests.symlink_to(outside, target_is_directory=True) swapped = True original_replace( source, destination, src_dir_fd=src_dir_fd, dst_dir_fd=dst_dir_fd, ) monkeypatch.setattr(os, "replace", swap_parent_before_replace) with pytest.raises(RuntimeError, match="unsafe component"): benchmark.materialize_evaluator_test( scenario, workspace, expected_hash=hashlib.sha256(scenario.test_body.encode()).hexdigest(), ) assert swapped assert outside_test.read_text(encoding="utf-8") == "outside sentinel\n" def _untracked_allowlist_fixture( tmp_path: Path, ) -> tuple[Path, Any, str]: workspace = tmp_path / "repo" workspace.mkdir() subprocess.run(["git", "init", "-q"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.email", "ctx@example.test"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.name", "ctx benchmark"], cwd=workspace, check=True) source = workspace / "source.py" source.write_text("VALUE = 1\n", encoding="utf-8") subprocess.run(["git", "add", "source.py"], cwd=workspace, check=True) subprocess.run(["git", "commit", "-qm", "parent"], cwd=workspace, check=True) pinned = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout.strip() scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], commit=pinned, test_path="test_feature.py", test_body="def test_hidden():\n assert True\n", allowed_changes=("source.py",), ) expected_hash = hashlib.sha256(scenario.test_body.encode()).hexdigest() benchmark.materialize_evaluator_test(scenario, workspace, expected_hash=expected_hash) return workspace, scenario, expected_hash @pytest.mark.parametrize("ignore_source", ["info-exclude", "core-excludes-file"]) def test_verification_rejects_ignored_untracked_disallowed_change( tmp_path: Path, ignore_source: str, ) -> None: workspace, scenario, expected_hash = _untracked_allowlist_fixture(tmp_path) if ignore_source == "info-exclude": (workspace / ".git/info/exclude").write_text("forbidden.py\n", encoding="utf-8") else: excludes = tmp_path / "global-ignore" excludes.write_text("forbidden.py\n", encoding="utf-8") subprocess.run( ["git", "config", "core.excludesFile", str(excludes)], cwd=workspace, check=True, ) (workspace / "forbidden.py").write_text("VALUE = 2\n", encoding="utf-8") result = benchmark._materialize_untracked_changes(scenario, workspace, expected_hash) assert result.returncode == 1 assert "changes outside scenario allowlist" in result.stderr assert "forbidden.py" in result.stderr def test_verification_accepts_ignored_untracked_allowed_change(tmp_path: Path) -> None: workspace, scenario, expected_hash = _untracked_allowlist_fixture(tmp_path) scenario = replace( scenario, allowed_changes=(*scenario.allowed_changes, "generated.py"), ) (workspace / ".git/info/exclude").write_text("generated.py\n", encoding="utf-8") (workspace / "generated.py").write_text("VALUE = 2\n", encoding="utf-8") result = benchmark._materialize_untracked_changes(scenario, workspace, expected_hash) assert result.returncode == 0 staged = subprocess.run( ["git", "diff", "--name-only"], cwd=workspace, check=True, capture_output=True, text=True, ) assert "generated.py" in staged.stdout.splitlines() def test_verification_rejects_ignored_untracked_change_before_project_tests( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: workspace, scenario, expected_hash = _untracked_allowlist_fixture(tmp_path) (workspace / ".git/info/exclude").write_text("forbidden.py\n", encoding="utf-8") (workspace / "forbidden.py").write_text("VALUE = 2\n", encoding="utf-8") project_test_called = False def reject_project_test(*_args: object, **_kwargs: object) -> Any: nonlocal project_test_called project_test_called = True raise AssertionError("project test ran before the allowlist preflight") monkeypatch.setattr(benchmark, "_run_verified", reject_project_test) result = benchmark.verify_workspace(scenario, workspace, expected_hash) assert result.returncode == 1 assert "forbidden.py" in result.stderr assert project_test_called is False def test_verification_ignores_mutable_core_worktree_config(tmp_path: Path) -> None: workspace, scenario, expected_hash = _untracked_allowlist_fixture(tmp_path) forbidden = workspace / "forbidden.py" forbidden.write_text("VALUE = 1\n", encoding="utf-8") subprocess.run(["git", "add", "forbidden.py"], cwd=workspace, check=True) subprocess.run(["git", "commit", "-qm", "tracked forbidden"], cwd=workspace, check=True) pinned = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout.strip() scenario = replace(scenario, commit=pinned) decoy = tmp_path / "decoy" decoy.mkdir() subprocess.run( ["git", "config", "core.worktree", str(decoy)], cwd=workspace, check=True, ) forbidden.write_text("VALUE = 2\n", encoding="utf-8") result = benchmark._materialize_untracked_changes(scenario, workspace, expected_hash) assert result.returncode == 1 assert "changes outside scenario allowlist" in result.stderr assert "forbidden.py" in result.stderr def test_verification_rejects_cached_only_disallowed_change(tmp_path: Path) -> None: workspace = tmp_path / "repo" workspace.mkdir() subprocess.run(["git", "init", "-q"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.email", "ctx@example.test"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.name", "ctx benchmark"], cwd=workspace, check=True) source = workspace / "source.py" source.write_text("VALUE = 1\n", encoding="utf-8") forbidden = workspace / "forbidden.py" forbidden.write_text("VALUE = 1\n", encoding="utf-8") subprocess.run(["git", "add", "."], cwd=workspace, check=True) subprocess.run(["git", "commit", "-qm", "parent"], cwd=workspace, check=True) pinned = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout.strip() scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], commit=pinned, test_path="test_feature.py", test_body="def test_hidden():\n assert True\n", allowed_changes=("source.py",), ) expected_hash = hashlib.sha256(scenario.test_body.encode()).hexdigest() benchmark.materialize_evaluator_test( scenario, workspace, expected_hash=expected_hash, ) forbidden.write_text("VALUE = 2\n", encoding="utf-8") subprocess.run(["git", "add", "forbidden.py"], cwd=workspace, check=True) forbidden.write_text("VALUE = 1\n", encoding="utf-8") result = benchmark._materialize_untracked_changes(scenario, workspace, expected_hash) assert result.returncode == 1 assert "changes outside scenario allowlist" in result.stderr assert "forbidden.py" in result.stderr @pytest.mark.parametrize("flag", ["--assume-unchanged", "--skip-worktree"]) def test_verification_rejects_index_flag_hidden_disallowed_change( tmp_path: Path, flag: str, ) -> None: workspace = tmp_path / "repo" workspace.mkdir() subprocess.run(["git", "init", "-q"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.email", "ctx@example.test"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.name", "ctx benchmark"], cwd=workspace, check=True) source = workspace / "source.py" source.write_text("VALUE = 1\n", encoding="utf-8") forbidden = workspace / "forbidden.py" forbidden.write_text("VALUE = 1\n", encoding="utf-8") subprocess.run(["git", "add", "."], cwd=workspace, check=True) subprocess.run(["git", "commit", "-qm", "parent"], cwd=workspace, check=True) pinned = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout.strip() scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], commit=pinned, test_path="test_feature.py", test_body="def test_hidden():\n assert True\n", allowed_changes=("source.py",), ) expected_hash = hashlib.sha256(scenario.test_body.encode()).hexdigest() benchmark.materialize_evaluator_test(scenario, workspace, expected_hash=expected_hash) subprocess.run(["git", "update-index", flag, "forbidden.py"], cwd=workspace, check=True) forbidden.write_text("VALUE = 2\n", encoding="utf-8") result = benchmark._materialize_untracked_changes(scenario, workspace, expected_hash) assert result.returncode == 1 assert "unsupported git index flags" in result.stderr assert "forbidden.py" in result.stderr def test_verification_accepts_staged_allowed_change(tmp_path: Path) -> None: workspace = tmp_path / "repo" workspace.mkdir() subprocess.run(["git", "init", "-q"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.email", "ctx@example.test"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.name", "ctx benchmark"], cwd=workspace, check=True) source = workspace / "source.py" source.write_text("VALUE = 1\n", encoding="utf-8") subprocess.run(["git", "add", "source.py"], cwd=workspace, check=True) subprocess.run(["git", "commit", "-qm", "parent"], cwd=workspace, check=True) pinned = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout.strip() scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], commit=pinned, test_path="test_feature.py", test_body="def test_hidden():\n assert True\n", allowed_changes=("source.py",), ) expected_hash = hashlib.sha256(scenario.test_body.encode()).hexdigest() benchmark.materialize_evaluator_test(scenario, workspace, expected_hash=expected_hash) source.write_text("VALUE = 2\n", encoding="utf-8") subprocess.run(["git", "add", "source.py"], cwd=workspace, check=True) result = benchmark._materialize_untracked_changes(scenario, workspace, expected_hash) assert result.returncode == 0 def test_verification_unions_staged_and_unstaged_allowed_changes(tmp_path: Path) -> None: workspace = tmp_path / "repo" workspace.mkdir() subprocess.run(["git", "init", "-q"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.email", "ctx@example.test"], cwd=workspace, check=True) subprocess.run(["git", "config", "user.name", "ctx benchmark"], cwd=workspace, check=True) staged = workspace / "staged.py" unstaged = workspace / "unstaged.py" staged.write_text("VALUE = 1\n", encoding="utf-8") unstaged.write_text("VALUE = 1\n", encoding="utf-8") subprocess.run(["git", "add", "."], cwd=workspace, check=True) subprocess.run(["git", "commit", "-qm", "parent"], cwd=workspace, check=True) pinned = subprocess.run( ["git", "rev-parse", "HEAD"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout.strip() scenario = replace( benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0], commit=pinned, test_path="test_feature.py", test_body="def test_hidden():\n assert True\n", allowed_changes=("staged.py", "unstaged.py"), ) expected_hash = hashlib.sha256(scenario.test_body.encode()).hexdigest() benchmark.materialize_evaluator_test(scenario, workspace, expected_hash=expected_hash) staged.write_text("VALUE = 2\n", encoding="utf-8") unstaged.write_text("VALUE = 2\n", encoding="utf-8") subprocess.run(["git", "add", "staged.py"], cwd=workspace, check=True) result = benchmark._materialize_untracked_changes(scenario, workspace, expected_hash) assert result.returncode == 0 assert "staged.py" in result.stdout assert "unstaged.py" in result.stdout def test_production_ctx_command_uses_shipped_cli_with_equal_controls(tmp_path: Path) -> None: common = { "model": "openai/model", "prompt": "task", "session_id": "session", "sessions_dir": tmp_path, "api_key_env": "MODEL_API_KEY", "base_url": "http://localhost:11434", "max_iterations": 7, "max_tokens": 2048, "provider_timeout": 45.0, } baseline = benchmark.production_ctx_command(with_ctx=False, **common) treated = benchmark.production_ctx_command(with_ctx=True, **common) surface_index = treated.index("--ctx-tool-surface") assert baseline[:-1] == treated[:surface_index] assert baseline[-1:] == ["--no-ctx-tools"] assert treated[surface_index : surface_index + 2] == ["--ctx-tool-surface", "adaptive"] assert [ treated[index + 1] for index, value in enumerate(treated) if value == "--allow-tool" ] == list(benchmark.PRODUCTION_CTX_TOOL_NAMES) mcp_index = treated.index("--mcp") assert treated[mcp_index + 1].startswith("ctx-benchmark-control:") assert "ctx.mcp_server.server" in treated[mcp_index + 1] assert baseline[:5] == [sys.executable, "-m", "ctx.cli.run", "run", "--model"] assert benchmark.build_parser().parse_args([]).engine == "codex-controlled" assert ( benchmark.build_parser().parse_args(["--engine", "production-ctx-run"]).engine == "production-ctx-run" ) assert ( benchmark.build_parser() .parse_args(["--engine", benchmark.PRODUCTION_CATALOG_ENGINE]) .engine == benchmark.PRODUCTION_CATALOG_ENGINE ) def test_production_usage_requires_exact_provider_counts() -> None: exact = benchmark.extract_production_usage( { "usage": { "tokens_reported": True, "input_tokens": 120, "cached_input_tokens": 20, "output_tokens": 30, "total_tokens": 150, } } ) assert exact["attribution"] == "exact" assert exact["uncached_input_tokens"] == 100 def test_provider_request_tool_surface_rejects_missing_and_extra_schemas() -> None: expected = benchmark.production_ctx_tool_schemas() exact = benchmark.validate_provider_request_tool_surface( {"tools": expected}, expected_tools=expected, ) assert exact["provider_request_tool_names"] == sorted(benchmark.PRODUCTION_CTX_TOOL_NAMES) assert len(exact["provider_request_tool_schema_sha256"]) == 64 assert ( benchmark.validate_provider_request_tool_surface( {}, expected_tools=[], )["provider_request_tool_names"] == [] ) with pytest.raises(ValueError, match="missing="): benchmark.validate_provider_request_tool_surface( {"tools": expected[:-1]}, expected_tools=expected, ) extra = [ *expected, { "type": "function", "function": { "name": "ctx__unexpected", "description": "unexpected", "parameters": {"type": "object"}, }, }, ] with pytest.raises(ValueError, match="extra="): benchmark.validate_provider_request_tool_surface( {"tools": extra}, expected_tools=expected, ) changed = json.loads(json.dumps(expected)) changed[0]["function"]["description"] = "changed" with pytest.raises(ValueError, match="schema mismatch"): benchmark.validate_provider_request_tool_surface( {"tools": changed}, expected_tools=expected, ) with pytest.raises(ValueError, match="did not report exact"): benchmark.extract_production_usage( { "usage": { "tokens_reported": False, "input_tokens": None, "output_tokens": None, "total_tokens": None, } } ) with pytest.raises(ValueError, match="inconsistent"): benchmark.extract_production_usage( { "usage": { "tokens_reported": True, "input_tokens": 10, "output_tokens": 5, "total_tokens": 99, } } ) def test_production_payload_requires_requested_successful_session() -> None: payload = { "session_id": "requested-session", "stop_reason": "completed", "usage": { "tokens_reported": True, "input_tokens": 10, "output_tokens": 5, "total_tokens": 15, }, } validated = benchmark.validate_production_payload( payload, session_id="requested-session", ) assert benchmark.extract_production_usage(validated)["total_tokens"] == 15 with pytest.raises(ValueError, match="does not match"): benchmark.validate_production_payload(payload, session_id="different-session") for stop_reason in ("max_iterations", "token_budget", "provider_error", None): with pytest.raises(ValueError, match="not successful"): benchmark.validate_production_payload( {**payload, "stop_reason": stop_reason}, session_id="requested-session", ) def test_provider_response_provenance_requires_a_successful_authenticated_response( tmp_path: Path, ) -> None: session_id = "provider-evidence" session_path = tmp_path / f"{session_id}.jsonl" events = [ { "type": "session_start", "session_id": session_id, "provider": "openai", "model": "openai/gpt-test", "api_key_env": "MODEL_API_KEY", "base_url": "", }, { "type": "model_response", "session_id": session_id, "provider": "litellm", "model": "openai/gpt-test", "response_model": "openai/gpt-test", "authentication_submitted": True, "request_endpoint_hash": None, "finish_reason": "stop", }, ] session_path.write_text( "".join(json.dumps(event) + "\n" for event in events), encoding="utf-8", ) evidence = benchmark.extract_provider_response_provenance( sessions_dir=tmp_path, session_id=session_id, model="openai/gpt-test", base_url=None, api_key_env="MODEL_API_KEY", env={"MODEL_API_KEY": "secret-value"}, ) assert evidence["provider_identity"] == "openai" assert evidence["provider_adapter"] == "litellm" assert evidence["provider_response_success"] is True assert evidence["provider_auth_mode"] == "api_key_env" assert ( evidence["provider_authentication_evidence"] == "credential_submitted_with_successful_response" ) assert evidence["provider_identity_verified"] is True assert evidence["provider_endpoint_verified"] is True assert evidence["provider_authentication_verified"] is True assert evidence["provider_request_authentication_submitted"] is True assert "secret-value" not in json.dumps(evidence) assert len(evidence["provider_session_sha256"]) == 64 def test_provider_key_presence_without_success_is_not_authentication_evidence( tmp_path: Path, ) -> None: session_id = "provider-failure" events = [ { "type": "session_start", "session_id": session_id, "provider": "openai", "model": "openai/gpt-test", "api_key_env": "MODEL_API_KEY", "base_url": "", }, { "type": "model_response", "session_id": session_id, "provider": "litellm", "model": "openai/gpt-test", "response_model": "openai/gpt-test", "authentication_submitted": True, "request_endpoint_hash": None, "finish_reason": "error", }, ] (tmp_path / f"{session_id}.jsonl").write_text( "".join(json.dumps(event) + "\n" for event in events), encoding="utf-8", ) evidence = benchmark.extract_provider_response_provenance( sessions_dir=tmp_path, session_id=session_id, model="openai/gpt-test", base_url=None, api_key_env="MODEL_API_KEY", env={"MODEL_API_KEY": "secret-value"}, ) assert evidence["provider_response_success"] is False assert evidence["provider_identity_verified"] is False assert evidence["provider_endpoint_verified"] is False assert evidence["provider_authentication_verified"] is False assert ( evidence["provider_authentication_evidence"] == "credential_submitted_without_successful_response" ) assert "secret-value" not in json.dumps(evidence) def test_successful_local_no_key_provider_remains_functional_only(tmp_path: Path) -> None: session_id = "local-no-key" model = "openai/local-test" base_url = "http://127.0.0.1:11434/v1" events = [ { "type": "session_start", "session_id": session_id, "provider": "openai", "model": model, "api_key_env": "", "base_url": base_url, }, { "type": "model_response", "session_id": session_id, "provider": "litellm", "model": model, "response_model": model, "authentication_submitted": False, "request_endpoint_hash": ( "sha256:" + hashlib.sha256(base_url.encode("utf-8")).hexdigest() ), "finish_reason": "stop", }, ] (tmp_path / f"{session_id}.jsonl").write_text( "".join(json.dumps(event) + "\n" for event in events), encoding="utf-8", ) evidence = benchmark.extract_provider_response_provenance( sessions_dir=tmp_path, session_id=session_id, model=model, base_url=base_url, api_key_env=None, env={}, ) assert evidence["provider_identity_verified"] is True assert evidence["provider_endpoint_verified"] is True assert evidence["provider_authentication_verified"] is False assert benchmark.classify_production_evidence( base_url=base_url, dry_run=False, provider_provenance=evidence, ) == { "endpoint_class": "custom_endpoint", "evidence_level": "functional_only", "production_efficiency_eligible": False, } def test_provider_reported_model_mismatch_does_not_verify_provider( tmp_path: Path, ) -> None: session_id = "unattested-provider" events = [ { "type": "session_start", "session_id": session_id, "provider": "openai", "model": "openai/gpt-test", "api_key_env": "MODEL_API_KEY", "base_url": "", }, { "type": "model_response", "session_id": session_id, "provider": "litellm", "model": "openai/gpt-test", "response_model": "provider-returned-different", "authentication_submitted": True, "request_endpoint_hash": None, "finish_reason": "stop", }, ] (tmp_path / f"{session_id}.jsonl").write_text( "".join(json.dumps(event) + "\n" for event in events), encoding="utf-8", ) evidence = benchmark.extract_provider_response_provenance( sessions_dir=tmp_path, session_id=session_id, model="openai/gpt-test", base_url=None, api_key_env="MODEL_API_KEY", env={"MODEL_API_KEY": "secret-value"}, ) assert evidence["provider_response_success"] is True assert evidence["provider_identity_verified"] is False assert evidence["provider_authentication_verified"] is True assert evidence["provider_request_authentication_submitted"] is True assert ( benchmark.classify_production_evidence( base_url=None, dry_run=False, provider_provenance=evidence, )["production_efficiency_eligible"] is False ) def test_environment_key_without_submitted_credential_does_not_verify_authentication( tmp_path: Path, ) -> None: session_id = "credential-not-submitted" events = [ { "type": "session_start", "session_id": session_id, "provider": "openai", "model": "openai/gpt-test", "api_key_env": "MODEL_API_KEY", "base_url": "", }, { "type": "model_response", "session_id": session_id, "provider": "litellm", "model": "openai/gpt-test", "response_model": "openai/gpt-test", "authentication_submitted": False, "request_endpoint_hash": None, "finish_reason": "stop", }, ] (tmp_path / f"{session_id}.jsonl").write_text( "".join(json.dumps(event) + "\n" for event in events), encoding="utf-8", ) evidence = benchmark.extract_provider_response_provenance( sessions_dir=tmp_path, session_id=session_id, model="openai/gpt-test", base_url=None, api_key_env="MODEL_API_KEY", env={"MODEL_API_KEY": "secret-value"}, ) assert evidence["provider_identity_verified"] is True assert evidence["provider_authentication_verified"] is False assert evidence["provider_request_authentication_submitted"] is False assert ( evidence["provider_authentication_evidence"] == "configured_api_key_env_present_but_not_submitted" ) def test_provider_response_provenance_rejects_foreign_session(tmp_path: Path) -> None: session_id = "requested" (tmp_path / f"{session_id}.jsonl").write_text( json.dumps( { "type": "session_start", "session_id": "foreign", "provider": "openai", "model": "openai/gpt-test", } ) + "\n", encoding="utf-8", ) with pytest.raises(ValueError, match="foreign session"): benchmark.extract_provider_response_provenance( sessions_dir=tmp_path, session_id=session_id, model="openai/gpt-test", base_url=None, api_key_env=None, env={}, ) def test_production_lifecycle_rejects_request_only_evidence(tmp_path: Path) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] lifecycle = benchmark.make_lifecycle_store(tmp_path) session_id = "request-only" skill = next(item for item in scenario.context if item["type"] == "skill") common = { "session_id": session_id, "entity_type": "skill", "slug": skill["slug"], } lifecycle.load_entity(**common, selected=True, selection_source="host") lifecycle.unload_entity(**common) lifecycle.end_session(session_id=session_id, status="completed") with pytest.raises(ValueError, match="invalid transition"): benchmark.validate_production_lifecycle( scenario, lifecycle_root=tmp_path, session_id=session_id, ) def _write_lifecycle_actions( root: Path, scenario: Any, *, session_id: str, actions: list[str], include_session_start: bool = False, session_end_status: str = "completed", ) -> list[dict[str, object]]: skill = next(item for item in scenario.context if item["type"] == "skill") events: list[dict[str, object]] = [] if include_session_start: events.append( { "session_id": session_id, "action": "session_start", "created_at_epoch": 0.0, } ) events.extend( [ { "session_id": session_id, "action": action, "entity_type": "skill", "slug": skill["slug"], "created_at_epoch": float(index), } for index, action in enumerate(actions, start=1) ] ) events.append( { "session_id": session_id, "action": "session_end", "status": session_end_status, "created_at_epoch": float(len(events) + 1), } ) _write_lifecycle_events(root, events) return events def _write_lifecycle_events(root: Path, events: list[dict[str, object]]) -> None: root.mkdir(parents=True, exist_ok=True) (root / "events.jsonl").write_text( "".join(json.dumps(event) + "\n" for event in events), encoding="utf-8", ) @pytest.mark.parametrize("session_end_status", ["completed", "successful"]) def test_production_lifecycle_accepts_optional_unload_request( tmp_path: Path, session_end_status: str, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] actions = [ "load_requested", "load_applied", "used", "unload_requested", "unload_applied", ] _write_lifecycle_actions( tmp_path, scenario, session_id="valid-with-request", actions=actions, session_end_status=session_end_status, ) evidence = benchmark.validate_production_lifecycle( scenario, lifecycle_root=tmp_path, session_id="valid-with-request", ) assert evidence["actions"] == actions assert evidence["final_loaded"] == [] assert evidence["session_status"] == session_end_status assert evidence["session_actions"][-1] == "session_end" assert len(evidence["lifecycle_sha256"]) == 64 def test_production_lifecycle_rejects_nonempty_final_loaded_state( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] session_id = "nonempty-final-state" _write_lifecycle_actions( tmp_path, scenario, session_id=session_id, actions=["load_requested", "load_applied", "used", "unload_applied"], ) class NonemptyStore: def session_state(self, *, session_id: str) -> dict[str, object]: return {"session_id": session_id, "loaded": [{"slug": "still-loaded"}]} monkeypatch.setattr(benchmark, "make_lifecycle_store", lambda _root: NonemptyStore()) with pytest.raises(ValueError, match="ended with loaded context"): benchmark.validate_production_lifecycle( scenario, lifecycle_root=tmp_path, session_id=session_id, ) def test_production_lifecycle_rejects_other_entity_transitions(tmp_path: Path) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] events = _write_lifecycle_actions( tmp_path, scenario, session_id="other-entity", actions=["load_requested", "load_applied", "used", "unload_applied"], ) events.insert( -1, { "session_id": "other-entity", "action": "load_requested", "entity_type": "agent", "slug": "unexpected-agent", "created_at_epoch": 5.0, }, ) _write_lifecycle_events(tmp_path, events) with pytest.raises(ValueError, match="unexpected entity transition"): benchmark.validate_production_lifecycle( scenario, lifecycle_root=tmp_path, session_id="other-entity", ) def test_production_lifecycle_rejects_foreign_session_before_digest( tmp_path: Path, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] events = _write_lifecycle_actions( tmp_path, scenario, session_id="requested-session", actions=["load_requested", "load_applied", "used", "unload_applied"], ) events.append( { "session_id": "foreign-session", "action": "load_requested", "entity_type": "agent", "slug": "foreign-agent", "created_at_epoch": 99.0, } ) _write_lifecycle_events(tmp_path, events) with pytest.raises(ValueError, match="foreign session"): benchmark.validate_production_lifecycle( scenario, lifecycle_root=tmp_path, session_id="requested-session", ) @pytest.mark.parametrize( ("case", "match"), [ ("late-session-start", "session_start"), ("missing-session-end", "exactly one session_end"), ("duplicate-session-end", "exactly one session_end"), ("event-after-session-end", "events after session_end"), ("failed-session-end", "status is not successful"), ], ) def test_production_lifecycle_rejects_invalid_session_envelope( tmp_path: Path, case: str, match: str, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] events = _write_lifecycle_actions( tmp_path, scenario, session_id="invalid-envelope", actions=["load_requested", "load_applied", "used", "unload_applied"], include_session_start=True, ) if case == "late-session-start": events.insert(2, events.pop(0)) elif case == "missing-session-end": events.pop() elif case == "duplicate-session-end": events.append(dict(events[-1])) elif case == "event-after-session-end": events.append( { "session_id": "invalid-envelope", "action": "dev_event", "created_at_epoch": 99.0, } ) else: events[-1]["status"] = "failed" _write_lifecycle_events(tmp_path, events) with pytest.raises(ValueError, match=match): benchmark.validate_production_lifecycle( scenario, lifecycle_root=tmp_path, session_id="invalid-envelope", ) def test_baseline_lifecycle_accepts_no_ledger_and_rejects_selected_cycle( tmp_path: Path, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] empty = benchmark.validate_production_lifecycle( scenario, lifecycle_root=tmp_path, session_id="baseline", expect_selected_cycle=False, ) assert empty["lifecycle_emitted"] is False assert empty["actions"] == [] assert empty["final_loaded"] == [] _write_lifecycle_actions( tmp_path, scenario, session_id="baseline", actions=["load_requested", "load_applied", "used", "unload_applied"], ) with pytest.raises(ValueError, match="baseline ctx run"): benchmark.validate_production_lifecycle( scenario, lifecycle_root=tmp_path, session_id="baseline", expect_selected_cycle=False, ) @pytest.mark.parametrize( "actions", [ ["load_requested", "load_applied", "unload_applied", "used", "unload_applied"], ["load_requested", "load_applied", "used", "unload_applied", "used"], [ "load_requested", "load_applied", "used", "unload_applied", "load_requested", "load_applied", "used", "unload_applied", ], ["load_requested", "load_requested", "load_applied", "used", "unload_applied"], ["load_requested", "used", "unload_applied"], ["load_requested", "load_applied", "used", "unload_requested", "used", "unload_applied"], ["load_requested", "load_applied", "validation", "used", "unload_applied"], ], ids=[ "use-after-early-unload", "use-after-complete", "duplicate-cycle", "duplicate-load-request", "use-before-load-applied", "use-after-unload-request", "unexpected-selected-entity-event", ], ) def test_production_lifecycle_rejects_contradictory_transitions( tmp_path: Path, actions: list[str], ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] _write_lifecycle_actions( tmp_path, scenario, session_id="invalid-transitions", actions=actions, ) with pytest.raises(ValueError, match="invalid transition"): benchmark.validate_production_lifecycle( scenario, lifecycle_root=tmp_path, session_id="invalid-transitions", ) def test_production_patch_is_limited_to_scenario_allowlist(tmp_path: Path) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[1] workspace = tmp_path / "repo" workspace.mkdir() benchmark.run_process(["git", "init", "-q"], cwd=workspace) source = workspace / scenario.allowed_changes[0] source.parent.mkdir(parents=True, exist_ok=True) source.write_text("old\n", encoding="utf-8") patch = ( f"diff --git a/{scenario.allowed_changes[0]} b/{scenario.allowed_changes[0]}\n" f"--- a/{scenario.allowed_changes[0]}\n" f"+++ b/{scenario.allowed_changes[0]}\n" "@@ -1 +1 @@\n" "-old\n" "+new\n" ) assert benchmark.apply_production_patch(scenario, workspace, patch) == [ scenario.allowed_changes[0] ] assert source.read_text(encoding="utf-8") == "new\n" with pytest.raises(ValueError, match="disallowed paths"): benchmark.apply_production_patch( scenario, workspace, "diff --git a/OTHER b/OTHER\n--- /dev/null\n+++ b/OTHER\n@@ -0,0 +1 @@\n+bad\n", ) def test_production_trial_mocked_boundaries_validate_usage_and_lifecycle( tmp_path: Path, monkeypatch: pytest.MonkeyPatch ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] observed_command: list[str] = [] def fake_prepare(_scenario: object, _cache: Path, destination: Path) -> str: destination.mkdir(parents=True) for relative in scenario.allowed_changes: path = destination / relative path.parent.mkdir(parents=True, exist_ok=True) path.write_text("# source\n", encoding="utf-8") return "test-hash" def fake_process(argv: list[str], **kwargs: object) -> object: observed_command[:] = argv env = kwargs["env"] assert isinstance(env, dict) lifecycle = benchmark.make_lifecycle_store(Path(env["CTX_RUNTIME_LIFECYCLE_DIR"])) session_id = argv[argv.index("--session-id") + 1] skill = next(item for item in scenario.context if item["type"] == "skill") common = { "session_id": session_id, "entity_type": "skill", "slug": skill["slug"], } lifecycle.load_entity(**common, selected=True, selection_source="host") lifecycle.mark_entity_loaded(**common) lifecycle.mark_entity_used(**common, evidence="submitted") lifecycle.mark_entity_unloaded(**common) lifecycle.end_session(session_id=session_id, status="completed") sessions_dir = Path(argv[argv.index("--sessions-dir") + 1]) sessions_dir.mkdir(parents=True, exist_ok=True) (sessions_dir / f"{session_id}.jsonl").write_text( "".join( json.dumps(event) + "\n" for event in ( { "type": "session_start", "session_id": session_id, "provider": "openai", "model": "openai/model", "api_key_env": "OPENAI_API_KEY", "base_url": "", "ctx_tools_enabled": True, "ctx_tool_surface": "adaptive", "ctx_tool_names": list(benchmark.PRODUCTION_CTX_TOOL_NAMES), }, { "type": "model_response", "session_id": session_id, "provider": "litellm", "model": "openai/model", "finish_reason": "stop", }, ) ), encoding="utf-8", ) payload = { "session_id": session_id, "stop_reason": "completed", "final_message": json.dumps({"patch": "diff"}), "usage": { "tokens_reported": True, "input_tokens": 90, "cached_input_tokens": 10, "output_tokens": 10, "total_tokens": 100, }, } return benchmark.CommandResult(0, json.dumps(payload), "", 0.25) monkeypatch.setattr(benchmark, "prepare_workspace", fake_prepare) monkeypatch.setattr(benchmark, "run_process", fake_process) monkeypatch.setattr( benchmark, "apply_production_patch", lambda *_args: list(scenario.allowed_changes), ) monkeypatch.setattr( benchmark, "verify_workspace", lambda *_args: benchmark.CommandResult(0, "passed", "", 0.1), ) result = benchmark.run_production_trial( scenario, arm="ctx-light", attempt=1, trial=1, retry=0, cache=tmp_path / "cache", output=tmp_path / "output", model="openai/model", timeout=10, dry_run=False, incidents=benchmark.IncidentLog(tmp_path / "incidents.csv"), api_key_env=None, base_url=None, max_iterations=3, max_tokens=1024, provider_timeout=5, ) assert result["status"] == "passed" assert result["token_attribution"] == "exact" assert result["lifecycle_actions"] == [ "load_requested", "load_applied", "used", "unload_applied", ] assert result["final_loaded"] == [] assert result["ctx_run_session_id"] == "ctx-ab-click-echo-json-ctx-light-1" assert result["ctx_run_stop_reason"] == "completed" assert result["endpoint_class"] == "provider_default_unverified" assert result["evidence_level"] == "functional_unverified" assert result["production_efficiency_eligible"] is False assert result["provider_identity"] == "openai" assert result["provider_response_success"] is True assert result["provider_authentication_verified"] is False assert result["cryptographic_independence"] is False assert "same-process artifacts" in result["evidence_trust_boundary"] assert ( result["ctx_run_payload_sha256"] == hashlib.sha256(Path(result["artifact_dir"], "ctx-run.json").read_bytes()).hexdigest() ) assert result["ctx_run_payload_digest_scope"] == "exact_ctx_run_stdout_bytes" assert ( result["lifecycle_sha256"] == hashlib.sha256(Path(result["lifecycle_events"]).read_bytes()).hexdigest() ) assert result["lifecycle_digest_scope"] == "entire_isolated_events_jsonl_bytes" assert result["expected_ctx_tool_names"] == list(benchmark.PRODUCTION_CTX_TOOL_NAMES) assert result["configured_ctx_tool_names"] == sorted(benchmark.PRODUCTION_CTX_TOOL_NAMES) assert result["configured_ctx_tool_surface_verified"] is True assert result["provider_tool_surface_evidence"] == ("ctx_run_session_start_pre_request_config") assert observed_command[observed_command.index("--ctx-tool-surface") + 1] == "adaptive" def test_production_dry_run_is_labeled_wiring_only( tmp_path: Path, monkeypatch: pytest.MonkeyPatch ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] def fake_prepare(_scenario: object, _cache: Path, destination: Path) -> str: destination.mkdir(parents=True) for relative in scenario.allowed_changes: path = destination / relative path.parent.mkdir(parents=True, exist_ok=True) path.write_text("# source\n", encoding="utf-8") return "test-hash" monkeypatch.setattr(benchmark, "prepare_workspace", fake_prepare) result = benchmark.run_production_trial( scenario, arm="ctx-light", attempt=1, trial=1, retry=0, cache=tmp_path / "cache", output=tmp_path / "output", model="openai/model", timeout=10, dry_run=True, incidents=benchmark.IncidentLog(tmp_path / "incidents.csv"), api_key_env=None, base_url=None, max_iterations=1, max_tokens=128, provider_timeout=5, ) assert result["status"] == "wiring_only" assert result["evidence_level"] == "wiring_only" assert result["production_efficiency_eligible"] is False assert not Path(result["artifact_dir"], "ctx-run.json").exists() def test_production_ctx_run_subprocess_compares_both_arms_with_local_provider( tmp_path: Path, ) -> None: scenario = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] changed_relative = scenario.allowed_changes[-1] patch = ( f"diff --git a/{changed_relative} b/{changed_relative}\n" f"--- a/{changed_relative}\n" f"+++ b/{changed_relative}\n" "@@ -1 +1 @@\n" '-VALUE = "before"\n' '+VALUE = "after"\n' ) shim_dir = tmp_path / "provider-shim" shim_dir.mkdir() (shim_dir / "litellm.py").write_text( """ import json import urllib.request def completion(**params): payload = { key: params[key] for key in ("model", "messages", "temperature", "max_tokens", "tools") if key in params } headers = {"Content-Type": "application/json"} if params.get("api_key"): headers["Authorization"] = f"Bearer {params['api_key']}" request = urllib.request.Request( str(params["api_base"]).rstrip("/") + "/chat/completions", data=json.dumps(payload).encode("utf-8"), headers=headers, method="POST", ) opener = urllib.request.build_opener(urllib.request.ProxyHandler({})) with opener.open(request, timeout=float(params.get("timeout", 5))) as response: return json.loads(response.read().decode("utf-8")) """.lstrip(), encoding="utf-8", ) observed_requests: list[dict[str, object]] = [] expected_treatment_tools = benchmark.production_ctx_tool_schemas() provider_payload = { "id": "chatcmpl-local", "object": "chat.completion", "created": 0, "model": "openai/local-mock", "choices": [ { "index": 0, "message": { "role": "assistant", "content": json.dumps({"patch": patch}), }, "finish_reason": "stop", } ], "usage": { "prompt_tokens": 120, "completion_tokens": 30, "total_tokens": 150, "prompt_tokens_details": {"cached_tokens": 20}, }, } class Handler(BaseHTTPRequestHandler): def do_POST(self) -> None: # noqa: N802 - BaseHTTPRequestHandler API. if self.headers.get("Authorization") != "Bearer local-test-key": self.send_response(401) self.end_headers() return length = int(self.headers.get("Content-Length", "0")) request_payload = json.loads(self.rfile.read(length)) expected_tools = [] if not observed_requests else expected_treatment_tools tool_surface = benchmark.validate_provider_request_tool_surface( request_payload, expected_tools=expected_tools, ) observed_requests.append( { "path": self.path, "authorization": self.headers.get("Authorization"), "payload": request_payload, "tool_surface": tool_surface, } ) body = json.dumps(provider_payload).encode("utf-8") self.send_response(200) self.send_header("Content-Type", "application/json") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body) def log_message(self, _format: str, *_args: object) -> None: return server = ThreadingHTTPServer(("127.0.0.1", 0), Handler) server_thread = threading.Thread(target=server.serve_forever, daemon=True) server_thread.start() commands: dict[str, list[str]] = {} arm_evidence: dict[str, dict[str, object]] = {} try: port = int(server.server_address[1]) session_id = "ctx-ab-local-provider" sessions_dir = tmp_path / "sessions" base_url = f"http://127.0.0.1:{port}/v1" for arm, with_ctx in (("baseline", False), ("ctx-light", True)): arm_root = tmp_path / arm workspace = arm_root / "repo" workspace.mkdir(parents=True) assert benchmark.run_process(["git", "init", "-q"], cwd=workspace).returncode == 0 for relative in scenario.allowed_changes: path = workspace / relative path.parent.mkdir(parents=True, exist_ok=True) path.write_text("# source\n", encoding="utf-8") changed_path = workspace / changed_relative changed_path.write_text('VALUE = "before"\n', encoding="utf-8") home = arm_root / "home" lifecycle_root = arm_root / "lifecycle" benchmark.write_ctx_fixture(scenario, home) prompt = benchmark.production_task_prompt(scenario, workspace) command = benchmark.production_ctx_command( model="openai/local-mock", prompt=prompt, session_id=session_id, sessions_dir=sessions_dir, with_ctx=with_ctx, api_key_env="LOCAL_MOCK_API_KEY", base_url=base_url, max_iterations=1, max_tokens=512, provider_timeout=5, ) commands[arm] = command env = benchmark._ctx_env(home, lifecycle_root) env["CODEX_HOME"] = str(arm_root / "codex-home") env["LOCAL_MOCK_API_KEY"] = "local-test-key" env["PYTHONPATH"] = os.pathsep.join((str(shim_dir), str(ROOT / "src"))) result = benchmark.run_process( command, cwd=workspace, env=env, timeout=10, contain_descendants=True, ) assert result.returncode == 0, result.stderr payload = benchmark.validate_production_payload( json.loads(result.stdout), session_id=session_id, ) usage = benchmark.extract_production_usage(payload) returned_patch = benchmark.extract_production_patch(payload) changed_paths = benchmark.apply_production_patch( scenario, workspace, returned_patch, ) lifecycle = benchmark.validate_production_lifecycle( scenario, lifecycle_root=lifecycle_root, session_id=session_id, expect_selected_cycle=with_ctx and secure_skill_reads_available(), ) provider_provenance = benchmark.extract_provider_response_provenance( sessions_dir=sessions_dir, session_id=session_id, model="openai/local-mock", base_url=base_url, api_key_env="LOCAL_MOCK_API_KEY", env=env, expected_ctx_tool_names=(benchmark.PRODUCTION_CTX_TOOL_NAMES if with_ctx else ()), ) arm_evidence[arm] = { "usage": usage, "changed_paths": changed_paths, "changed_body": changed_path.read_text(encoding="utf-8"), "lifecycle": lifecycle, "provider_provenance": provider_provenance, "payload_sha256": hashlib.sha256(result.stdout.encode("utf-8")).hexdigest(), } finally: server.shutdown() server.server_close() server_thread.join(timeout=2) treatment_surface_index = commands["ctx-light"].index("--ctx-tool-surface") assert commands["baseline"][:-1] == commands["ctx-light"][:treatment_surface_index] assert commands["baseline"][-1:] == ["--no-ctx-tools"] assert commands["ctx-light"][treatment_surface_index : treatment_surface_index + 2] == [ "--ctx-tool-surface", "adaptive", ] for evidence in arm_evidence.values(): usage = evidence["usage"] assert isinstance(usage, dict) assert usage["total_tokens"] == 150 assert usage["cached_input_tokens"] == 20 assert evidence["changed_paths"] == [changed_relative] assert evidence["changed_body"] == 'VALUE = "after"\n' assert len(str(evidence["payload_sha256"])) == 64 baseline_lifecycle = arm_evidence["baseline"]["lifecycle"] treatment_lifecycle = arm_evidence["ctx-light"]["lifecycle"] assert isinstance(baseline_lifecycle, dict) assert isinstance(treatment_lifecycle, dict) assert baseline_lifecycle["selected_id"] is None assert baseline_lifecycle["actions"] == [] assert baseline_lifecycle["final_loaded"] == [] expected_treatment_actions = ( ["load_requested", "load_applied", "used", "unload_applied"] if secure_skill_reads_available() else [] ) assert treatment_lifecycle["actions"] == expected_treatment_actions assert treatment_lifecycle["selected_id"] == ( "skill:click-public-api-feature" if secure_skill_reads_available() else None ) assert treatment_lifecycle["session_status"] == "completed" assert treatment_lifecycle["final_loaded"] == [] assert len(observed_requests) == 2 assert all(request["path"] == "/v1/chat/completions" for request in observed_requests) assert all(request["authorization"] == "Bearer local-test-key" for request in observed_requests) baseline_payload = observed_requests[0]["payload"] treatment_payload = observed_requests[1]["payload"] assert isinstance(baseline_payload, dict) assert isinstance(treatment_payload, dict) assert baseline_payload.get("tools") in (None, []) assert treatment_payload.get("tools") == expected_treatment_tools assert observed_requests[0]["tool_surface"] == { "provider_request_tool_names": [], "provider_request_tool_schema_sha256": hashlib.sha256(b"[]").hexdigest(), "provider_request_tool_surface_observed": True, } treatment_surface = observed_requests[1]["tool_surface"] assert isinstance(treatment_surface, dict) assert treatment_surface["provider_request_tool_names"] == sorted( benchmark.PRODUCTION_CTX_TOOL_NAMES ) assert len(str(treatment_surface["provider_request_tool_schema_sha256"])) == 64 request_texts: list[str] = [] for request in observed_requests: request_payload = request["payload"] assert isinstance(request_payload, dict) messages = request_payload.get("messages") assert isinstance(messages, list) request_texts.append( "\n".join( str(message.get("content") or "") for message in messages if isinstance(message, dict) ) ) skill = next(item for item in scenario.context if item["type"] == "skill") skill_body = str(skill["body"]).strip() assert skill_body not in request_texts[0] assert (skill_body in request_texts[1]) is secure_skill_reads_available() for evidence in arm_evidence.values(): provider_provenance = evidence["provider_provenance"] assert isinstance(provider_provenance, dict) assert provider_provenance["provider_identity"] == "openai" assert provider_provenance["provider_adapter"] == "litellm" assert provider_provenance["provider_response_success"] is True assert provider_provenance["provider_identity_verified"] is True assert provider_provenance["provider_endpoint_verified"] is True assert provider_provenance["provider_authentication_verified"] is True assert provider_provenance["configured_ctx_tool_surface_verified"] is True assert benchmark.classify_production_evidence( base_url=base_url, dry_run=False, provider_provenance=provider_provenance, ) == { "endpoint_class": "custom_endpoint", "evidence_level": "live_provider", "production_efficiency_eligible": True, } def test_environment_manifest_records_schedule_and_dirty_state( tmp_path: Path, monkeypatch: pytest.MonkeyPatch ) -> None: scenario_path = ROOT / "benchmarks/ctx_ab/scenarios.yaml" scenarios = benchmark.load_scenarios(scenario_path) schedule = benchmark.trial_schedule(scenarios, benchmark.TREATMENT_ARMS, 1) def fake_run_process(argv: list[str], **_kwargs: object) -> object: joined = " ".join(argv) if "rev-parse" in joined: return benchmark.CommandResult(0, "abc123\n", "", 0.0) if "status --porcelain" in joined: return benchmark.CommandResult(0, "?? local.txt\n", "", 0.0) if "git diff" in joined: return benchmark.CommandResult(0, "diff", "", 0.0) if "pip freeze" in joined: return benchmark.CommandResult(0, "pytest==1\n", "", 0.0) return benchmark.CommandResult(0, "codex 1.0\n", "", 0.0) monkeypatch.setattr(benchmark, "run_process", fake_run_process) benchmark.write_environment_manifest( output=tmp_path, scenarios_path=scenario_path, scenarios=scenarios, codex="codex", model="model", run_config={"arms": list(benchmark.TREATMENT_ARMS), "trials": 1}, schedule=schedule, ) manifest = json.loads((tmp_path / "environment.json").read_text()) assert manifest["repository_state"]["clean"] is False assert manifest["repository_state"]["status"] == ["?? local.txt"] assert manifest["schedule"] == schedule assert manifest["run_config"]["trials"] == 1 def test_scenario_loader_rejects_traversal(tmp_path: Path) -> None: source = yaml.safe_load((ROOT / "benchmarks/ctx_ab/scenarios.yaml").read_text()) source["scenarios"][0]["test_path"] = "../outside.py" path = tmp_path / "scenarios.yaml" path.write_text(yaml.safe_dump(source), encoding="utf-8") with pytest.raises(ValueError, match="normalized relative POSIX path"): benchmark.load_scenarios(path) def test_verification_uses_managed_networkless_sandbox_and_scrubbed_environment( tmp_path: Path, monkeypatch: pytest.MonkeyPatch ) -> None: workspace = tmp_path / "repo" workspace.mkdir() monkeypatch.setenv("CTX_BENCHMARK_SECRET", "must-not-leak") monkeypatch.setattr(benchmark.sys, "platform", "darwin") monkeypatch.setattr(benchmark.shutil, "which", lambda _name: "/opt/codex") captured: dict[str, object] = {} def fake_run_process(argv: list[str], **kwargs: object) -> object: captured.update(argv=argv, **kwargs) return benchmark.CommandResult(0, "ok", "", 0.1) monkeypatch.setattr(benchmark, "run_process", fake_run_process) result = benchmark._run_verified(["python", "-V"], workspace=workspace) argv = captured["argv"] env = captured["env"] assert isinstance(argv, list) assert isinstance(env, dict) assert argv[:6] == [ "/opt/codex", "sandbox", "-P", ":workspace", "--sandbox-state-disable-network", "-C", ] assert str(workspace) in argv assert "CTX_BENCHMARK_SECRET" not in env assert env["PYTEST_DISABLE_PLUGIN_AUTOLOAD"] == "1" assert captured["contain_descendants"] is True assert result.returncode == 0 def test_timeout_reaps_process_group(tmp_path: Path) -> None: pid_file = tmp_path / "child.pid" child = ( "import os,time; open(os.environ['PID_FILE'],'w').write(str(os.getpid())); time.sleep(30)" ) parent = ( "import subprocess,sys,time; " f"subprocess.Popen([sys.executable, '-c', {child!r}], env={{'PID_FILE': {str(pid_file)!r}}}); " "time.sleep(30)" ) result = benchmark.run_process([sys.executable, "-c", parent], cwd=tmp_path, timeout=0.2) assert result.timed_out if pid_file.exists(): child_pid = int(pid_file.read_text()) deadline = time.monotonic() + 2 while _pid_is_running(child_pid) and time.monotonic() < deadline: time.sleep(0.05) assert not _pid_is_running(child_pid) @pytest.mark.skipif(sys.platform != "darwin", reason="benchmark containment is macOS-only") def test_successful_parent_reaps_detached_descendant(tmp_path: Path) -> None: pid_file = tmp_path / "detached.pid" child = ( "import os,time; os.setsid(); " "open(os.environ['PID_FILE'],'w').write(str(os.getpid())); " "fd=os.open('/dev/null',os.O_RDWR); " "os.dup2(fd,0); os.dup2(fd,1); os.dup2(fd,2); time.sleep(30)" ) parent = ( "import os,subprocess,sys; " f"subprocess.Popen([sys.executable, '-c', {child!r}], env=os.environ.copy())" ) result = benchmark.run_process( [sys.executable, "-c", parent], cwd=tmp_path, env={**os.environ, "PID_FILE": str(pid_file)}, timeout=5, contain_descendants=True, ) assert result.returncode == 0 assert result.reaped_descendants >= 1 child_pid = int(pid_file.read_text()) with pytest.raises(ProcessLookupError): os.kill(child_pid, 0) @pytest.mark.skipif(sys.platform != "darwin", reason="benchmark containment is macOS-only") def test_detached_descendant_holding_parent_pipes_is_contained(tmp_path: Path) -> None: pid_file = tmp_path / "detached-pipes.pid" child = ( "import os,time; os.setsid(); " "open(os.environ['PID_FILE'],'w').write(str(os.getpid())); time.sleep(30)" ) parent = ( "import os,subprocess,sys; " f"subprocess.Popen([sys.executable, '-c', {child!r}], env=os.environ.copy())" ) result = benchmark.run_process( [sys.executable, "-c", parent], cwd=tmp_path, env={**os.environ, "PID_FILE": str(pid_file)}, timeout=0.2, contain_descendants=True, ) assert result.timed_out assert result.reaped_descendants >= 1 child_pid = int(pid_file.read_text()) with pytest.raises(ProcessLookupError): os.kill(child_pid, 0) def _official_holdout_fixture( tmp_path: Path, *, codex_path: Path | None = None, ) -> tuple[Any, dict[str, Path]]: codex_path = codex_path or Path(sys.executable) scenario_ids = [f"owner__repo-{index}" for index in range(10)] test_source = "def test_feature():\n assert True\n" test_sha256 = hashlib.sha256(test_source.encode()).hexdigest() scenario_rows = [ { "allowed_changes": ["src/feature.py"], "benchmark_class": "historical", "commit": f"{index + 1:040x}", "ctx_context": [], "expected_test_count": 1, "id": scenario_id, "language": "python", "query": f"implement feature {index}", "red_failure_contains": "FAILED", "reference_patch": ( "diff --git a/src/feature.py b/src/feature.py\n" "--- a/src/feature.py\n" "+++ b/src/feature.py\n" "@@ -0,0 +1 @@\n" "+VALUE = 1\n" ), "regression_verify": [["{python}", "-m", "pytest", "-q", "tests/test_feature.py"]], "repo_url": f"https://github.com/owner/repo-{index}.git", "reconstructed_test_sha256": test_sha256, "task": f"Implement frozen feature {index}.", "test_body": test_source, "test_path": "tests/test_feature.py", "verify": ["{python}", "-m", "pytest", "-q", "tests/test_feature.py"], } for index, scenario_id in enumerate(scenario_ids) ] scenario_pack = {"scenarios": scenario_rows, "version": 1} source_root = tmp_path / "sources" source_root.mkdir() source_repositories: dict[str, dict[str, str]] = {} for index, row in enumerate(scenario_rows): bundle = source_root / f"repo-{index}.bundle" bundle.write_bytes(f"fixture-bundle-{index}\n".encode()) bundle.chmod(0o600) source_repositories[str(row["repo_url"])] = { "base_commit": str(row["commit"]), "bundle_path": f"sources/repo-{index}.bundle", "bundle_sha256": hashlib.sha256(bundle.read_bytes()).hexdigest(), "tree_sha1": f"{index + 101:040x}", } source_map = { "repositories": source_repositories, "schema_version": 1, } selection = { "analysis_instance_ids": scenario_ids, "analysis_repository_map": { scenario_id: f"https://github.com/owner/repo-{index}.git" for index, scenario_id in enumerate(scenario_ids) }, "canary_instance_id": None, "canary_repository": None, "protocol_id": "production-graph-holdout-v2", } schedule_assignments = [ { "arms": ( ["baseline", "ctx-light"] if (index + trial - 1) % 2 == 0 else ["ctx-light", "baseline"] ), "scenario": scenario_id, "trial": trial, } for trial in range(1, 4) for index, scenario_id in enumerate(scenario_ids) ] schedule = { "assignment_count": 30, "assignments": schedule_assignments, "baseline_first_count": 15, "ctx_light_first_count": 15, "protocol_id": "production-graph-holdout-v2", "schema_version": 1, "trials_per_scenario": 3, } verifier = { "bridge_sha256": "1" * 64, "docker_cli_sha256": "2" * 64, "docker_daemon_id": "daemon", "docker_package_sha256": "3" * 64, "docker_server_version": "29.5.2", "namespace": "swebench", "python_environment_sha256": "4" * 64, "python_sha256": "5" * 64, "revision": "6" * 40, "run_evaluation_sha256": "7" * 64, "schema_version": 1, } verifier_sha256 = hashlib.sha256( json.dumps(verifier, sort_keys=True, separators=(",", ":")).encode() ).hexdigest() reconstructed = { "guard": "reconstructed-test-dependency-v1", "module_sha256": {scenario_id: test_sha256 for scenario_id in scenario_ids}, } collision = { "catalog_archive_sha256": hashlib.sha256( benchmark.PRODUCTION_CATALOG_ARCHIVE.read_bytes() ).hexdigest(), "collision_count": 0, "collision_free": True, "guard": "runtime-pack-distinctive-evidence-v1", "runtime_availability_sha256": hashlib.sha256( benchmark.PRODUCTION_RUNTIME_AVAILABILITY.read_bytes() ).hexdigest(), "scenario_ids": sorted(scenario_ids), } def encoded(value: object) -> bytes: return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() blobs = { "selection": encoded(selection), "scenario_pack": encoded(scenario_pack), "schedule": encoded(schedule), "source_map": encoded(source_map), } selection_sha256 = hashlib.sha256(blobs["selection"]).hexdigest() scenario_pack_sha256 = hashlib.sha256(blobs["scenario_pack"]).hexdigest() reconstructed["selection_sha256"] = selection_sha256 collision["scenarios_sha256"] = scenario_pack_sha256 def control_phase(scenario_id: str, phase: str) -> dict[str, Any]: failed = phase == "red" image_id = "sha256:" + hashlib.sha256(scenario_id.encode()).hexdigest() return { "artifact_bytes": 100, "artifact_count": 2, "artifact_manifest_sha256": hashlib.sha256( f"{scenario_id}:module".encode() ).hexdigest(), "container_policy_count": 1, "exact_selector_identity": True, "fail_to_pass_count": 1, "image_id": image_id, "pass_to_pass_count": 1, "phase": phase, "runtime_identity_sha256": hashlib.sha256( f"{scenario_id}:runtime".encode() ).hexdigest(), "status_counts": {"FAILED": 1, "PASSED": 1} if failed else {"PASSED": 2}, "verifier_evidence_sha256": hashlib.sha256( f"{scenario_id}:{phase}:evidence".encode() ).hexdigest(), } controls = { "all_scenarios_passed": True, "guard": "holdout-control-results-v1", "scenario_count": 10, "scenario_pack_sha256": scenario_pack_sha256, "scenario_results": { scenario_id: { "changed_test_module_green": True, "elapsed_seconds": 10.0, "green_evidence_sha256": control_phase(scenario_id, "green")[ "verifier_evidence_sha256" ], "module_evidence_sha256": control_phase(scenario_id, "green")[ "artifact_manifest_sha256" ], "official_swebench": { "green": control_phase(scenario_id, "green"), "image_id": "sha256:" + hashlib.sha256(scenario_id.encode()).hexdigest(), "pins_sha256": verifier_sha256, "red": control_phase(scenario_id, "red"), }, "parent_with_test_patch_red": True, "reconstructed_test_sha256": test_sha256, "red_evidence_sha256": control_phase(scenario_id, "red")[ "verifier_evidence_sha256" ], "reference_patch_green": True, "timeout_compliant": True, "timeout_seconds": 900, } for scenario_id in scenario_ids }, "selection_sha256": selection_sha256, "verifier_pins_sha256": verifier_sha256, } environment = { "codex": { "runtime_contract": dict(CODEX_RUNTIME_CONTRACT), "version": "test", }, "evaluator": { "backend": benchmark.OFFICIAL_HOLDOUT_BACKEND, "pins_sha256": verifier_sha256, }, "limits": { "agent_timeout_seconds": 900.0, "arms": ["baseline", "ctx-light"], "catalog_cache_hit": False, "measured_concurrency": 1, "pair_count": 30, "retries": 0, "sandbox_contract": benchmark.OFFICIAL_SANDBOX_CONTRACT, "task_count": 10, "trials_per_scenario": 3, }, "model": "gpt-5.5", "product_revision": "a" * 40, "protocol_id": "production-graph-holdout-v2", "provider": "openai", "python": { "dependencies_sha256": benchmark.python_dependencies_sha256(sys.executable), "executable_sha256": hashlib.sha256(Path(sys.executable).read_bytes()).hexdigest(), "version": benchmark.platform.python_version(), }, "schema_version": 1, } blobs.update( { "collision": encoded(collision), "reconstructed": encoded(reconstructed), "controls": encoded(controls), "environment": encoded(environment), } ) from scripts import ctx_ab_holdout_freeze as freezer product_inputs = { "benchmark_script_sha256": hashlib.sha256(SCRIPT.read_bytes()).hexdigest(), "catalog_archive_sha256": hashlib.sha256( benchmark.PRODUCTION_CATALOG_ARCHIVE.read_bytes() ).hexdigest(), "codex_binary_sha256": hashlib.sha256(codex_path.read_bytes()).hexdigest(), "provider_config_sha256": benchmark.codex_provider_config_sha256("openai"), "origin_main_revision": "a" * 40, "origin_url": "https://github.com/stevesolun/ctx.git", "revision": "a" * 40, "runtime_availability_sha256": hashlib.sha256( benchmark.PRODUCTION_RUNTIME_AVAILABILITY.read_bytes() ).hexdigest(), } acquisition_protocol = freezer.build_acquisition_protocol( v1=freezer._supported_v1_protocol(), frozen_at="2026-07-01T00:00:00Z", acquisition_frozen_at="2026-07-01T00:00:00Z", product_inputs=product_inputs, verifier_pins=verifier, exposure_ledger_sha256="e" * 64, ) acquisition_protocol["execution_inputs"]["source_map_sha256"] = None acquisition_protocol_bytes = freezer._canonical_bytes( acquisition_protocol, newline=True, ) protocol = json.loads(acquisition_protocol_bytes) protocol["stage"] = "execution-frozen" protocol["execution_frozen_at"] = "2026-07-02T00:00:00Z" protocol["execution_inputs"] = { "acquisition_protocol_sha256": hashlib.sha256(acquisition_protocol_bytes).hexdigest(), "collision_attestation_sha256": hashlib.sha256(blobs["collision"]).hexdigest(), "control_results_sha256": hashlib.sha256(blobs["controls"]).hexdigest(), "execution_environment_sha256": hashlib.sha256(blobs["environment"]).hexdigest(), "execution_schedule_sha256": hashlib.sha256(blobs["schedule"]).hexdigest(), "reconstructed_test_attestation_sha256": hashlib.sha256(blobs["reconstructed"]).hexdigest(), "scenario_pack_sha256": scenario_pack_sha256, "selection_output_sha256": selection_sha256, "source_map_sha256": hashlib.sha256(blobs["source_map"]).hexdigest(), } paths: dict[str, Path] = {} for name, data in blobs.items(): path = tmp_path / f"{name}.json" path.write_bytes(data) path.chmod(0o600) paths[name] = path protocol_path = tmp_path / "protocol.json" protocol_path.write_bytes(encoded(protocol)) paths["protocol"] = protocol_path loaded = benchmark.load_execution_frozen_holdout( protocol_path=protocol_path, expected_protocol_sha256=hashlib.sha256(protocol_path.read_bytes()).hexdigest(), selection_path=paths["selection"], scenario_pack_path=paths["scenario_pack"], collision_path=paths["collision"], reconstructed_path=paths["reconstructed"], control_results_path=paths["controls"], environment_path=paths["environment"], schedule_path=paths["schedule"], source_map_path=paths["source_map"], ) return loaded, paths def test_official_workspace_cannot_access_future_gold_commit( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: source_repo = tmp_path / "source" source_repo.mkdir() def git(*args: str, check: bool = True) -> subprocess.CompletedProcess[str]: return subprocess.run( ["git", *args], cwd=source_repo, check=check, capture_output=True, text=True, ) git("init", "-b", "main") git("config", "user.email", "benchmark@example.invalid") git("config", "user.name", "Benchmark") feature = source_repo / "feature.py" feature.write_text("VALUE = 1\n", encoding="utf-8") git("add", "feature.py") git("commit", "-m", "base") base_commit = git("rev-parse", "HEAD").stdout.strip() base_tree = git("rev-parse", "HEAD^{tree}").stdout.strip() bundle = tmp_path / "base.bundle" git("bundle", "create", str(bundle), "--all") bundle.chmod(0o600) feature.write_text("VALUE = 2 # gold\n", encoding="utf-8") git("commit", "-am", "future gold") future_commit = git("rev-parse", "HEAD").stdout.strip() hooks = tmp_path / "malicious-hooks" hooks.mkdir() post_checkout = hooks / "post-checkout" post_checkout.write_text( "#!/bin/sh\nprintf 'leaked\\n' > \"$PWD/GOLD_LEAK.txt\"\n", encoding="utf-8", ) post_checkout.chmod(0o700) global_config = tmp_path / "malicious-gitconfig" subprocess.run( [ "git", "config", "--file", str(global_config), "core.hooksPath", str(hooks), ], check=True, ) monkeypatch.setenv("GIT_CONFIG_GLOBAL", str(global_config)) template = benchmark.load_scenarios(ROOT / "benchmarks/ctx_ab/scenarios.yaml")[0] scenario = replace( template, repo_url="https://github.com/owner/repo.git", commit=base_commit, ) source = benchmark.OfficialSourceBundle( canonical_url=scenario.repo_url, base_commit=base_commit, bundle_path=bundle, bundle_sha256=hashlib.sha256(bundle.read_bytes()).hexdigest(), tree_sha1=base_tree, ) workspace = tmp_path / "workspace" benchmark.prepare_official_workspace( scenario, source, workspace, include_evaluator_test=False, ) assert ( subprocess.run( ["git", "cat-file", "-e", f"{future_commit}^{{commit}}"], cwd=workspace, check=False, capture_output=True, ).returncode != 0 ) assert ( future_commit not in subprocess.run( ["git", "log", "--all", "--format=%H"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout ) assert ( subprocess.run( ["git", "remote"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout.strip() == "" ) assert not (workspace / "GOLD_LEAK.txt").exists() assert ( subprocess.run( ["git", "status", "--porcelain=v1", "--untracked-files=all"], cwd=workspace, check=True, capture_output=True, text=True, ).stdout == "" ) def test_official_protocol_claim_is_one_shot(tmp_path: Path) -> None: state_root = tmp_path / "private" protocol_sha256 = "1" * 64 first = benchmark.claim_official_protocol( state_root=state_root, assignment_sha256="3" * 64, protocol_sha256=protocol_sha256, selection_sha256="2" * 64, output=tmp_path / "first", ) original = first.read_bytes() with pytest.raises(RuntimeError, match="already consumed"): benchmark.claim_official_protocol( state_root=state_root, assignment_sha256="3" * 64, protocol_sha256=protocol_sha256, selection_sha256="2" * 64, output=tmp_path / "second", ) assert first.read_bytes() == original def test_official_assignment_identity_is_order_independent_and_canary_sensitive() -> None: first = { "analysis_instance_ids": ["task-b", "task-a"], "analysis_repository_map": { "task-a": "https://github.com/owner/a.git", "task-b": "https://github.com/owner/b.git", }, "canary_instance_id": "task-c", "canary_repository": "https://github.com/owner/c.git", "protocol_id": "protocol-a", } reordered = { **first, "analysis_instance_ids": ["task-a", "task-b"], "protocol_id": "protocol-b", } changed_canary = {**reordered, "canary_instance_id": "task-d"} assert benchmark.official_assignment_sha256(first) == benchmark.official_assignment_sha256( reordered ) assert benchmark.official_assignment_sha256(first) != benchmark.official_assignment_sha256( changed_canary ) def test_official_assignment_claim_rejects_reordered_selection_replay( tmp_path: Path, ) -> None: first_selection = { "analysis_instance_ids": ["task-b", "task-a"], "analysis_repository_map": { "task-a": "https://github.com/owner/a.git", "task-b": "https://github.com/owner/b.git", }, "canary_instance_id": "task-c", "canary_repository": "https://github.com/owner/c.git", } reordered_selection = { **first_selection, "analysis_instance_ids": ["task-a", "task-b"], } first_selection_sha256 = benchmark._sha256_bytes( benchmark._canonical_json_bytes(first_selection) ) reordered_selection_sha256 = benchmark._sha256_bytes( benchmark._canonical_json_bytes(reordered_selection) ) assignment_sha256 = benchmark.official_assignment_sha256(first_selection) assert first_selection_sha256 != reordered_selection_sha256 assert assignment_sha256 == benchmark.official_assignment_sha256(reordered_selection) benchmark.claim_official_protocol( state_root=tmp_path / "private", assignment_sha256=assignment_sha256, protocol_sha256="1" * 64, selection_sha256=first_selection_sha256, output=tmp_path / "first", ) with pytest.raises(RuntimeError, match="assignments were already consumed"): benchmark.claim_official_protocol( state_root=tmp_path / "private", assignment_sha256=assignment_sha256, protocol_sha256="2" * 64, selection_sha256=reordered_selection_sha256, output=tmp_path / "second", ) def test_official_claim_durably_syncs_regular_files_and_directories( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: fsynced_types: list[str] = [] real_fsync = os.fsync def observed_fsync(descriptor: int) -> None: mode = os.fstat(descriptor).st_mode fsynced_types.append("directory" if stat.S_ISDIR(mode) else "file") real_fsync(descriptor) monkeypatch.setattr(benchmark.os, "fsync", observed_fsync) benchmark.claim_official_protocol( state_root=tmp_path / "private", assignment_sha256="3" * 64, protocol_sha256="1" * 64, selection_sha256="2" * 64, output=tmp_path / "output", ) assert fsynced_types.count("file") == 3 assert fsynced_types.count("directory") >= 3 first_file = fsynced_types.index("file") assert fsynced_types[first_file:] == ["file", "directory"] * 3 def test_official_claim_syncs_every_new_state_ancestor( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: state_root = tmp_path / "new-home" / ".ctx" / "benchmark-state" / "repository-key" synced_directories: list[Path] = [] real_sync = benchmark._fsync_directory def observed_sync(path: Path) -> None: synced_directories.append(path.resolve(strict=True)) real_sync(path) monkeypatch.setattr(benchmark, "_fsync_directory", observed_sync) benchmark.claim_official_protocol( state_root=state_root, assignment_sha256="3" * 64, protocol_sha256="1" * 64, selection_sha256="2" * 64, output=tmp_path / "output", ) created_directories = [ state_root.parents[2], state_root.parents[1], state_root.parent, state_root, state_root / "assignment-consumption", state_root / "selection-consumption", state_root / "protocol-consumption", ] for directory in created_directories: assert directory.resolve(strict=True) in synced_directories assert directory.parent.resolve(strict=True) in synced_directories def test_official_state_observer_syncs_concurrently_created_root( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: state_root = tmp_path / "private-state" resolved_state_root = state_root.resolve(strict=False) creator_blocked = threading.Event() release_creator = threading.Event() creator_ident: list[int] = [] creator_errors: list[BaseException] = [] observer_syncs: list[Path] = [] real_sync = benchmark._fsync_directory def controlled_sync(path: Path) -> None: resolved = path.resolve(strict=True) if threading.get_ident() in creator_ident and resolved == resolved_state_root: creator_blocked.set() if not release_creator.wait(timeout=5): raise RuntimeError("creator sync was not released") else: observer_syncs.append(resolved) real_sync(path) def create_state_root() -> None: creator_ident.append(threading.get_ident()) try: benchmark._ensure_owner_only_directory(state_root, label="test state root") except BaseException as exc: # pragma: no cover - reported in the parent thread creator_errors.append(exc) monkeypatch.setattr(benchmark, "_fsync_directory", controlled_sync) creator = threading.Thread(target=create_state_root) creator.start() assert creator_blocked.wait(timeout=5) try: observed = benchmark._ensure_owner_only_directory(state_root, label="test state root") finally: release_creator.set() creator.join(timeout=5) assert not creator.is_alive() assert creator_errors == [] assert observed == state_root.resolve(strict=True) assert resolved_state_root in observer_syncs assert state_root.parent.resolve(strict=True) in observer_syncs def test_official_state_observer_syncs_contested_intermediate_parent( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: state_base = tmp_path / "state-base" state_base.mkdir() intermediate = state_base / "intermediate" state_root = intermediate / "repository-key" initial_anchor_barrier = threading.Barrier(2) anchored_threads: set[int] = set() publisher_ident: list[int] = [] publisher_blocked = threading.Event() release_publisher = threading.Event() observer_done = threading.Event() observer_syncs: list[Path] = [] worker_errors: list[BaseException] = [] synchronization_lock = threading.Lock() real_sync = benchmark._fsync_directory def controlled_sync(path: Path) -> None: resolved = path.resolve(strict=True) ident = threading.get_ident() initial_anchor = False block_publisher = False with synchronization_lock: if resolved == state_base and ident not in anchored_threads: anchored_threads.add(ident) initial_anchor = True if initial_anchor: initial_anchor_barrier.wait(timeout=5) with synchronization_lock: if resolved == intermediate and not publisher_ident: publisher_ident.append(ident) publisher_blocked.set() block_publisher = True elif publisher_ident and ident != publisher_ident[0]: observer_syncs.append(resolved) if block_publisher and not release_publisher.wait(timeout=5): raise RuntimeError("intermediate publisher sync was not released") real_sync(path) def ensure_state_root() -> None: ident = threading.get_ident() try: benchmark._ensure_owner_only_directory(state_root, label="test state root") with synchronization_lock: is_observer = bool(publisher_ident) and ident != publisher_ident[0] if is_observer: observer_done.set() except BaseException as exc: # pragma: no cover - reported in the parent thread worker_errors.append(exc) monkeypatch.setattr(benchmark, "_fsync_directory", controlled_sync) workers = [threading.Thread(target=ensure_state_root) for _ in range(2)] for worker in workers: worker.start() assert publisher_blocked.wait(timeout=5) try: assert observer_done.wait(timeout=5) finally: release_publisher.set() for worker in workers: worker.join(timeout=5) assert all(not worker.is_alive() for worker in workers) assert worker_errors == [] assert state_base.resolve(strict=True) in observer_syncs def test_official_selection_claim_is_one_shot_across_protocol_refreezes( tmp_path: Path, ) -> None: state_root = tmp_path / "private" assignment_sha256 = "b" * 64 selection_sha256 = "a" * 64 first = benchmark.claim_official_protocol( state_root=state_root, assignment_sha256=assignment_sha256, protocol_sha256="1" * 64, selection_sha256=selection_sha256, output=tmp_path / "first", ) original = first.read_bytes() with pytest.raises(RuntimeError, match="assignments were already consumed"): benchmark.claim_official_protocol( state_root=state_root, assignment_sha256=assignment_sha256, protocol_sha256="2" * 64, selection_sha256=selection_sha256, output=tmp_path / "second", ) assert first == state_root / "assignment-consumption" / f"{assignment_sha256}.json" assert first.read_bytes() == original assert len(list((state_root / "protocol-consumption").glob("*.json"))) == 1 def test_official_selection_claim_fails_closed_between_dual_index_writes( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: state_root = tmp_path / "private" assignment_sha256 = "b" * 64 selection_sha256 = "a" * 64 real_write = benchmark._write_exclusive_owner_file writes = 0 def interrupt_second_write(path: Path, payload: dict[str, Any]) -> None: nonlocal writes writes += 1 if writes == 2: raise OSError("injected interruption") real_write(path, payload) monkeypatch.setattr(benchmark, "_write_exclusive_owner_file", interrupt_second_write) with pytest.raises(OSError, match="injected interruption"): benchmark.claim_official_protocol( state_root=state_root, assignment_sha256=assignment_sha256, protocol_sha256="1" * 64, selection_sha256=selection_sha256, output=tmp_path / "interrupted", ) assert (state_root / "assignment-consumption" / f"{assignment_sha256}.json").is_file() with pytest.raises(RuntimeError, match="assignments were already consumed"): benchmark.claim_official_protocol( state_root=state_root, assignment_sha256=assignment_sha256, protocol_sha256="2" * 64, selection_sha256=selection_sha256, output=tmp_path / "retry", ) def test_official_selection_claim_is_atomic_across_concurrent_protocols( tmp_path: Path, ) -> None: state_root = tmp_path / "private" assignment_sha256 = "b" * 64 selection_sha256 = "a" * 64 barrier = threading.Barrier(2) outcomes: list[str] = [] def claim(protocol_sha256: str) -> None: barrier.wait() try: benchmark.claim_official_protocol( state_root=state_root, assignment_sha256=assignment_sha256, protocol_sha256=protocol_sha256, selection_sha256=selection_sha256, output=tmp_path / protocol_sha256, ) except RuntimeError as exc: outcomes.append(str(exc)) else: outcomes.append("claimed") threads = [ threading.Thread(target=claim, args=("1" * 64,)), threading.Thread(target=claim, args=("2" * 64,)), ] for thread in threads: thread.start() for thread in threads: thread.join() assert outcomes.count("claimed") == 1 assert sum("assignments were already consumed" in outcome for outcome in outcomes) == 1 assert len(list((state_root / "assignment-consumption").glob("*.json"))) == 1 assert len(list((state_root / "selection-consumption").glob("*.json"))) == 1 assert len(list((state_root / "protocol-consumption").glob("*.json"))) == 1 def test_official_selection_claim_is_private_single_link_and_contains_no_task_id( tmp_path: Path, ) -> None: state_root = tmp_path / "private" assignment_sha256 = "3" * 64 protocol_sha256 = "1" * 64 selection_sha256 = "2" * 64 assignment_claim = benchmark.claim_official_protocol( state_root=state_root, assignment_sha256=assignment_sha256, protocol_sha256=protocol_sha256, selection_sha256=selection_sha256, output=tmp_path / "output", ) selection_claim = state_root / "selection-consumption" / f"{selection_sha256}.json" protocol_claim = state_root / "protocol-consumption" / f"{protocol_sha256}.json" for claim in (assignment_claim, selection_claim, protocol_claim): metadata = claim.stat() document = json.loads(claim.read_bytes()) assert metadata.st_nlink == 1 assert stat.S_IMODE(metadata.st_mode) == 0o600 assert set(document) == { "assignment_sha256", "claimed_at", "hostname", "output", "pid", "protocol_sha256", "schema_version", "selection_sha256", } assert "task" not in json.dumps(document).lower() def test_official_selection_claim_rejects_existing_malformed_state(tmp_path: Path) -> None: state_root = tmp_path / "private" state_root.mkdir(mode=0o700) ledger = state_root / "assignment-consumption" ledger.mkdir(mode=0o700) assignment_sha256 = "3" * 64 selection_sha256 = "2" * 64 claim = ledger / f"{assignment_sha256}.json" claim.write_text("not-json\n", encoding="utf-8") claim.chmod(0o600) with pytest.raises(RuntimeError, match="assignments were already consumed"): benchmark.claim_official_protocol( state_root=state_root, assignment_sha256=assignment_sha256, protocol_sha256="1" * 64, selection_sha256=selection_sha256, output=tmp_path / "output", ) def test_official_assignment_claim_rejects_legacy_two_index_state(tmp_path: Path) -> None: state_root = tmp_path / "private" state_root.mkdir(mode=0o700) (state_root / "protocol-consumption").mkdir(mode=0o700) with pytest.raises(RuntimeError, match="legacy official consumption state"): benchmark.claim_official_protocol( state_root=state_root, assignment_sha256="3" * 64, protocol_sha256="1" * 64, selection_sha256="2" * 64, output=tmp_path / "output", ) assert not (state_root / "assignment-consumption").exists() @pytest.mark.parametrize("link_kind", ["symlink", "hardlink"]) def test_official_selection_claim_rejects_existing_link_state( tmp_path: Path, link_kind: str, ) -> None: state_root = tmp_path / "private" state_root.mkdir(mode=0o700) ledger = state_root / "assignment-consumption" ledger.mkdir(mode=0o700) assignment_sha256 = "3" * 64 selection_sha256 = "2" * 64 target = tmp_path / "existing-claim" target.write_text("existing\n", encoding="utf-8") target.chmod(0o600) claim = ledger / f"{assignment_sha256}.json" if link_kind == "symlink": claim.symlink_to(target) else: os.link(target, claim) with pytest.raises(RuntimeError, match="assignments were already consumed"): benchmark.claim_official_protocol( state_root=state_root, assignment_sha256=assignment_sha256, protocol_sha256="1" * 64, selection_sha256=selection_sha256, output=tmp_path / "output", ) def test_official_campaign_lock_rejects_concurrency_and_releases( tmp_path: Path, ) -> None: state_root = tmp_path / "private" first = benchmark.OfficialCampaignLock.acquire(state_root) with pytest.raises(RuntimeError, match="already held"): benchmark.OfficialCampaignLock.acquire(state_root) assert first.path.is_file() first.release() assert not first.path.exists() second = benchmark.OfficialCampaignLock.acquire(state_root) second.release() assert not second.path.exists() def test_official_campaign_state_is_shared_by_independent_clones( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: monkeypatch.setattr(benchmark, "OFFICIAL_CAMPAIGN_STATE_BASE", tmp_path / "host-state") repository_url = "https://github.com/stevesolun/ctx.git" first_root = benchmark._official_campaign_state_root(repository_url=repository_url) second_root = benchmark._official_campaign_state_root(repository_url=repository_url) benchmark.claim_official_protocol( state_root=first_root, assignment_sha256="3" * 64, protocol_sha256="1" * 64, selection_sha256="2" * 64, output=tmp_path / "first-clone-output", ) assert first_root == second_root with pytest.raises(RuntimeError, match="already consumed"): benchmark.claim_official_protocol( state_root=second_root, assignment_sha256="3" * 64, protocol_sha256="1" * 64, selection_sha256="2" * 64, output=tmp_path / "second-clone-output", ) def test_origin_main_drift_fails_pre_arm_identity_check( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: holdout, _ = _official_holdout_fixture(tmp_path) monkeypatch.setattr( benchmark, "collect_official_repository_identity", lambda: { "head": holdout.origin_main_revision, "origin_fetch_url": holdout.origin_url, "origin_main_revision": "b" * 40, "origin_push_url": holdout.origin_url, }, ) monkeypatch.setattr( benchmark, "collect_repository_state", lambda: { "clean": True, "head": holdout.origin_main_revision, "status": [], "tracked_diff_sha256": hashlib.sha256(b"").hexdigest(), }, ) with pytest.raises(ValueError, match="origin/main"): benchmark.validate_official_repository_identity(holdout) def test_dirty_worktree_fails_pre_arm_identity_check( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: holdout, _ = _official_holdout_fixture(tmp_path) monkeypatch.setattr( benchmark, "collect_official_repository_identity", lambda: { "head": holdout.origin_main_revision, "origin_fetch_url": holdout.origin_url, "origin_main_revision": holdout.origin_main_revision, "origin_push_url": holdout.origin_url, }, ) monkeypatch.setattr( benchmark, "collect_repository_state", lambda: { "clean": False, "head": holdout.origin_main_revision, "status": [" M README.md"], "tracked_diff_sha256": "f" * 64, }, ) with pytest.raises(ValueError, match="clean"): benchmark.validate_official_repository_identity(holdout) def test_repository_state_ignores_ambient_git_repository_redirects( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: repository = tmp_path / "repository" alternate_tree = tmp_path / "alternate-tree" repository.mkdir() alternate_tree.mkdir() subprocess.run(["git", "init", "-q"], cwd=repository, check=True) subprocess.run( ["git", "config", "user.email", "ctx@example.test"], cwd=repository, check=True, ) subprocess.run( ["git", "config", "user.name", "ctx benchmark"], cwd=repository, check=True, ) source = repository / "source.py" source.write_text("clean = True\n", encoding="utf-8") subprocess.run(["git", "add", "source.py"], cwd=repository, check=True) subprocess.run(["git", "commit", "-qm", "base"], cwd=repository, check=True) (alternate_tree / "source.py").write_text("clean = True\n", encoding="utf-8") source.write_text("clean = False\n", encoding="utf-8") monkeypatch.setattr(benchmark, "ROOT", repository) monkeypatch.setenv("GIT_DIR", str(repository / ".git")) monkeypatch.setenv("GIT_WORK_TREE", str(alternate_tree)) state = benchmark.collect_repository_state() assert state["clean"] is False assert state["status"] == [" M source.py"] assert state["tracked_diff_sha256"] != hashlib.sha256(b"").hexdigest() def test_execution_frozen_holdout_authenticates_all_inputs_and_balanced_schedule( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: holdout, paths = _official_holdout_fixture(tmp_path) monkeypatch.setattr(benchmark, "_command_version", lambda _command: "test") assert len(holdout.scenarios) == 10 assert len(holdout.schedule.assignments) == 30 assert sum(row["arms"][0] == "baseline" for row in holdout.schedule.assignments) == 15 assert sum(row["arms"][0] == "ctx-light" for row in holdout.schedule.assignments) == 15 runtime_identity = benchmark.validate_holdout_execution_conditions( holdout, model="gpt-5.5", timeout=900.0, arms=("baseline", "ctx-light"), trials=3, retries=0, scenario_filters=[], codex=sys.executable, ) assert runtime_identity["codex_runtime_contract_sha256"] == ( benchmark.codex_runtime_contract_sha256(CODEX_RUNTIME_CONTRACT) ) assert ( holdout.codex_binary_sha256 == hashlib.sha256(Path(sys.executable).read_bytes()).hexdigest() ) assert ( holdout.acquisition_protocol_sha256 == json.loads(paths["protocol"].read_text())["execution_inputs"][ "acquisition_protocol_sha256" ] ) assert holdout.provider_config_sha256 == benchmark.codex_provider_config_sha256("openai") assert set(holdout.sensitive_paths) == { paths[name] for name in ( "protocol", "selection", "scenario_pack", "collision", "reconstructed", "controls", "environment", "schedule", "source_map", ) } | {source.bundle_path for source in holdout.source_bundles.values()} assert holdout.origin_url == "https://github.com/stevesolun/ctx.git" assert holdout.origin_main_revision == "a" * 40 def test_execution_frozen_holdout_rejects_selection_repository_map_replay( tmp_path: Path, ) -> None: holdout_root = tmp_path / "holdout" holdout_root.mkdir() holdout, paths = _official_holdout_fixture(holdout_root) state_root = tmp_path / "private-state" benchmark.claim_official_protocol( state_root=state_root, assignment_sha256=holdout.assignment_sha256, protocol_sha256=holdout.protocol_sha256, selection_sha256=holdout.selection_sha256, output=tmp_path / "first-output", ) selection = json.loads(paths["selection"].read_text()) first_id = selection["analysis_instance_ids"][0] selection["analysis_repository_map"][first_id] = "https://github.com/owner/forged.git" paths["selection"].write_text( json.dumps(selection, sort_keys=True, separators=(",", ":")), encoding="utf-8", ) forged_selection_sha256 = hashlib.sha256(paths["selection"].read_bytes()).hexdigest() forged_assignment_sha256 = benchmark.official_assignment_sha256(selection) assert forged_assignment_sha256 != holdout.assignment_sha256 linked_inputs = ( ("reconstructed", "reconstructed_test_attestation_sha256"), ("controls", "control_results_sha256"), ) for name, _field in linked_inputs: document = json.loads(paths[name].read_text()) document["selection_sha256"] = forged_selection_sha256 paths[name].write_text( json.dumps(document, sort_keys=True, separators=(",", ":")), encoding="utf-8", ) protocol = json.loads(paths["protocol"].read_text()) protocol["execution_inputs"]["selection_output_sha256"] = forged_selection_sha256 for name, field in linked_inputs: protocol["execution_inputs"][field] = hashlib.sha256(paths[name].read_bytes()).hexdigest() paths["protocol"].write_text( json.dumps(protocol, sort_keys=True, separators=(",", ":")), encoding="utf-8", ) with pytest.raises(ValueError, match="selection does not match the scenario pack"): benchmark.load_execution_frozen_holdout( protocol_path=paths["protocol"], expected_protocol_sha256=hashlib.sha256(paths["protocol"].read_bytes()).hexdigest(), selection_path=paths["selection"], scenario_pack_path=paths["scenario_pack"], collision_path=paths["collision"], reconstructed_path=paths["reconstructed"], control_results_path=paths["controls"], environment_path=paths["environment"], schedule_path=paths["schedule"], source_map_path=paths["source_map"], ) assert len(list((state_root / "assignment-consumption").glob("*.json"))) == 1 assert not (state_root / "assignment-consumption" / f"{forged_assignment_sha256}.json").exists() def test_official_catalog_requires_the_frozen_cold_cache_contract(tmp_path: Path) -> None: holdout, _ = _official_holdout_fixture(tmp_path) cold = benchmark.CatalogSnapshot(tmp_path / "cold", {}, cache_hit=False) warm = benchmark.CatalogSnapshot(tmp_path / "warm", {}, cache_hit=True) benchmark.validate_official_catalog_cache_contract(holdout, cold) with pytest.raises(ValueError, match="cold catalog cache"): benchmark.validate_official_catalog_cache_contract(holdout, warm) def test_execution_frozen_holdout_loads_from_documented_module_mode( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: monkeypatch.setattr(benchmark, "__name__", "__main__") holdout, _ = _official_holdout_fixture(tmp_path) assert holdout.protocol_id == "production-graph-holdout-v2" assert len(holdout.scenarios) == 10 def test_execution_frozen_holdout_rejects_codex_or_provider_identity_drift( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: holdout, _ = _official_holdout_fixture(tmp_path) monkeypatch.setattr(benchmark, "_command_version", lambda _command: "different") with pytest.raises(ValueError, match="runtime conditions"): benchmark.validate_holdout_execution_conditions( holdout, model="gpt-5.5", timeout=900.0, arms=("baseline", "ctx-light"), trials=3, retries=0, scenario_filters=[], codex=sys.executable, ) provider_drift = replace( holdout, provider_config_sha256="0" * 64, ) monkeypatch.setattr(benchmark, "_command_version", lambda _command: "test") with pytest.raises(ValueError, match="runtime conditions"): benchmark.validate_holdout_execution_conditions( provider_drift, model="gpt-5.5", timeout=900.0, arms=("baseline", "ctx-light"), trials=3, retries=0, scenario_filters=[], codex=sys.executable, ) def test_runtime_reauthentication_rejects_mid_campaign_codex_drift( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: codex = tmp_path / "codex" codex.write_bytes(b"frozen-codex-binary") holdout_root = tmp_path / "holdout" holdout_root.mkdir() holdout, _ = _official_holdout_fixture(holdout_root, codex_path=codex) monkeypatch.setattr(benchmark, "_command_version", lambda _command: "test") conditions = { "model": "gpt-5.5", "timeout": 900.0, "arms": ("baseline", "ctx-light"), "trials": 3, "retries": 0, "scenario_filters": [], "codex": str(codex), } first = benchmark.validate_holdout_execution_conditions(holdout, **conditions) codex.write_bytes(b"drifted-codex-binary") assert first["codex_binary_sha256"] == holdout.codex_binary_sha256 with pytest.raises(ValueError, match="runtime conditions"): benchmark.validate_holdout_execution_conditions(holdout, **conditions) def test_runtime_reauthentication_rejects_python_dependency_drift( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: holdout, _ = _official_holdout_fixture(tmp_path) monkeypatch.setattr(benchmark, "_command_version", lambda _command: "test") monkeypatch.setattr(benchmark, "python_dependencies_sha256", lambda _python: "0" * 64) with pytest.raises(ValueError, match="runtime conditions"): benchmark.validate_holdout_execution_conditions( holdout, model="gpt-5.5", timeout=900.0, arms=("baseline", "ctx-light"), trials=3, retries=0, scenario_filters=[], codex=sys.executable, ) def test_execution_frozen_holdout_requires_python_dependency_identity( tmp_path: Path, ) -> None: holdout, paths = _official_holdout_fixture(tmp_path) environment = json.loads(paths["environment"].read_text()) del environment["python"]["dependencies_sha256"] paths["environment"].write_text( json.dumps(environment, sort_keys=True, separators=(",", ":")), encoding="utf-8", ) protocol = json.loads(paths["protocol"].read_text()) protocol["execution_inputs"]["execution_environment_sha256"] = hashlib.sha256( paths["environment"].read_bytes() ).hexdigest() paths["protocol"].write_text( json.dumps(protocol, sort_keys=True, separators=(",", ":")), encoding="utf-8", ) with pytest.raises(ValueError, match="private execution environment is invalid"): benchmark.load_execution_frozen_holdout( protocol_path=paths["protocol"], expected_protocol_sha256=hashlib.sha256(paths["protocol"].read_bytes()).hexdigest(), selection_path=paths["selection"], scenario_pack_path=paths["scenario_pack"], collision_path=paths["collision"], reconstructed_path=paths["reconstructed"], control_results_path=paths["controls"], environment_path=paths["environment"], schedule_path=paths["schedule"], source_map_path=paths["source_map"], ) assert holdout.execution_conditions["python"]["dependencies_sha256"] def test_execution_frozen_holdout_rejects_authenticated_runtime_arm_mismatch( tmp_path: Path, ) -> None: _, paths = _official_holdout_fixture(tmp_path) environment = json.loads(paths["environment"].read_text()) environment["codex"]["runtime_contract"]["arms"] = ["ctx-light", "baseline"] paths["environment"].write_text( json.dumps(environment, sort_keys=True, separators=(",", ":")), encoding="utf-8", ) protocol = json.loads(paths["protocol"].read_text()) protocol["execution_inputs"]["execution_environment_sha256"] = hashlib.sha256( paths["environment"].read_bytes() ).hexdigest() paths["protocol"].write_text( json.dumps(protocol, sort_keys=True, separators=(",", ":")), encoding="utf-8", ) with pytest.raises(ValueError, match="runtime contract is invalid"): benchmark.load_execution_frozen_holdout( protocol_path=paths["protocol"], expected_protocol_sha256=hashlib.sha256(paths["protocol"].read_bytes()).hexdigest(), selection_path=paths["selection"], scenario_pack_path=paths["scenario_pack"], collision_path=paths["collision"], reconstructed_path=paths["reconstructed"], control_results_path=paths["controls"], environment_path=paths["environment"], schedule_path=paths["schedule"], source_map_path=paths["source_map"], ) def test_python_dependency_identity_is_canonical_and_fail_closed( monkeypatch: pytest.MonkeyPatch, ) -> None: first = "z-package==2\r\na-package==1\n" second = "a-package==1\nz-package==2\n" assert benchmark.canonical_python_dependencies_bytes(first) == ( benchmark.canonical_python_dependencies_bytes(second) ) monkeypatch.setattr( benchmark, "run_process", lambda *_args, **_kwargs: benchmark.CommandResult( returncode=1, stdout="", stderr="pip unavailable", elapsed=0.1, ), ) with pytest.raises(ValueError, match="dependency inventory is unavailable"): benchmark.python_dependencies_sha256(sys.executable) @pytest.mark.parametrize( ("mutation", "message"), [ ("missing", "unsupported shape"), ("invalid", "acquisition protocol SHA-256"), ("arbitrary", "acquisition protocol identity"), ], ) def test_execution_frozen_holdout_rejects_invalid_acquisition_provenance( tmp_path: Path, mutation: str, message: str, ) -> None: holdout, paths = _official_holdout_fixture(tmp_path) protocol = json.loads(paths["protocol"].read_text()) if mutation == "missing": del protocol["execution_inputs"]["acquisition_protocol_sha256"] elif mutation == "invalid": protocol["execution_inputs"]["acquisition_protocol_sha256"] = "not-a-digest" else: protocol["execution_inputs"]["acquisition_protocol_sha256"] = "9" * 64 paths["protocol"].write_text( json.dumps(protocol, sort_keys=True, separators=(",", ":")), encoding="utf-8", ) with pytest.raises(ValueError, match=message): benchmark.load_execution_frozen_holdout( protocol_path=paths["protocol"], expected_protocol_sha256=hashlib.sha256(paths["protocol"].read_bytes()).hexdigest(), selection_path=paths["selection"], scenario_pack_path=paths["scenario_pack"], collision_path=paths["collision"], reconstructed_path=paths["reconstructed"], control_results_path=paths["controls"], environment_path=paths["environment"], schedule_path=paths["schedule"], source_map_path=paths["source_map"], ) assert holdout.acquisition_protocol_sha256 != "9" * 64 def test_execution_frozen_holdout_rejects_rehashed_claim_gate_drift( tmp_path: Path, ) -> None: from scripts import ctx_ab_holdout_freeze as freezer _, paths = _official_holdout_fixture(tmp_path) protocol = json.loads(paths["protocol"].read_text()) protocol["claim_gates"]["required_benefiting_repositories"] = 1 acquisition_protocol = dict(protocol) acquisition_protocol.pop("execution_frozen_at") acquisition_protocol["stage"] = "acquisition-frozen" acquisition_protocol["execution_inputs"] = {key: None for key in protocol["execution_inputs"]} protocol["execution_inputs"]["acquisition_protocol_sha256"] = hashlib.sha256( freezer._canonical_bytes(acquisition_protocol, newline=True) ).hexdigest() paths["protocol"].write_text( json.dumps(protocol, sort_keys=True, separators=(",", ":")), encoding="utf-8", ) with pytest.raises(ValueError, match="fixed V2 acquisition design drifted"): benchmark.load_execution_frozen_holdout( protocol_path=paths["protocol"], expected_protocol_sha256=hashlib.sha256(paths["protocol"].read_bytes()).hexdigest(), selection_path=paths["selection"], scenario_pack_path=paths["scenario_pack"], collision_path=paths["collision"], reconstructed_path=paths["reconstructed"], control_results_path=paths["controls"], environment_path=paths["environment"], schedule_path=paths["schedule"], source_map_path=paths["source_map"], ) def test_execution_frozen_holdout_rejects_noncanonical_acquisition_digest( tmp_path: Path, ) -> None: _, paths = _official_holdout_fixture(tmp_path) protocol = json.loads(paths["protocol"].read_text()) acquisition_protocol = dict(protocol) acquisition_protocol.pop("execution_frozen_at") acquisition_protocol["stage"] = "acquisition-frozen" acquisition_protocol["execution_inputs"] = {key: None for key in protocol["execution_inputs"]} noncanonical_bytes = (json.dumps(acquisition_protocol, indent=2) + "\n").encode() protocol["execution_inputs"]["acquisition_protocol_sha256"] = hashlib.sha256( noncanonical_bytes ).hexdigest() paths["protocol"].write_text( json.dumps(protocol, sort_keys=True, separators=(",", ":")), encoding="utf-8", ) with pytest.raises(ValueError, match="acquisition protocol identity"): benchmark.load_execution_frozen_holdout( protocol_path=paths["protocol"], expected_protocol_sha256=hashlib.sha256(paths["protocol"].read_bytes()).hexdigest(), selection_path=paths["selection"], scenario_pack_path=paths["scenario_pack"], collision_path=paths["collision"], reconstructed_path=paths["reconstructed"], control_results_path=paths["controls"], environment_path=paths["environment"], schedule_path=paths["schedule"], source_map_path=paths["source_map"], ) def test_execution_frozen_holdout_rejects_mutated_materialization_input( tmp_path: Path, ) -> None: holdout, paths = _official_holdout_fixture(tmp_path) paths["selection"].write_bytes(paths["selection"].read_bytes() + b"\n") assert benchmark.holdout_inputs_match_execution_freeze(holdout) is False with pytest.raises(ValueError, match="does not match the execution freeze"): benchmark.load_execution_frozen_holdout( protocol_path=holdout.protocol_path, expected_protocol_sha256=holdout.protocol_sha256, selection_path=paths["selection"], scenario_pack_path=paths["scenario_pack"], collision_path=paths["collision"], reconstructed_path=paths["reconstructed"], control_results_path=paths["controls"], environment_path=paths["environment"], schedule_path=paths["schedule"], source_map_path=paths["source_map"], ) def test_execution_frozen_holdout_rejects_incomplete_evaluator_closure( tmp_path: Path, ) -> None: holdout, paths = _official_holdout_fixture(tmp_path) controls = json.loads(paths["controls"].read_text()) scenario_id = next(iter(controls["scenario_results"])) del controls["scenario_results"][scenario_id]["official_swebench"]["green"][ "runtime_identity_sha256" ] paths["controls"].write_text( json.dumps(controls, sort_keys=True, separators=(",", ":")), encoding="utf-8", ) protocol = json.loads(paths["protocol"].read_text()) protocol["execution_inputs"]["control_results_sha256"] = hashlib.sha256( paths["controls"].read_bytes() ).hexdigest() paths["protocol"].write_text( json.dumps(protocol, sort_keys=True, separators=(",", ":")), encoding="utf-8", ) with pytest.raises(ValueError, match="red/green control evidence"): benchmark.load_execution_frozen_holdout( protocol_path=paths["protocol"], expected_protocol_sha256=hashlib.sha256(paths["protocol"].read_bytes()).hexdigest(), selection_path=paths["selection"], scenario_pack_path=paths["scenario_pack"], collision_path=paths["collision"], reconstructed_path=paths["reconstructed"], control_results_path=paths["controls"], environment_path=paths["environment"], schedule_path=paths["schedule"], source_map_path=paths["source_map"], ) assert holdout.image_ids def _official_result_rows( holdout: Any, *, status: str, failure_class: str | None, team_token_completeness: str = "not_applicable", ) -> list[dict[str, Any]]: rows: list[dict[str, Any]] = [] runtime_identity = { "codex_binary_sha256": holdout.codex_binary_sha256, "codex_runtime_contract_sha256": benchmark.codex_runtime_contract_sha256( CODEX_RUNTIME_CONTRACT ), "codex_version": "test", "provider": "openai", "provider_config_sha256": holdout.provider_config_sha256, "python_dependencies_sha256": benchmark.python_dependencies_sha256(sys.executable), "python_executable_sha256": hashlib.sha256(Path(sys.executable).read_bytes()).hexdigest(), "python_version": benchmark.platform.python_version(), } for scenario in holdout.scenarios: for trial in range(1, 4): for arm in ("baseline", "ctx-light"): row = benchmark._VerifiedProductionResult( { "agent_timeout_seconds": 900.0, "arm": arm, "cached_input_tokens": 20, "catalog_cache_hit": False, "context_delivery_verified": arm == "ctx-light", "delivered_prompt_sha256": "b" * 64, "development_seconds": 10.0, "engine": benchmark.PRODUCTION_CATALOG_ENGINE, "environment_manifest_matches_start_at_end": True, "evaluator_contract_sha256": "c" * 64, "evaluator_isolation_verified": True, "evidence_level": ( "official_swebench_scored" if status == "passed" else "official_swebench_model_quality_failure" ), "frozen_scenario_sha256": holdout.scenario_sha256[scenario.id], "frozen_schedule_sha256": holdout.schedule.sha256, "frozen_codex_binary_sha256": holdout.codex_binary_sha256, "codex_runtime_contract_sha256": ( benchmark.codex_runtime_contract_sha256(CODEX_RUNTIME_CONTRACT) ), "frozen_provider": "openai", "frozen_provider_config_sha256": holdout.provider_config_sha256, "harness_total_seconds": 12.0, "holdout_collision_sha256": holdout.collision_sha256, "holdout_acquisition_protocol_sha256": ( holdout.acquisition_protocol_sha256 ), "holdout_control_results_sha256": holdout.control_results_sha256, "holdout_environment_sha256": holdout.environment_sha256, "holdout_inputs_match_start_at_end": True, "holdout_protocol_sha256": holdout.protocol_sha256, "holdout_reconstructed_sha256": holdout.reconstructed_sha256, "holdout_scenario_pack_sha256": holdout.scenario_pack_sha256, "holdout_selection_sha256": holdout.selection_sha256, "input_tokens": 100, "measured_phase_seconds": 10.0, "model": "gpt-5.5", "output_tokens": 30, "policy_valid": True, "production_efficiency_eligible": True, "repo_url": scenario.repo_url, "repository_state_matches_start_at_end": True, "runtime_identity_before_arm": runtime_identity, "runtime_identity_matches_start_at_end": True, "runtime_identity_verified_before_arm": True, "sandbox_contract": benchmark.OFFICIAL_SANDBOX_CONTRACT, "scenario": scenario.id, "scenario_commit": scenario.commit, "status": status, "task_prompt_sha256": "a" * 64, "team_token_completeness": team_token_completeness, "token_attribution": "exact", "total_tokens": 130, "trial": trial, "uncached_input_tokens": 80, "verification_backend": benchmark.OFFICIAL_HOLDOUT_BACKEND, "verification_failure_class": failure_class, "verification_passed": status == "passed", } ) row.seal() rows.append(row) return rows @pytest.mark.parametrize( "artifact", ["protocol", "selection", "scenario_pack", "collision", "controls"], ) def test_official_verdict_rejects_post_attestation_artifact_drift( tmp_path: Path, artifact: str, ) -> None: holdout, paths = _official_holdout_fixture(tmp_path) rows = _official_result_rows(holdout, status="passed", failure_class=None) report_kwargs = { "scenario_ids": [scenario.id for scenario in holdout.scenarios], "trials": 3, "arms": ("baseline", "ctx-light"), "expected_repositories": {scenario.id: scenario.repo_url for scenario in holdout.scenarios}, "frozen_schedule": holdout.schedule, "official_holdout": holdout, } performance = benchmark.build_performance_report(rows, **report_kwargs) assert benchmark.holdout_inputs_match_execution_freeze(holdout) is True paths[artifact].write_bytes(paths[artifact].read_bytes() + b"\n") output = tmp_path / "output" output.mkdir() with pytest.raises(ValueError, match="changed after authentication"): benchmark.write_performance_report(output, rows, **report_kwargs) assert not (output / "performance.json").exists() with pytest.raises(ValueError, match="changed after authentication"): benchmark.write_public_holdout_summary(output, rows, performance, holdout) assert not (output / "public-summary.json").exists() def test_authenticated_freeze_drives_all_thirty_pairs_and_sixty_arms( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: monkeypatch.setattr(benchmark.sys, "platform", "darwin") holdout, paths = _official_holdout_fixture(tmp_path) result_by_key = { (row["scenario"], row["trial"], row["arm"]): dict(row) for row in _official_result_rows(holdout, status="passed", failure_class=None) } calls: list[tuple[str, int, str]] = [] runtime_identity_checks: list[dict[str, str]] = [] run_root = tmp_path / "runs" output = run_root / "confirmatory" cache_root = tmp_path / "cache" state_root = tmp_path / "private-state" repository_identity_checks: list[dict[str, str]] = [] repository_identity = { "head": holdout.origin_main_revision, "origin_fetch_url": holdout.origin_url, "origin_main_revision": holdout.origin_main_revision, "origin_push_url": holdout.origin_url, } monkeypatch.setattr(benchmark, "PRODUCTION_PRIVATE_RUN_ROOT", run_root) monkeypatch.setattr(benchmark, "_official_campaign_state_root", lambda: state_root) monkeypatch.setattr( benchmark, "_validate_production_scenarios_path", lambda path, *, live: path.resolve(), ) monkeypatch.setattr(benchmark, "_command_version", lambda _command: "test") dependency_identity_checks: list[str] = [] frozen_dependencies_sha256 = str(holdout.execution_conditions["python"]["dependencies_sha256"]) def record_dependency_identity(python: str | Path) -> str: dependency_identity_checks.append(str(python)) return frozen_dependencies_sha256 monkeypatch.setattr( benchmark, "python_dependencies_sha256", record_dependency_identity, ) validate_runtime = benchmark.validate_holdout_execution_conditions def record_runtime_identity(*args: Any, **kwargs: Any) -> dict[str, str]: identity = validate_runtime(*args, **kwargs) runtime_identity_checks.append(identity) return identity monkeypatch.setattr( benchmark, "validate_holdout_execution_conditions", record_runtime_identity, ) monkeypatch.setattr( benchmark, "collect_repository_state", lambda: { "clean": True, "head": "a" * 40, "status": [], "tracked_diff_sha256": "d" * 64, }, ) def record_repository_identity() -> dict[str, str]: repository_identity_checks.append(dict(repository_identity)) return dict(repository_identity) monkeypatch.setattr( benchmark, "collect_official_repository_identity", record_repository_identity, ) monkeypatch.setattr( benchmark, "validate_runtime_pack_scenario_independence", lambda *_args, **_kwargs: { "guard": "runtime-pack-distinctive-evidence-v1", "runtime_availability_sha256": "e" * 64, }, ) monkeypatch.setattr( benchmark, "prepare_production_catalog", lambda _cache_root: benchmark.CatalogSnapshot( wiki_dir=tmp_path / "wiki", provenance={ "archive_sha256": "f" * 64, "graph_export_id": "frozen-export", "graph_export_manifest_sha256": "1" * 64, "overlay_records": 0, "overlay_sha256": "2" * 64, "runtime_availability_sha256": "3" * 64, }, prepare_seconds=30.0, ), ) monkeypatch.setattr( benchmark, "verify_scenario_independence_attestation", lambda *_args, **_kwargs: None, ) def reject_repo_cache(*_args: Any, **_kwargs: Any) -> Path: raise AssertionError("official execution must not use the network cache") monkeypatch.setattr(benchmark, "ensure_repo_cache", reject_repo_cache) def write_manifest(**kwargs: Any) -> dict[str, Any]: manifest = { "model": kwargs["model"], "schedule": kwargs["schedule"], "scenarios_sha256": holdout.scenario_pack_sha256, } (kwargs["output"] / "environment.json").write_text( json.dumps(manifest, indent=2) + "\n", encoding="utf-8", ) return manifest monkeypatch.setattr(benchmark, "write_environment_manifest", write_manifest) monkeypatch.setattr( benchmark, "write_final_repository_attestation", lambda *_args, **_kwargs: ( True, True, { "clean": True, "head": "a" * 40, "status": [], "tracked_diff_sha256": "d" * 64, }, ), ) def run_trial( scenario: Any, *, arm: str, treatment_level: str, attempt: int, trial: int, retry: int, cache: Path, output: Path, codex: str, model: str, timeout: float, dry_run: bool, incidents: Any, catalog_snapshot: Any, forbidden_agent_reads: Any, official_holdout: Any, official_runtime: Any, official_source: Any, runtime_identity_before_arm: Any, catalog_setup_charge_seconds: float, ) -> dict[str, Any]: assert treatment_level == arm assert attempt == trial assert retry == 0 assert official_source == holdout.source_bundles[scenario.repo_url] assert cache == official_source.bundle_path assert output == run_root / "confirmatory" assert codex == sys.executable assert model == "gpt-5.5" assert timeout == 900.0 assert dry_run is False assert isinstance(incidents, benchmark.IncidentLog) assert catalog_snapshot.prepare_seconds == 30.0 assert forbidden_agent_reads["scenario_source"] == paths["scenario_pack"].resolve() assert official_holdout.protocol_sha256 == holdout.protocol_sha256 assert official_runtime.dataset_path == tmp_path / "dataset.jsonl" assert official_runtime.swebench_checkout == tmp_path / "swebench" assert official_runtime.swebench_python == tmp_path / "swebench-python" assert official_runtime.docker_cli == tmp_path / "docker" assert official_runtime.docker_host == "unix:///private/docker.sock" assert runtime_identity_before_arm["codex_binary_sha256"] == holdout.codex_binary_sha256 assert runtime_identity_before_arm["codex_runtime_contract_sha256"] == ( benchmark.codex_runtime_contract_sha256(CODEX_RUNTIME_CONTRACT) ) assert runtime_identity_before_arm["provider_config_sha256"] == ( holdout.provider_config_sha256 ) assert runtime_identity_before_arm["python_dependencies_sha256"] == ( frozen_dependencies_sha256 ) assert catalog_setup_charge_seconds == (1.0 if arm == "ctx-light" else 0.0) calls.append((scenario.id, trial, arm)) result = dict(result_by_key[(scenario.id, trial, arm)]) result["runtime_identity_before_arm"] = dict(runtime_identity_before_arm) return result monkeypatch.setattr(benchmark, "run_trial", run_trial) verifier_inputs = { "swebench-dataset": tmp_path / "dataset.jsonl", "swebench-checkout": tmp_path / "swebench", "swebench-python": tmp_path / "swebench-python", "docker-cli": tmp_path / "docker", } exit_code = benchmark.main( [ "--engine", benchmark.PRODUCTION_CATALOG_ENGINE, "--arm", "both", "--trials", "3", "--retries", "0", "--timeout", "900", "--model", "gpt-5.5", "--codex", sys.executable, "--cache-root", str(cache_root), "--output", str(output), "--holdout-protocol", str(paths["protocol"]), "--holdout-protocol-sha256", holdout.protocol_sha256, "--holdout-selection", str(paths["selection"]), "--holdout-scenario-pack", str(paths["scenario_pack"]), "--holdout-collision", str(paths["collision"]), "--holdout-reconstructed", str(paths["reconstructed"]), "--holdout-controls", str(paths["controls"]), "--holdout-environment", str(paths["environment"]), "--holdout-schedule", str(paths["schedule"]), "--holdout-source-map", str(paths["source_map"]), *[ value for option, path in verifier_inputs.items() for value in (f"--{option}", str(path)) ], "--docker-host", "unix:///private/docker.sock", ] ) expected_calls = [ (str(assignment["scenario"]), int(assignment["trial"]), str(arm)) for assignment in holdout.schedule.assignments for arm in assignment["arms"] ] assert exit_code == 0 assert calls == expected_calls assert len(calls) == 60 assert len(runtime_identity_checks) == 62 assert len(repository_identity_checks) == 62 assert len(dependency_identity_checks) == 62 assert set(dependency_identity_checks) == {sys.executable} assert all(identity == runtime_identity_checks[0] for identity in runtime_identity_checks) report = json.loads((output / "performance.json").read_text()) assert report["assignment_complete"] is True assert report["experiment_valid"] is True assert report["product_benefit_verdict"] == "not_beneficial" public_summary = json.loads((output / "public-summary.json").read_text()) assert public_summary["benefit_verdict"] == "not_beneficial" assert public_summary["quality_gate"] == { "criterion": "all assigned arm outcomes observed and passed", "label": "observed quality preservation", "passed": True, } expected_public_claim = dict(report["official_repository_claim"]) expected_public_claim["observed_quality_preservation"] = expected_public_claim.pop( "quality_preserved" ) assert public_summary["official_repository_claim"] == expected_public_claim assert list(csv.DictReader((output / "incidents.csv").open())) == [] assert not (state_root / "runtime-guard" / "campaign.lock").exists() assert (state_root / "assignment-consumption" / f"{holdout.assignment_sha256}.json").is_file() assert (state_root / "selection-consumption" / f"{holdout.selection_sha256}.json").is_file() assert (state_root / "protocol-consumption" / f"{holdout.protocol_sha256}.json").is_file() def test_confirmatory_dual_model_failure_is_valid_honest_negative( tmp_path: Path, ) -> None: holdout, _ = _official_holdout_fixture(tmp_path) rows = _official_result_rows(holdout, status="failed", failure_class="model") report = benchmark.build_performance_report( rows, scenario_ids=[scenario.id for scenario in holdout.scenarios], trials=3, arms=("baseline", "ctx-light"), expected_repositories={scenario.id: scenario.repo_url for scenario in holdout.scenarios}, frozen_schedule=holdout.schedule, official_holdout=holdout, ) assert report["experiment_valid"] is True assert report["quality_preserved"] is False assert report["quality_complete_pair_count"] == 0 assert report["execution_complete_pair_count"] == 30 assert report["product_benefit_verdict"] == "not_beneficial" assert report["official_repository_claim"]["quality_preserved"] is False assert report["official_repository_claim"]["passed"] is False public_summary = benchmark.build_public_holdout_summary(rows, report, holdout) assert public_summary["quality_gate"]["passed"] is False assert public_summary["quality_gate"]["label"] == "observed quality preservation" assert public_summary["official_repository_claim"]["observed_quality_preservation"] is False assert "non-inferiority" not in json.dumps(public_summary).lower() expected = { (scenario.id, arm, trial) for scenario in holdout.scenarios for trial in range(1, 4) for arm in ("baseline", "ctx-light") } assert benchmark.confirmatory_run_succeeded( final_keys=expected, expected_keys=expected, performance=report, unresolved_incidents=0, ) def _updated_official_rows( rows: list[dict[str, Any]], *, predicate: Any, updates: dict[str, Any], ) -> list[dict[str, Any]]: updated: list[dict[str, Any]] = [] for row in rows: values = dict(row) if predicate(values): values.update(updates) sealed = benchmark._VerifiedProductionResult(values) sealed.seal() updated.append(sealed) return updated def _descriptive_official_rows(holdout: Any) -> list[dict[str, Any]]: rows = _official_result_rows(holdout, status="passed", failure_class=None) common = { "agent_returncode": 0, "agent_timed_out": False, "descriptive_record_schema_version": 1, "descriptive_trace_complete": True, "verification_returncode": 0, } rows = _updated_official_rows(rows, predicate=lambda _row: True, updates=common) rows = _updated_official_rows( rows, predicate=lambda row: row["arm"] == "baseline", updates={ "tool_command_count": 10, "tool_command_exit_code_known_count": 10, "tool_command_output_known_count": 10, "tool_command_text_known_count": 10, "tool_failure_count": 1, "tool_output_bytes": 100, "repeated_tool_command_count": 2, }, ) return _updated_official_rows( rows, predicate=lambda row: row["arm"] == "ctx-light", updates={ "candidate_ids": ["skill:private-candidate"], "selected_ids": ["skill:private-candidate"], "delivered_ids": ["skill:private-candidate"], "used_ids": [], "recommendation_invocation_verified": True, "semantic_context_use_verified": None, "skill_use_evidence_unavailable_reason": ( "provider_does_not_expose_semantic_context_attribution" ), "lifecycle_actions": [ "load_requested", "load_applied", "unload_requested", "unload_applied", "session_end", ], "lifecycle_sha256": "e" * 64, "lifecycle_session_status": "passed", "final_loaded": [], "tool_command_count": 8, "tool_command_exit_code_known_count": 8, "tool_command_output_known_count": 8, "tool_command_text_known_count": 8, "tool_failure_count": 0, "tool_output_bytes": 80, "repeated_tool_command_count": 1, }, ) def _official_performance(holdout: Any, rows: list[dict[str, Any]]) -> dict[str, Any]: return benchmark.build_performance_report( rows, scenario_ids=[scenario.id for scenario in holdout.scenarios], trials=3, arms=("baseline", "ctx-light"), expected_repositories={scenario.id: scenario.repo_url for scenario in holdout.scenarios}, frozen_schedule=holdout.schedule, official_holdout=holdout, ) def test_public_summary_freezes_descriptive_arm_pair_and_ctx_funnel_metrics( tmp_path: Path, ) -> None: holdout, _ = _official_holdout_fixture(tmp_path) rows = _descriptive_official_rows(holdout) summary = benchmark.build_public_holdout_summary( rows, _official_performance(holdout, rows), holdout, ) assert summary["schema_version"] == 2 assert summary["descriptive_metrics_published"] is True descriptive = summary["descriptive_metrics"] assert descriptive["schema_version"] == 1 assert descriptive["analysis_role"] == "descriptive_non_confirmatory" assert descriptive["causal_interpretation"] == "unsupported" assert descriptive["used_by_primary_verdict"] is False assert descriptive["thresholds"] is None assert descriptive["population"] == { "assigned_arm_n": 60, "assigned_pair_n": 30, "outcome_filtering": "none", } command_metrics = descriptive["completed_shell_command_executions"] assert command_metrics["calls"]["arms"]["baseline"] == { "assigned_n": 30, "known_n": 30, "missing_n": 0, "total": 300, "median": 10.0, } assert command_metrics["calls"]["pairs"] == { "assigned_pair_n": 30, "complete_pair_n": 30, "missing_pair_n": 0, "median_ctx_minus_baseline": -2.0, "ctx_lower_pair_n": 30, "equal_pair_n": 0, "ctx_higher_pair_n": 0, } assert command_metrics["failed_calls"]["arms"]["baseline"]["total"] == 30 assert command_metrics["failed_calls"]["arms"]["ctx-light"]["total"] == 0 assert command_metrics["exit_code_known_calls"]["arms"]["baseline"]["total"] == 300 assert command_metrics["exit_code_known_calls"]["arms"]["ctx-light"]["total"] == 240 assert descriptive["ctx_funnel"]["candidate_count"] == { "assigned_n": 30, "known_n": 30, "missing_n": 0, "total": 30, "median": 1.0, } assert descriptive["ctx_funnel"]["semantic_use_count"]["known_n"] == 0 assert descriptive["ctx_funnel"]["semantic_use_count"]["missing_n"] == 30 assert descriptive["lifecycle_events"]["load_applied_count"]["total"] == 30 assert descriptive["lifecycle_events"]["used_count"]["total"] == 0 assert descriptive["errors"]["agent_timeout"]["arms"]["baseline"]["total"] == 0 def test_descriptive_contract_asset_matches_public_schema( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: path = ROOT / "benchmarks" / "ctx_ab" / "descriptive-metrics-v1.json" content = path.read_bytes() contract = json.loads(content) assert hashlib.sha256(content).hexdigest() == (benchmark.DESCRIPTIVE_METRICS_CONTRACT_SHA256) assert contract["schema_version"] == benchmark.DESCRIPTIVE_PUBLIC_SCHEMA_VERSION assert contract["raw_arm_record"]["schema_version_value"] == ( benchmark.DESCRIPTIVE_RECORD_SCHEMA_VERSION ) assert contract["analysis_role"] == "descriptive_non_confirmatory" assert contract["used_by_primary_verdict"] is False assert contract["thresholds"] is None changed = tmp_path / "changed-descriptive-contract.json" changed.write_bytes(content + b"\n") monkeypatch.setattr(benchmark, "DESCRIPTIVE_METRICS_CONTRACT", changed) with pytest.raises(ValueError, match="changed after preregistration"): benchmark._descriptive_metrics_contract() def test_descriptive_summary_withholds_partial_campaign_and_rejects_duplicates( tmp_path: Path, ) -> None: holdout, _ = _official_holdout_fixture(tmp_path) rows = _descriptive_official_rows(holdout) performance = _official_performance(holdout, rows) partial = benchmark.build_public_holdout_summary(rows[:-1], performance, holdout) assert partial["descriptive_metrics_published"] is False assert "descriptive_metrics" not in partial with pytest.raises(ValueError, match="duplicate descriptive arm record"): benchmark.build_public_holdout_summary([*rows, rows[0]], performance, holdout) def test_descriptive_summary_retains_unknowns_and_never_copies_private_values( tmp_path: Path, ) -> None: holdout, _ = _official_holdout_fixture(tmp_path) rows = _descriptive_official_rows(holdout) sentinel = "PRIVATE-DESCRIPTIVE-SENTINEL" first_ctx = next(row for row in rows if row["arm"] == "ctx-light") first_ctx_key = (first_ctx["scenario"], first_ctx["trial"], first_ctx["arm"]) rows = _updated_official_rows( rows, predicate=lambda row: (row["scenario"], row["trial"], row["arm"]) == first_ctx_key, updates={ "recommendation_invocation_verified": False, "candidate_ids": [], "tool_command_exit_code_known_count": 7, "error": sentinel, "raw_command": f"pytest {sentinel}", "aggregated_output": sentinel, }, ) performance = _official_performance(holdout, rows) performance["benefit_verdict"] = sentinel performance["official_repository_claim"] = { **performance["official_repository_claim"], "private_detail": sentinel, } summary = benchmark.build_public_holdout_summary(rows, performance, holdout) failed = summary["descriptive_metrics"]["completed_shell_command_executions"]["failed_calls"][ "arms" ]["ctx-light"] assert failed["known_n"] == 29 assert failed["missing_n"] == 1 exit_code_denominator = summary["descriptive_metrics"]["completed_shell_command_executions"][ "exit_code_known_calls" ]["arms"]["ctx-light"] assert exit_code_denominator["known_n"] == 30 assert exit_code_denominator["total"] == 239 funnel = summary["descriptive_metrics"]["ctx_funnel"] assert funnel["recommendation_invocation_count"]["known_n"] == 29 assert funnel["candidate_count"]["missing_n"] == 1 assert summary["benefit_verdict"] is None assert "protocol_id" not in summary assert "protocol_sha256" not in summary assert "schedule_sha256" not in summary assert sentinel not in json.dumps(summary) def test_descriptive_population_retains_a_sealed_harness_failure_as_missing( tmp_path: Path, ) -> None: holdout, _ = _official_holdout_fixture(tmp_path) rows = _descriptive_official_rows(holdout) target = next(row for row in rows if row["arm"] == "baseline") target_key = (target["scenario"], target["trial"], target["arm"]) sparse_rows: list[dict[str, Any]] = [] for row in rows: values = dict(row) if (values["scenario"], values["trial"], values["arm"]) == target_key: for field in ( "agent_returncode", "agent_timed_out", "descriptive_record_schema_version", "descriptive_trace_complete", "tool_command_count", "tool_command_exit_code_known_count", "tool_command_output_known_count", "tool_command_text_known_count", "tool_failure_count", "tool_output_bytes", "repeated_tool_command_count", "verification_returncode", ): values.pop(field, None) values["status"] = "harness_error" values["production_efficiency_eligible"] = False sealed = benchmark._VerifiedProductionResult(values) sealed.seal() sparse_rows.append(sealed) summary = benchmark.build_public_holdout_summary( sparse_rows, _official_performance(holdout, sparse_rows), holdout, ) calls = summary["descriptive_metrics"]["completed_shell_command_executions"]["calls"]["arms"][ "baseline" ] assert summary["descriptive_metrics"]["population"]["assigned_arm_n"] == 60 assert calls["known_n"] == 29 assert calls["missing_n"] == 1 assert ( summary["descriptive_metrics"]["errors"]["harness_error"]["arms"]["baseline"]["total"] == 1 ) def test_descriptive_fields_do_not_change_primary_performance_verdict(tmp_path: Path) -> None: holdout, _ = _official_holdout_fixture(tmp_path) rows = _descriptive_official_rows(holdout) changed = _updated_official_rows( rows, predicate=lambda _row: True, updates={ "tool_command_count": 999, "tool_command_exit_code_known_count": 999, "tool_command_output_known_count": 999, "tool_command_text_known_count": 999, "tool_failure_count": 998, "tool_output_bytes": 123456789, "repeated_tool_command_count": 997, }, ) assert _official_performance(holdout, changed) == _official_performance(holdout, rows) def test_official_claim_rejects_time_only_improvement(tmp_path: Path) -> None: holdout, _ = _official_holdout_fixture(tmp_path) rows = _updated_official_rows( _official_result_rows(holdout, status="passed", failure_class=None), predicate=lambda row: row["arm"] == "ctx-light", updates={"development_seconds": 8.0, "measured_phase_seconds": 8.0}, ) report = benchmark.build_performance_report( rows, scenario_ids=[scenario.id for scenario in holdout.scenarios], trials=3, arms=("baseline", "ctx-light"), expected_repositories={scenario.id: scenario.repo_url for scenario in holdout.scenarios}, frozen_schedule=holdout.schedule, official_holdout=holdout, ) assert report["median_time_ratio"] == 0.8 assert report["median_uncached_token_ratio"] == 1.0 assert report["official_repository_claim"] == { "benefiting_repositories": 0, "evidence_complete": True, "exact_one_sided_sign_p": 1.0, "incident_free": True, "overall_time_ratio": 0.8, "overall_token_ratio": 1.0, "passed": False, "quality_preserved": True, "verified_delivery_repositories": 10, } assert report["benefit_verdict"] == "not_beneficial" assert report["product_beneficial"] is False assert report["product_benefit_verdict"] == "not_beneficial" def test_official_claim_requires_delivery_in_all_ten_repositories(tmp_path: Path) -> None: holdout, _ = _official_holdout_fixture(tmp_path) first_scenario = holdout.scenarios[0].id rows = _updated_official_rows( _official_result_rows(holdout, status="passed", failure_class=None), predicate=lambda row: row["arm"] == "ctx-light", updates={ "cached_input_tokens": 20, "input_tokens": 84, "output_tokens": 30, "total_tokens": 114, "uncached_input_tokens": 64, }, ) rows = _updated_official_rows( rows, predicate=lambda row: row["arm"] == "ctx-light" and row["scenario"] == first_scenario, updates={ "adopted_ids": [], "body_fetch_seconds": 0, "catalog_recommendation_lifecycle_verified": True, "context_delivery_verified": False, "delivered_ids": [], "delivered_prompt_sha256": "a" * 64, "evidence_level": benchmark.PRODUCTION_POLICY_ABSTENTION_LEVEL, "lifecycle_actions": ["dev_event", "session_end"], "lifecycle_session_status": "passed", "pinned_head_verified": True, "policy_abstention_applied": True, "policy_abstention_reason": "language_only_match", "policy_abstention_verified": True, "selected_ids": [], "used_ids": [], }, ) report = benchmark.build_performance_report( rows, scenario_ids=[scenario.id for scenario in holdout.scenarios], trials=3, arms=("baseline", "ctx-light"), expected_repositories={scenario.id: scenario.repo_url for scenario in holdout.scenarios}, frozen_schedule=holdout.schedule, official_holdout=holdout, ) assert report["experiment_valid"] is True assert report["median_uncached_token_ratio"] == 0.8 assert report["official_repository_claim"]["benefiting_repositories"] == 10 assert report["official_repository_claim"]["overall_token_ratio"] == 0.8 assert report["official_repository_claim"]["verified_delivery_repositories"] == 9 assert report["official_repository_claim"]["passed"] is False assert report["product_beneficial"] is False assert report["product_benefit_verdict"] == "not_beneficial" def test_confirmatory_rejects_unknown_delegated_agent_tokens(tmp_path: Path) -> None: holdout, _ = _official_holdout_fixture(tmp_path) rows = _official_result_rows( holdout, status="passed", failure_class=None, team_token_completeness="unknown", ) report = benchmark.build_performance_report( rows, scenario_ids=[scenario.id for scenario in holdout.scenarios], trials=3, arms=("baseline", "ctx-light"), expected_repositories={scenario.id: scenario.repo_url for scenario in holdout.scenarios}, frozen_schedule=holdout.schedule, ) assert report["experiment_valid"] is False assert report["execution_complete_pair_count"] == 0 def test_entity_activity_claims_only_observed_lifecycle_transitions() -> None: catalog = { "candidates": [ {"id": "skill:s", "type": "skill"}, {"id": "agent:a", "type": "agent"}, {"id": "mcp-server:m", "type": "mcp-server"}, ], "deferred_activation": {"deferred_candidates": [{"id": "agent:a", "type": "agent"}]}, } lifecycle = { "events": [ {"action": "load_applied", "entity_type": "skill"}, {"action": "used", "entity_type": "skill"}, {"action": "unload_applied", "entity_type": "skill"}, ] } assert benchmark.actual_entity_type_activity( catalog=catalog, selected_items=[{"id": "skill:s", "type": "skill"}], lifecycle=lifecycle, ) == { "recommended_entity_types": ["agent", "mcp-server", "skill"], "selected_entity_types": ["skill"], "deferred_entity_types": ["agent"], "loaded_entity_types": ["skill"], "used_entity_types": ["skill"], "unloaded_entity_types": ["skill"], } def test_official_verifier_is_the_scored_quality_path( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: from scripts import ctx_ab_swebench holdout, _ = _official_holdout_fixture(tmp_path) scenario = holdout.scenarios[0] captured: dict[str, Any] = {} def fake_verify(**kwargs: Any) -> dict[str, Any]: captured.update(kwargs) return { "validation": { "image_id": holdout.image_ids[scenario.id], "phase": "scored", "resolved": True, } } monkeypatch.setattr(ctx_ab_swebench, "verify_swebench", fake_verify) run_dir = tmp_path / "scored" run_dir.mkdir() runtime = benchmark.OfficialVerifierRuntime( dataset_path=tmp_path / "dataset.jsonl", swebench_checkout=tmp_path / "swebench", swebench_python=tmp_path / "python", docker_cli=tmp_path / "docker", docker_host="unix:///private/docker.sock", ) result = benchmark.verify_official_model_patch( holdout=holdout, runtime=runtime, scenario=scenario, model_patch="diff --git a/src/feature.py b/src/feature.py\n", run_dir=run_dir, ) assert result.passed is True assert captured["phase"] == "scored" assert captured["instance_id"] == scenario.id assert captured["model_patch"].startswith("diff --git") assert captured["expected_image_id"] == holdout.image_ids[scenario.id] assert captured["allow_image_pull"] is False assert "test_body" not in captured assert "reference_patch" not in captured assert (run_dir / "official-verification-evidence.json").is_file() def test_official_development_timing_includes_ctx_catalog_but_excludes_evaluator() -> None: totals = benchmark.trial_timing_totals( ctx_setup_seconds=2.0, catalog_setup_seconds=4.0, agent_seconds=10.0, teardown_seconds=3.0, verification_seconds=40.0, official_evaluator=True, ) assert totals == { "development_seconds": 19.0, "measured_phase_seconds": 19.0, "total_seconds": 59.0, } baseline = benchmark.trial_timing_totals( ctx_setup_seconds=0.0, catalog_setup_seconds=0.0, agent_seconds=10.0, teardown_seconds=0.0, verification_seconds=40.0, official_evaluator=True, ) assert baseline["development_seconds"] == 10.0 def test_official_verifier_boundary_classifies_unexpected_failures_as_evaluator( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: from scripts import ctx_ab_swebench holdout, _ = _official_holdout_fixture(tmp_path) scenario = holdout.scenarios[0] def fail(**_kwargs: Any) -> dict[str, Any]: raise OSError("docker daemon unavailable") monkeypatch.setattr(ctx_ab_swebench, "verify_swebench", fail) run_dir = tmp_path / "failed-scored" run_dir.mkdir() result = benchmark.verify_official_model_patch( holdout=holdout, runtime=benchmark.OfficialVerifierRuntime( dataset_path=tmp_path / "dataset.jsonl", swebench_checkout=tmp_path / "swebench", swebench_python=tmp_path / "python", docker_cli=tmp_path / "docker", docker_host="unix:///private/docker.sock", ), scenario=scenario, model_patch="diff --git a/src/feature.py b/src/feature.py\n", run_dir=run_dir, ) assert result.passed is False assert result.failure_class == "evaluator" failure = json.loads((run_dir / "official-verification-failure.json").read_text()) assert failure["error_type"] == "OSError" assert failure["failure_class"] == "evaluator"