claude-dev-env 4.2.0 → 7.0.0

package/.agents/skills/_shared/pr-loop/scripts/test_build_audit_prompt.py

@@ -1,499 +0,0 @@
-"""Tests pinning build_audit_prompt's emitted A-Q category taxonomy."""
-
-from __future__ import annotations
-
-import importlib.util
-import re
-import sys
-from pathlib import Path
-from types import ModuleType
-from xml.etree.ElementTree import Element
-
-import pytest
-
-_SCRIPTS_DIR = Path(__file__).resolve().parent
-_skills_home_directory = _SCRIPTS_DIR.parents[3]
-_PACKAGE_ROOT_FOR_RUBRICS = (
-    _skills_home_directory.parent
-    if _skills_home_directory.name == ".agents"
-    else _skills_home_directory
-)
-if str(_SCRIPTS_DIR) not in sys.path:
-    sys.path.insert(0, str(_SCRIPTS_DIR))
-
-from skills_pr_loop_constants.path_resolver_constants import (
-    ALL_AUDIT_CATEGORY_ENTRIES,
-    AUDIT_COMMENT_POSTING_AGENT_TEXT,
-    AUDIT_COMMENT_POSTING_HEADLESS_TEXT,
-    AUDIT_OUTPUT_FORMAT_AGENT_TEXT,
-    AUDIT_OUTPUT_FORMAT_HEADLESS_TEMPLATE,
-    AUDIT_PROMPT_FLAVOR_AGENT,
-    AUDIT_PROMPT_FLAVOR_HEADLESS,
-    OUTCOME_XML_TEMPLATE,
-)
-
-_CATEGORY_RUBRICS_DIR = _PACKAGE_ROOT_FOR_RUBRICS / "audit-rubrics" / "category_rubrics"
-_HEADING_PATTERN = re.compile(r"^# Category ([A-Q]) — (.+)$")
-
-
-def _load_build_audit_prompt() -> ModuleType:
-    module_path = _SCRIPTS_DIR / "build_audit_prompt.py"
-    spec = importlib.util.spec_from_file_location("build_audit_prompt", module_path)
-    assert spec is not None
-    assert spec.loader is not None
-    module = importlib.util.module_from_spec(spec)
-    sys.modules["build_audit_prompt"] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-build_audit_prompt = _load_build_audit_prompt()
-
-
-def _rubric_label_by_letter() -> dict[str, str]:
-    assert _CATEGORY_RUBRICS_DIR.is_dir(), f"Missing rubric directory: {_CATEGORY_RUBRICS_DIR}"
-    all_labels: dict[str, str] = {}
-    for each_rubric_file in sorted(_CATEGORY_RUBRICS_DIR.glob("category-*.md")):
-        all_rubric_lines = each_rubric_file.read_text(encoding="utf-8").splitlines()
-        assert all_rubric_lines, f"Empty rubric file: {each_rubric_file}"
-        each_match = _HEADING_PATTERN.match(all_rubric_lines[0])
-        assert each_match is not None, f"Heading pattern not matched in {each_rubric_file}"
-        all_labels[each_match.group(1)] = each_match.group(2)
-    return all_labels
-
-
-def _build_audit_root() -> Element:
-    return build_audit_prompt.build_audit_prompt_xml(
-        owner="jl-cmd",
-        repo="claude-dev-env",
-        pr_number=422,
-        loop=1,
-        head_ref="feat/branch",
-        base_ref="main",
-        worktree_path=Path("/tmp/bugteam-pr-422/worktree"),
-        run_temp_dir=Path("/tmp/bugteam-pr-422"),
-    )
-
-
-def test_context_and_scope_render_paths_with_forward_slashes() -> None:
-    root = build_audit_prompt.build_audit_prompt_xml(
-        owner="jl-cmd",
-        repo="claude-dev-env",
-        pr_number=376,
-        loop=1,
-        head_ref="feat/branch",
-        base_ref="main",
-        worktree_path=Path("C:/Users/example/AppData/Local/Temp/bugteam-pr-376/worktree"),
-        run_temp_dir=Path("C:/Users/example/AppData/Local/Temp/bugteam-pr-376"),
-    )
-    context = root.find("context")
-    assert context is not None
-    worktree_text = context.findtext("worktree_path")
-    run_temp_text = context.findtext("run_temp_dir")
-    assert worktree_text == "C:/Users/example/AppData/Local/Temp/bugteam-pr-376/worktree"
-    assert run_temp_text == "C:/Users/example/AppData/Local/Temp/bugteam-pr-376"
-    scope = root.find("scope")
-    assert scope is not None
-    assert scope.text is not None
-    assert "\\" not in scope.text
-    assert "C:/Users/example/AppData/Local/Temp/bugteam-pr-376/worktree" in scope.text
-
-
-def test_bug_categories_carry_ids_a_through_q_in_order() -> None:
-    root = _build_audit_root()
-    bug_categories = root.find("bug_categories")
-    assert bug_categories is not None
-    all_emitted_ids = [each_category.get("id") for each_category in bug_categories]
-    all_expected_ids = list("ABCDEFGHIJKLMNOPQ")
-    assert all_emitted_ids == all_expected_ids
-
-
-def test_emitted_category_labels_match_constant_entries() -> None:
-    root = _build_audit_root()
-    bug_categories = root.find("bug_categories")
-    assert bug_categories is not None
-    label_by_id = {
-        each_category.get("id"): each_category.text for each_category in bug_categories
-    }
-    for each_category_id, each_category_label in ALL_AUDIT_CATEGORY_ENTRIES:
-        assert label_by_id[each_category_id] == each_category_label
-
-
-def test_category_labels_match_rubric_file_headings() -> None:
-    assert dict(ALL_AUDIT_CATEGORY_ENTRIES) == _rubric_label_by_letter()
-
-
-def test_rubric_reference_element_names_category_rubrics_directory() -> None:
-    root = _build_audit_root()
-    rubric_reference = root.find("rubric_reference")
-    assert rubric_reference is not None
-    assert rubric_reference.text is not None
-    assert "audit-rubrics/category_rubrics" in rubric_reference.text
-
-
-def test_prompt_skeleton_sub_bucket_counts_match_rubric_rows() -> None:
-    """Each prompt skeleton's numeric sub-bucket count equals its rubric's row count.
-
-    For every (letter, label) the prompts dir holds a category-<letter>- file.
-    The skeleton above the first standalone --- line states "decomposed into N
-    sub-buckets"; that N must equal the rubric's count of | <letter>N | rows,
-    and a numeric walk-instruction range (For each sub-bucket X1-Xn) must end
-    at that same row count. Skeletons with a [N] placeholder are skipped.
-    """
-    prompts_directory = _CATEGORY_RUBRICS_DIR.parent / "prompts"
-    count_pattern = re.compile(r"decomposed into (\d+) sub-buckets")
-    for each_letter, _each_label in ALL_AUDIT_CATEGORY_ENTRIES:
-        all_prompt_matches = sorted(prompts_directory.glob(f"category-{each_letter.lower()}-*.md"))
-        assert all_prompt_matches, f"Missing prompt file for category {each_letter}"
-        all_skeleton_lines: list[str] = []
-        for each_line in all_prompt_matches[0].read_text(encoding="utf-8").splitlines():
-            if each_line == "---":
-                break
-            all_skeleton_lines.append(each_line)
-        skeleton_text = "\n".join(all_skeleton_lines)
-        each_count_match = count_pattern.search(skeleton_text)
-        if each_count_match is None:
-            assert "decomposed into [N] sub-buckets" in skeleton_text, (
-                f"Category {each_letter}: skeleton neither states a numeric "
-                "sub-bucket count nor carries the [N] placeholder"
-            )
-            continue
-        all_rubric_matches = sorted(_CATEGORY_RUBRICS_DIR.glob(f"category-{each_letter.lower()}-*.md"))
-        assert all_rubric_matches, f"Missing rubric file for category {each_letter}"
-        rubric_row_pattern = re.compile(r"^\| " + each_letter + r"\d+ \|", re.MULTILINE)
-        sub_bucket_row_count = len(rubric_row_pattern.findall(all_rubric_matches[0].read_text(encoding="utf-8")))
-        assert int(each_count_match.group(1)) == sub_bucket_row_count, (
-            f"Category {each_letter}: skeleton says {each_count_match.group(1)} sub-buckets "
-            f"but rubric has {sub_bucket_row_count} rows"
-        )
-        walk_range_pattern = re.compile(
-            rf"For each sub-bucket {each_letter}1[-–]{each_letter}(\d+)"
-        )
-        each_walk_match = walk_range_pattern.search(skeleton_text)
-        if each_walk_match is not None:
-            assert int(each_walk_match.group(1)) == sub_bucket_row_count, (
-                f"Category {each_letter}: walk instruction ends at "
-                f"{each_letter}{each_walk_match.group(1)} but rubric has "
-                f"{sub_bucket_row_count} rows"
-            )
-
-
-def test_bug_categories_include_category_q() -> None:
-    root = _build_audit_root()
-    bug_categories = root.find("bug_categories")
-    assert bug_categories is not None
-    label_by_id = {
-        each_category.get("id"): each_category.text for each_category in bug_categories
-    }
-    assert label_by_id["Q"] == (
-        "Cross-surface claim consistency "
-        "(terminology, PR-description claims, message-vs-guard)"
-    )
-
-
-def test_pr_description_carries_body_text_when_supplied() -> None:
-    root = build_audit_prompt.build_audit_prompt_xml(
-        owner="jl-cmd",
-        repo="claude-dev-env",
-        pr_number=422,
-        loop=1,
-        head_ref="feat/branch",
-        base_ref="main",
-        worktree_path=Path("/tmp/bugteam-pr-422/worktree"),
-        run_temp_dir=Path("/tmp/bugteam-pr-422"),
-        pr_body_text="## Summary\nCloses the gate.",
-    )
-    pr_description = root.find("pr_description")
-    assert pr_description is not None
-    assert pr_description.text == "## Summary\nCloses the gate."
-
-
-def test_pr_description_empty_when_body_absent() -> None:
-    root = _build_audit_root()
-    pr_description = root.find("pr_description")
-    assert pr_description is not None
-    assert pr_description.text is None
-
-
-def test_read_pr_body_text_returns_file_contents(tmp_path: Path) -> None:
-    body_file = tmp_path / "pr-body.md"
-    body_file.write_text("body from disk", encoding="utf-8")
-    assert build_audit_prompt.read_pr_body_text(body_file) == "body from disk"
-
-
-def test_read_pr_body_text_returns_none_when_path_absent() -> None:
-    assert build_audit_prompt.read_pr_body_text(None) is None
-
-
-def test_read_pr_body_text_returns_none_when_file_missing(tmp_path: Path) -> None:
-    missing_file = tmp_path / "does-not-exist.md"
-    assert build_audit_prompt.read_pr_body_text(missing_file) is None
-
-
-def test_emit_audit_prompt_embeds_pr_body_text_in_pr_description() -> None:
-    xml_text = build_audit_prompt.emit_audit_prompt(
-        owner="jl-cmd",
-        repo="claude-dev-env",
-        pr_number=422,
-        loop=1,
-        head_ref="feat/branch",
-        base_ref="main",
-        worktree_path=Path("/tmp/bugteam-pr-422/worktree"),
-        run_temp_dir=Path("/tmp/bugteam-pr-422"),
-        pr_body_text="body via emit",
-    )
-    assert "body via emit" in xml_text
-
-
-def test_parse_arguments_defaults_pr_body_file_to_none() -> None:
-    arguments = build_audit_prompt.parse_arguments([
-        "--owner", "jl-cmd",
-        "--repo", "claude-dev-env",
-        "--pr-number", "422",
-        "--loop", "1",
-        "--head-ref", "feat/branch",
-        "--base-ref", "main",
-        "--worktree-path", "/tmp/wt",
-        "--run-temp-dir", "/tmp/rt",
-    ])
-    assert arguments.pr_body_file is None
-
-
-def test_parse_arguments_reads_pr_body_file_path() -> None:
-    arguments = build_audit_prompt.parse_arguments([
-        "--owner", "jl-cmd",
-        "--repo", "claude-dev-env",
-        "--pr-number", "422",
-        "--loop", "1",
-        "--head-ref", "feat/branch",
-        "--base-ref", "main",
-        "--worktree-path", "/tmp/wt",
-        "--run-temp-dir", "/tmp/rt",
-        "--pr-body-file", "/tmp/body.md",
-    ])
-    assert arguments.pr_body_file == Path("/tmp/body.md")
-
-
-def test_parse_arguments_defaults_flavor_to_agent() -> None:
-    arguments = build_audit_prompt.parse_arguments([
-        "--owner", "jl-cmd",
-        "--repo", "claude-dev-env",
-        "--pr-number", "422",
-        "--loop", "1",
-        "--head-ref", "feat/branch",
-        "--base-ref", "main",
-        "--worktree-path", "/tmp/wt",
-        "--run-temp-dir", "/tmp/rt",
-    ])
-    assert arguments.flavor == AUDIT_PROMPT_FLAVOR_AGENT
-
-
-def test_parse_arguments_reads_headless_flavor() -> None:
-    arguments = build_audit_prompt.parse_arguments([
-        "--owner", "jl-cmd",
-        "--repo", "claude-dev-env",
-        "--pr-number", "422",
-        "--loop", "1",
-        "--head-ref", "feat/branch",
-        "--base-ref", "main",
-        "--worktree-path", "/tmp/wt",
-        "--run-temp-dir", "/tmp/rt",
-        "--flavor", AUDIT_PROMPT_FLAVOR_HEADLESS,
-    ])
-    assert arguments.flavor == AUDIT_PROMPT_FLAVOR_HEADLESS
-
-
-def test_agent_flavor_comment_posting_names_mcp_tool() -> None:
-    root = build_audit_prompt.build_audit_prompt_xml(
-        owner="jl-cmd",
-        repo="claude-dev-env",
-        pr_number=422,
-        loop=1,
-        head_ref="feat/branch",
-        base_ref="main",
-        worktree_path=Path("/tmp/bugteam-pr-422/worktree"),
-        run_temp_dir=Path("/tmp/bugteam-pr-422"),
-        flavor=AUDIT_PROMPT_FLAVOR_AGENT,
-    )
-    comment_posting = root.find("comment_posting")
-    assert comment_posting is not None
-    assert comment_posting.text == AUDIT_COMMENT_POSTING_AGENT_TEXT
-    output_format = root.find("output_format")
-    assert output_format is not None
-    assert output_format.text == AUDIT_OUTPUT_FORMAT_AGENT_TEXT
-
-
-def test_headless_flavor_writes_outcome_path_and_forbids_mcp() -> None:
-    worktree_path = Path("/tmp/bugteam-pr-422/worktree")
-    pr_number = 422
-    loop = 3
-    root = build_audit_prompt.build_audit_prompt_xml(
-        owner="jl-cmd",
-        repo="claude-dev-env",
-        pr_number=pr_number,
-        loop=loop,
-        head_ref="feat/branch",
-        base_ref="main",
-        worktree_path=worktree_path,
-        run_temp_dir=Path("/tmp/bugteam-pr-422"),
-        flavor=AUDIT_PROMPT_FLAVOR_HEADLESS,
-    )
-    comment_posting = root.find("comment_posting")
-    assert comment_posting is not None
-    assert comment_posting.text == AUDIT_COMMENT_POSTING_HEADLESS_TEXT
-    assert "MCP" not in (comment_posting.text or "")
-    assert "TaskCreate" not in (comment_posting.text or "")
-    assert "gh" in (comment_posting.text or "")
-    assert "post_audit_thread.py" in (comment_posting.text or "")
-
-    expected_outcome_path = (
-        worktree_path / OUTCOME_XML_TEMPLATE.format(number=pr_number, loop=loop)
-    ).as_posix()
-    output_format = root.find("output_format")
-    assert output_format is not None
-    assert output_format.text == AUDIT_OUTPUT_FORMAT_HEADLESS_TEMPLATE.format(
-        outcome_path=expected_outcome_path,
-    )
-    assert expected_outcome_path in (output_format.text or "")
-    assert "TaskCreate" in (output_format.text or "")
-    assert "MCP" in (output_format.text or "")
-
-
-def test_main_headless_flavor_emits_outcome_path_on_stdout(
-    capsys: pytest.CaptureFixture[str],
-) -> None:
-    worktree_path = "/tmp/bugteam-pr-99/worktree"
-    exit_code = build_audit_prompt.main([
-        "--owner", "jl-cmd",
-        "--repo", "claude-dev-env",
-        "--pr-number", "99",
-        "--loop", "2",
-        "--head-ref", "feat/branch",
-        "--base-ref", "main",
-        "--worktree-path", worktree_path,
-        "--run-temp-dir", "/tmp/bugteam-pr-99",
-        "--flavor", AUDIT_PROMPT_FLAVOR_HEADLESS,
-    ])
-    assert exit_code == 0
-    captured = capsys.readouterr()
-    expected_outcome = (
-        Path(worktree_path)
-        / OUTCOME_XML_TEMPLATE.format(number=99, loop=2)
-    ).as_posix()
-    assert expected_outcome in captured.out
-    assert "post_audit_thread.py" in captured.out
-    assert "Do not post reviews" in captured.out
-    assert "add_comment_to_pending_review" not in captured.out
-
-
-def test_code_quality_agent_requires_scoped_intake_and_evidence_gaps() -> None:
-    agent_text = _CODE_QUALITY_AGENT_PATH.read_text(encoding="utf-8")
-
-    required_phrases = (
-        "read each existing `AGENTS.md` and `CLAUDE.md`",
-        "scoped `AGENTS.md` files as the canonical",
-        "`docs/CODE_RULES.md` is a compact projection",
-        "`hooks/blocking/code_rules_enforcer.py` is hand-maintained write-time coverage",
-        "full diff",
-        "resolved base or merge-base",
-        "complete changed-file list",
-        "PR description",
-        "evidence gap",
-        "Never infer omitted content",
-    )
-    for each_phrase in required_phrases:
-        assert each_phrase in agent_text
-
-    assert "## Review intake and policy sources" in agent_text
-    assert "Open questions" in agent_text
-
-
-_PACKAGE_ROOT = _PACKAGE_ROOT_FOR_RUBRICS
-_CODE_QUALITY_AGENT_PATH = _PACKAGE_ROOT / ".agents" / "agents" / "code-quality-agent.md"
-_AUDIT_CONTRACT_PATH = _PACKAGE_ROOT / "_shared" / "pr-loop" / "audit-contract.md"
-_PRECATCH_RUBRIC_PATH = _PACKAGE_ROOT / "_shared" / "pr-loop" / "precatch-rubric.md"
-_CATEGORY_Q_LABEL = (
-    "Cross-surface claim consistency "
-    "(terminology, PR-description claims, message-vs-guard)"
-)
-_CATEGORY_Q_RUBRIC_REFERENCE = (
-    "`<managed-root>/audit-rubrics/category_rubrics/"
-    "category-q-cross-surface-claims.md`"
-    " (source fallback: "
-    "`packages/claude-dev-env/audit-rubrics/category_rubrics/"
-    "category-q-cross-surface-claims.md`)"
-)
-_A_THROUGH_Q_PATTERN = re.compile(r"A[\u2013-]Q")
-_SEVENTEEN_CATEGORIES_PATTERN = re.compile(r"seventeen categor", re.IGNORECASE)
-_STALE_SIXTEEN_PATTERN = re.compile(r"sixteen categor", re.IGNORECASE)
-_STALE_A_THROUGH_P_PATTERN = re.compile(r"A[\u2013-]P")
-
-
-def test_code_quality_agent_default_scope_is_a_through_q() -> None:
-    agent_text = _CODE_QUALITY_AGENT_PATH.read_text(encoding="utf-8")
-    assert _A_THROUGH_Q_PATTERN.search(agent_text) is not None
-    assert _SEVENTEEN_CATEGORIES_PATTERN.search(agent_text) is not None
-    assert _STALE_SIXTEEN_PATTERN.search(agent_text) is None
-    assert "A through Q" in agent_text
-    assert "A through P" not in agent_text
-    assert _STALE_A_THROUGH_P_PATTERN.search(agent_text) is None
-    assert "## Bug Categories A–Q" in agent_text
-    assert _CATEGORY_Q_LABEL in agent_text
-    assert _CATEGORY_Q_RUBRIC_REFERENCE in agent_text
-    assert "| Q |" in agent_text
-
-
-def test_code_quality_agent_contract_is_caller_neutral() -> None:
-    agent_text = _CODE_QUALITY_AGENT_PATH.read_text(encoding="utf-8")
-    stale_terms = (
-        "PR #394",
-        "PR #397",
-        "May 2026",
-        "r3210166636",
-        "/bugteam",
-        "/pr-converge",
-        "/autoconverge",
-        "opus",
-        "sonnet",
-        "model:",
-    )
-    for stale_term in stale_terms:
-        assert stale_term not in agent_text
-    assert "The caller provides the diff, audit scope, ID prefix, and output format." in agent_text
-    assert "Do not assume a model, caller name, or persistence path." in agent_text
-
-
-def test_audit_contract_category_schema_includes_q() -> None:
-    contract_text = _AUDIT_CONTRACT_PATH.read_text(encoding="utf-8")
-    assert '"category": "A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q"' in (
-        contract_text
-    )
-    assert _A_THROUGH_Q_PATTERN.search(contract_text) is not None
-    assert _STALE_A_THROUGH_P_PATTERN.search(contract_text) is None
-
-
-def test_precatch_rubric_adversarial_lane_uses_a_through_q() -> None:
-    rubric_text = _PRECATCH_RUBRIC_PATH.read_text(encoding="utf-8")
-    assert _A_THROUGH_Q_PATTERN.search(rubric_text) is not None
-    assert _STALE_A_THROUGH_P_PATTERN.search(rubric_text) is None
-
-
-def test_audit_prompt_constraints_require_collection_before_severity_filter() -> None:
-    root = _build_audit_root()
-    constraints = root.find("constraints")
-    assert constraints is not None
-    all_constraint_texts = [
-        each_constraint.text or "" for each_constraint in constraints
-    ]
-    joined = "\n".join(all_constraint_texts)
-    assert "Report every real finding" in joined
-    assert "Do not drop findings by severity during collection" in joined
-    assert "separate consumer stage" in joined
-    assert "P0" in joined and "P1" in joined and "P2" in joined
-
-
-def test_audit_contract_documents_collection_before_severity_filtering() -> None:
-    contract_text = _AUDIT_CONTRACT_PATH.read_text(encoding="utf-8")
-    assert "## Collection before severity filtering" in contract_text
-    assert "separate consumer stage" in contract_text
-    assert "Do not drop a real finding because its severity is low" in contract_text

package/.agents/skills/_shared/pr-loop/scripts/test_build_converge_task_list.py

@@ -1,140 +0,0 @@
-"""Tests for build_converge_task_list — runnable gates and final CLEAN task."""
-
-from __future__ import annotations
-
-import json
-import subprocess
-import sys
-from pathlib import Path
-
-_SCRIPTS_DIR = Path(__file__).resolve().parent
-if str(_SCRIPTS_DIR) not in sys.path:
-    sys.path.insert(0, str(_SCRIPTS_DIR))
-
-import build_converge_task_list as task_list_module  # noqa: E402
-from skills_pr_loop_constants.converge_task_list_constants import (  # noqa: E402
-    EXIT_SUCCESS,
-    RESULT_KEY_DONE_WHEN,
-    RESULT_KEY_FINAL_TASK_ID,
-    RESULT_KEY_RUNNABLE_REVIEW_IDS,
-    RESULT_KEY_SKIPPED_REVIEW_IDS,
-    RESULT_KEY_TASKS,
-    SKIP_REASON_BUGBOT_DOWN,
-    SKIP_REASON_CODEX_NOT_REQUIRED,
-    SKIP_REASON_COPILOT_DOWN,
-    TASK_FIELD_ID,
-    TASK_FIELD_IS_RUNNABLE,
-    TASK_FIELD_KIND,
-    TASK_ID_ALL_CLEAN_SAME_HEAD,
-    TASK_ID_BUGBOT,
-    TASK_ID_BUGTEAM,
-    TASK_ID_CODE_REVIEW,
-    TASK_ID_CODEX,
-    TASK_ID_COPILOT,
-    TASK_KIND_FINAL,
-    TASK_KIND_REVIEW,
-)
-
-SCRIPT_PATH = _SCRIPTS_DIR / "build_converge_task_list.py"
-
-
-def test_default_flags_code_review_and_bugteam_runnable_final_last() -> None:
-    payload = task_list_module.build_converge_task_list(
-        is_bugbot_down=False,
-        is_copilot_down=False,
-        is_codex_down=False,
-        is_codex_required=False,
-    )
-    all_tasks = payload[RESULT_KEY_TASKS]
-    assert isinstance(all_tasks, list)
-    assert all_tasks[0][TASK_FIELD_ID] == TASK_ID_CODE_REVIEW
-    assert all_tasks[1][TASK_FIELD_ID] == TASK_ID_BUGTEAM
-    assert all_tasks[-1][TASK_FIELD_ID] == TASK_ID_ALL_CLEAN_SAME_HEAD
-    assert all_tasks[-1][TASK_FIELD_KIND] == TASK_KIND_FINAL
-    assert payload[RESULT_KEY_FINAL_TASK_ID] == TASK_ID_ALL_CLEAN_SAME_HEAD
-    assert TASK_ID_CODE_REVIEW in payload[RESULT_KEY_RUNNABLE_REVIEW_IDS]
-    assert TASK_ID_BUGTEAM in payload[RESULT_KEY_RUNNABLE_REVIEW_IDS]
-    assert TASK_ID_BUGBOT in payload[RESULT_KEY_RUNNABLE_REVIEW_IDS]
-    assert TASK_ID_COPILOT in payload[RESULT_KEY_RUNNABLE_REVIEW_IDS]
-    assert TASK_ID_CODEX in payload[RESULT_KEY_SKIPPED_REVIEW_IDS]
-
-
-def test_down_flags_skip_external_reviews() -> None:
-    payload = task_list_module.build_converge_task_list(
-        is_bugbot_down=True,
-        is_copilot_down=True,
-        is_codex_down=True,
-        is_codex_required=True,
-    )
-    all_tasks = payload[RESULT_KEY_TASKS]
-    assert isinstance(all_tasks, list)
-    all_tasks_by_id = {
-        each_task[TASK_FIELD_ID]: each_task for each_task in all_tasks
-    }
-    assert all_tasks_by_id[TASK_ID_BUGBOT][TASK_FIELD_IS_RUNNABLE] is False
-    assert all_tasks_by_id[TASK_ID_COPILOT][TASK_FIELD_IS_RUNNABLE] is False
-    assert all_tasks_by_id[TASK_ID_CODEX][TASK_FIELD_IS_RUNNABLE] is False
-    assert payload[RESULT_KEY_RUNNABLE_REVIEW_IDS] == [
-        TASK_ID_CODE_REVIEW,
-        TASK_ID_BUGTEAM,
-    ]
-    assert SKIP_REASON_BUGBOT_DOWN in str(all_tasks_by_id[TASK_ID_BUGBOT])
-    assert SKIP_REASON_COPILOT_DOWN in str(all_tasks_by_id[TASK_ID_COPILOT])
-
-
-def test_codex_required_is_runnable() -> None:
-    payload = task_list_module.build_converge_task_list(
-        is_bugbot_down=True,
-        is_copilot_down=True,
-        is_codex_down=False,
-        is_codex_required=True,
-    )
-    assert TASK_ID_CODEX in payload[RESULT_KEY_RUNNABLE_REVIEW_IDS]
-    assert SKIP_REASON_CODEX_NOT_REQUIRED not in str(payload)
-
-
-def test_final_task_always_last_and_runnable() -> None:
-    payload = task_list_module.build_converge_task_list(
-        is_bugbot_down=True,
-        is_copilot_down=False,
-        is_codex_down=False,
-        is_codex_required=True,
-    )
-    all_tasks = payload[RESULT_KEY_TASKS]
-    assert isinstance(all_tasks, list)
-    final_task = all_tasks[-1]
-    assert final_task[TASK_FIELD_ID] == TASK_ID_ALL_CLEAN_SAME_HEAD
-    assert final_task[TASK_FIELD_IS_RUNNABLE] is True
-    assert final_task[TASK_FIELD_KIND] == TASK_KIND_FINAL
-    assert payload[RESULT_KEY_DONE_WHEN]
-
-
-def test_cli_prints_json() -> None:
-    completed = subprocess.run(
-        [
-            sys.executable,
-            str(SCRIPT_PATH),
-            "--bugbot-down",
-            "1",
-            "--copilot-down",
-            "0",
-            "--codex-required",
-            "0",
-        ],
-        check=False,
-        capture_output=True,
-        text=True,
-    )
-    assert completed.returncode == EXIT_SUCCESS, completed.stderr
-    payload = json.loads(completed.stdout)
-    assert payload[RESULT_KEY_FINAL_TASK_ID] == TASK_ID_ALL_CLEAN_SAME_HEAD
-    assert TASK_ID_BUGBOT in payload[RESULT_KEY_SKIPPED_REVIEW_IDS]
-    assert any(
-        each_task[TASK_FIELD_KIND] == TASK_KIND_REVIEW
-        for each_task in payload[RESULT_KEY_TASKS]
-    )
-
-
-def test_main_returns_usage_on_bad_bool() -> None:
-    exit_code = task_list_module.main(["--bugbot-down", "maybe"])
-    assert exit_code == task_list_module.EXIT_USAGE_ERROR