@ikon85/agent-workflow-kit 0.42.1 → 0.44.0

package/scripts/test_orchestrate_wave_contract.py

@@ -1,381 +0,0 @@
-#!/usr/bin/env python3
-"""Reference-free behavioral contract for the portable orchestrate-wave skill.
-
-The parity table names outcomes, not the consumer that first proved them.  That
-keeps the regression test useful in every repository that installs the kit.
-
-Run: python3 scripts/test_orchestrate_wave_contract.py
-"""
-
-import re
-import unittest
-from pathlib import Path
-
-
-REPO = Path(__file__).resolve().parent.parent
-CLAUDE_SKILL = REPO / ".claude/skills/orchestrate-wave/SKILL.md"
-CODEX_SKILL = REPO / ".agents/skills/orchestrate-wave/SKILL.md"
-CLAUDE_BUILDER = (
-    REPO / ".claude/skills/orchestrate-wave/references/builder-contract.md"
-)
-CODEX_BUILDER = (
-    REPO / ".agents/skills/orchestrate-wave/references/builder-contract.md"
-)
-CLAUDE_WORKFLOW = (
-    REPO / ".claude/skills/orchestrate-wave/references/dispatch-workflow.md"
-)
-CODEX_WORKFLOW = (
-    REPO / ".agents/skills/orchestrate-wave/references/dispatch-workflow.md"
-)
-CLAUDE_SUBAGENTS = (
-    REPO / ".claude/skills/orchestrate-wave/references/dispatch-subagents.md"
-)
-CODEX_SUBAGENTS = (
-    REPO / ".agents/skills/orchestrate-wave/references/dispatch-subagents.md"
-)
-CODEX_SURFACE = REPO / ".agents/skills/orchestrate-wave"
-EXPECTED_DIRECT_SPAWN_CONTRACTS = (
-    "audit-skills/SKILL.md",
-    "code-review/SKILL.md",
-    "codebase-design/DESIGN-IT-TWICE.md",
-    "improve-codebase-architecture/INTERFACE-DESIGN.md",
-    "improve-codebase-architecture/SKILL.md",
-    "research/SKILL.md",
-)
-DIRECT_SPAWN_PATTERN = re.compile(
-    r"Run \*\*one read-only research subagent|"
-    r"Run both axes as \*\*parallel sub-agents|"
-    r"Spawn 3\+ sub-agents|"
-    r"spawn 3\+ sub-agents|"
-    r"make 3\+ parallel\s+`spawn_agent` calls|"
-    r"Then use the Agent tool|"
-    r"use `spawn_agent` with `agent_type: explorer`|"
-    r"use `spawn_agent` with only|"
-    r"Spin up a \*\*background agent",
-)
-
-
-# Outcome -> fragments whose conjunction proves that portable behavior.
-BEHAVIORAL_PARITY = {
-    "collision-safe claim": (
-        "wave-active/<anchor>",
-        "ahead",
-        "uncommitted changes",
-        "LOCAL annotated tag",
-        "never push",
-    ),
-    "compare-and-set claim protocol": (
-        "src/lib/waveClaim.mjs",
-        "claimWave",
-        "compare-and-set",
-        "acquired",
-    ),
-    "owner-safe abort cleanup": (
-        "this run planted",
-        "On ANY wave STOP/abort",
-        "Never delete a claim marker observed during a preflight collision",
-        "releaseWaveClaim",
-    ),
-    "dependency-aware retirement": (
-        "topological",
-        "internal import graph",
-        "ONE atomic slice",
-        "cycle",
-    ),
-    "safe stacked landing": (
-        "Do NOT rely on auto-retarget",
-        "FRESH PR",
-        "merge order",
-        "manual gate",
-    ),
-    "completion propagation": (
-        "Closing Conditions",
-        "completion status",
-        "native parent",
-        "Program-PRD",
-        "program sync",
-    ),
-    "session-owned teardown": (
-        "session.py begin",
-        "session.py create",
-        "refuses reused/pre-existing targets",
-        "seal the receipt",
-        "compare-deleted",
-        "foreign targets",
-        "recovery-OID evidence",
-    ),
-    "program authorization continuity": (
-        "explicit whole-Program mandate",
-        "all planned Waves",
-        "Do not re-ask at each Wave boundary",
-        "gated action",
-        "meaningful authorized safe work",
-        "must not be marked `blocked`",
-    ),
-}
-
-
-def markdown_body(text: str) -> str:
-    """Ignore frontmatter representation differences between adapters."""
-    if not text.startswith("---\n"):
-        return text
-    return text.split("\n---\n", 1)[1]
-
-
-def direct_spawn_contracts(surface: str) -> tuple[str, ...]:
-    root = REPO / surface
-    return tuple(sorted(
-        str(path.relative_to(root))
-        for path in root.rglob("*.md")
-        if DIRECT_SPAWN_PATTERN.search(path.read_text(encoding="utf-8"))
-    ))
-
-
-class OrchestrateWaveContract(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.skill = CLAUDE_SKILL.read_text(encoding="utf-8")
-        cls.builder = CLAUDE_BUILDER.read_text(encoding="utf-8")
-
-    def test_reference_free_behavioral_parity_table(self):
-        prose = " ".join(self.skill.split())
-        for outcome, fragments in BEHAVIORAL_PARITY.items():
-            with self.subTest(outcome=outcome):
-                for fragment in fragments:
-                    self.assertIn(" ".join(fragment.split()), prose)
-
-        self.assertNotRegex(self.skill, re.compile(r"/home/|#[0-9]{3,}"))
-
-    def test_builder_commands_finish_in_the_foreground(self):
-        prose = " ".join(self.builder.split())
-        for fragment in (
-            "IN THE FOREGROUND",
-            "never background a test/gate command",
-            "completed command results",
-            "exit status",
-        ):
-            self.assertIn(" ".join(fragment.split()), prose)
-
-    def test_builder_report_contract_is_identical_on_every_path(self):
-        """One report contract, whichever mechanic dispatched the builder."""
-        prose = " ".join(self.builder.split())
-        for fragment in (
-            "identical on every orchestration path",
-            "references/report-contracts.md",
-            "exactly ONE JSON object",
-            "src/lib/reportValidator.mjs",
-            "semanticVerify",
-        ):
-            self.assertIn(" ".join(fragment.split()), prose)
-
-    def test_current_portable_contracts_survive_the_port(self):
-        for fragment in (
-            "project layer",
-            "Native blocking edges are the frontier authority",
-            "AFK heartbeat",
-            "Re-run your project's full CI/verify gate CENTRALLY yourself",
-            "already authenticated",
-        ):
-            self.assertIn(fragment, self.skill)
-
-    def test_capability_selector_routes_exactly_one_orchestration_mechanic(self):
-        for fragment in (
-            "## Orchestration mechanics",
-            "literal `Workflow`",
-            "do not emulate",
-            "returns exactly one",
-            "references/dispatch-workflow.md",
-            "references/dispatch-subagents.md",
-            "Path C",
-            "Phase 1 uses the selected orchestration mechanics",
-            "Phase 2 uses the selected orchestration mechanics",
-        ):
-            self.assertIn(fragment, self.skill)
-
-        # Skeleton-size ratchet: detail belongs in references/, not here. 345 ->
-        # 360 carried the sticky Program-authorization rule; 360 -> 368 adds the
-        # per-slice pickup claim (#231). Both are phase-level responsibilities
-        # the reference files cannot carry — they gate dispatch itself.
-        self.assertLessEqual(len(self.skill.splitlines()), 368)
-
-    def test_registry_ownership_distinguishes_safe_from_eager_registries(self):
-        prose = " ".join(self.skill.split())
-        for fragment in (
-            "declaration-only registries",
-            "may be predeclared by one hub",
-            "eager/validated registries",
-            "each appending only its own existing artifact after creation",
-            "dependency edges",
-        ):
-            self.assertIn(fragment, prose)
-
-        phase_one = prose.split("## Phase 1", 1)[1].split("## Phase 2", 1)[0]
-        done = phase_one.split("**Done when:**", 1)[1]
-        for fragment in (
-            "either one declaration-only owner",
-            "verbatim consume-only dependents",
-            "or an explicit serialized owner sequence",
-            "each owner appends only its own existing artifact",
-        ):
-            self.assertIn(fragment, done)
-
-    def test_phase_one_orders_producers_before_surface_measurers(self):
-        prose = " ".join(self.skill.split())
-        phase_one = prose.split("## Phase 1", 1)[1].split("## Phase 2", 1)[0]
-        for fragment in (
-            "Producer/measurer coupling",
-            "semantic dependency",
-            "measurer strictly after the producer",
-            "baseline reconciliation",
-            "drop producer-resolved entries",
-        ):
-            self.assertIn(fragment, phase_one)
-
-        done = phase_one.split("**Done when:**", 1)[1]
-        for fragment in (
-            "producer/measurer pair",
-            "explicit edge/order",
-            "reconciliation owner",
-        ):
-            self.assertIn(fragment, done)
-
-    def test_phase_four_centrally_runs_builder_browser_specs_before_ci(self):
-        prose = " ".join(self.skill.split())
-        phase_four = prose.split("## Phase 4", 1)[1].split("## Phase 5", 1)[0]
-        browser_contract = "builders authored or changed browser specs"
-        central_gate = "Re-run your project's full CI/verify gate CENTRALLY yourself"
-        for fragment in (
-            browser_contract,
-            "unverified artifact",
-            "ONE central green run",
-            "if `§Verify Recipe` names a local e2e runner",
-            "Never invent a command under generic fallback",
-        ):
-            self.assertIn(fragment, phase_four)
-        self.assertLess(phase_four.index(browser_contract), phase_four.index(central_gate))
-
-    def test_phase_two_keeps_per_slice_routing_decisions(self):
-        prose = " ".join(self.skill.split())
-        self.assertIn("(a) inline vs delegate", prose)
-        self.assertIn("(b) tier + effort", prose)
-        self.assertIn("Standing rules", prose)
-
-    def test_every_surface_dispatch_crosses_resolver_and_spawn_guard(self):
-        prose = " ".join(self.skill.split())
-        for fragment in (
-            "provider-neutral Routing intent",
-            "shared resolver",
-            "spawn guard",
-            "Claude or Codex adapter",
-            "routingAdapters/codex.mjs",
-            "Dispatch receipt",
-            "requested and applied route",
-            "environment precedence",
-            "detected transport is not authorization",
-            "AFK",
-        ):
-            self.assertIn(fragment, prose)
-
-    def test_every_direct_spawn_contract_routes_through_the_shared_guard(self):
-        required = (
-            "provider-neutral Routing intent",
-            "routeDispatcher.mjs",
-            "shared spawn guard",
-            "Dispatch receipt",
-        )
-        claude_actual = direct_spawn_contracts(".claude/skills")
-        codex_actual = direct_spawn_contracts(".agents/skills")
-        self.assertEqual(claude_actual, EXPECTED_DIRECT_SPAWN_CONTRACTS)
-        self.assertEqual(codex_actual, EXPECTED_DIRECT_SPAWN_CONTRACTS)
-        for relative in claude_actual:
-            claude = " ".join(
-                (REPO / ".claude/skills" / relative).read_text(encoding="utf-8").split()
-            )
-            codex = " ".join(
-                (REPO / ".agents/skills" / relative).read_text(encoding="utf-8").split()
-            )
-            with self.subTest(contract=relative):
-                for fragment in required:
-                    self.assertIn(fragment, claude)
-                    self.assertIn(fragment, codex)
-                for unsupported in ("Agent tool", "subagent_type", "agent_type"):
-                    self.assertNotIn(unsupported, codex)
-
-    def test_path_a_reference_locks_the_two_run_dispatch_contract(self):
-        workflow = CLAUDE_WORKFLOW.read_text(encoding="utf-8")
-        for fragment in (
-            "meta.phases",
-            "one `agent()` call per slice",
-            "model`, `effort`, and `phase`",
-            "inline schema literal",
-            "Recon run",
-            "reconcileReconReports",
-            "Build run",
-            "resumeFromRunId",
-            "exactly once",
-            "journal.jsonl",
-            "timestamps through `args`",
-            "Date.now()",
-            "Math.random()",
-            "Every orchestration path",
-        ):
-            self.assertIn(fragment, workflow)
-
-        self.assertEqual(workflow, CODEX_WORKFLOW.read_text(encoding="utf-8"))
-
-    def test_path_b_reference_locks_the_native_subagent_contract(self):
-        subagents = CLAUDE_SUBAGENTS.read_text(encoding="utf-8")
-        prose = " ".join(subagents.split())
-        for fragment in (
-            "one read-only explorer per slice",
-            "one builder per slice",
-            "explicit wait",
-            "exactly ONE JSON object",
-            "reportValidator.mjs",
-            "reconcileReconReports",
-            "main thread",
-            "is not a PASS",
-            "waveClaim",
-            "spawn_agents_on_csv",
-            "output_schema",
-            "dormant",
-            "task_name`, `message`, and `fork_turns",
-            "no model or effort selector",
-            "blocks differentiated AFK",
-            "routingAdapters/codex.mjs",
-        ):
-            self.assertIn(" ".join(fragment.split()), prose)
-
-        self.assertEqual(subagents, CODEX_SUBAGENTS.read_text(encoding="utf-8"))
-
-    def test_codex_surface_carries_no_path_a_primitive_outside_its_pointer_target(self):
-        """B-surface prose must not require Workflow-only primitives."""
-        offenders = {}
-        for path in sorted(CODEX_SURFACE.rglob("*.md")):
-            if path.name == "dispatch-workflow.md":
-                continue
-            body = path.read_text(encoding="utf-8")
-            hits = [term for term in ("journal.jsonl", "resumeFromRunId") if term in body]
-            # The literal tool name is admissible ONLY inside the capability gate.
-            if "`Workflow`" in body:
-                gate = body.split("## Orchestration mechanics", 1)
-                remainder = gate[0] + (gate[1].split("\n## ", 1)[1] if len(gate) > 1 and "\n## " in gate[1] else "")
-                if "`Workflow`" in remainder:
-                    hits.append("`Workflow`")
-            if hits:
-                offenders[str(path.relative_to(REPO))] = hits
-        self.assertEqual(offenders, {})
-
-    def test_claude_and_codex_surfaces_match(self):
-        self.assertEqual(
-            markdown_body(self.skill),
-            markdown_body(CODEX_SKILL.read_text(encoding="utf-8")),
-        )
-        self.assertEqual(
-            self.builder,
-            CODEX_BUILDER.read_text(encoding="utf-8"),
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

package/scripts/test_pr_body_check.py

@@ -1,264 +0,0 @@
-#!/usr/bin/env python3
-"""Behavior tests for the PR-body convention guard."""
-import importlib.util
-import os
-import subprocess
-import sys
-import tempfile
-import unittest
-from unittest import mock
-from pathlib import Path
-from types import SimpleNamespace
-
-PROFILE_PATH = Path(__file__).parent.parent / "docs/agents/board-sync.md"
-TEST_ENV = os.environ.copy()
-TEST_ENV["BOARD_SYNC_PROFILE"] = str(PROFILE_PATH)
-_PREVIOUS_PROFILE = os.environ.get("BOARD_SYNC_PROFILE")
-os.environ["BOARD_SYNC_PROFILE"] = str(PROFILE_PATH)
-
-_SPEC = importlib.util.spec_from_file_location(
-    "pr_body_check", Path(__file__).parent / "pr-body-check.py")
-pbc = importlib.util.module_from_spec(_SPEC)
-_SPEC.loader.exec_module(pbc)
-if _PREVIOUS_PROFILE is None:
-    os.environ.pop("BOARD_SYNC_PROFILE", None)
-else:
-    os.environ["BOARD_SYNC_PROFILE"] = _PREVIOUS_PROFILE
-import pr_body_e2e as e2e  # noqa: E402
-
-SCRIPT_PATH = Path(__file__).parent / "pr-body-check.py"
-
-RETRO = "**Retro:** skipped — focused guard change"
-VALID_LEAF_BODY = f"closes #149\n{RETRO}"
-
-
-class E2eNaBodyEvidence(unittest.TestCase):
-    def test_no_trailer_and_no_evidence_is_green(self):
-        self.assertEqual(pbc.check_pr_body(VALID_LEAF_BODY, 149, None), [])
-
-    def test_no_trailer_with_evidence_is_green(self):
-        body = VALID_LEAF_BODY + "\nE2E: n/a — harmless extra context"
-        self.assertEqual(pbc.check_pr_body(body, 149, None), [])
-
-    def test_valid_trailer_without_body_evidence_is_actionable(self):
-        violations = pbc.check_pr_body(
-            VALID_LEAF_BODY,
-            149,
-            None,
-            has_e2e_na_trailer=True,
-        )
-        self.assertTrue(any("E2E: n/a" in violation for violation in violations))
-
-    def test_valid_trailer_with_non_empty_evidence_is_green(self):
-        body = VALID_LEAF_BODY + "\nE2E: n/a — backend-only change"
-        self.assertEqual(
-            pbc.check_pr_body(body, 149, None, has_e2e_na_trailer=True), []
-        )
-
-    def test_valid_trailer_with_empty_evidence_is_actionable(self):
-        body = VALID_LEAF_BODY + "\nE2E: n/a —   "
-        violations = pbc.check_pr_body(
-            body, 149, None, has_e2e_na_trailer=True
-        )
-        self.assertTrue(any("E2E: n/a" in violation for violation in violations))
-
-
-class ExistingBodyRules(unittest.TestCase):
-    def test_anchor_slice_still_accepts_part_of_and_leaf_close(self):
-        body = f"Part of #130\ncloses #149\n{RETRO}"
-        self.assertEqual(pbc.check_pr_body(body, 149, 130), [])
-
-    def test_anchor_slice_still_rejects_close_on_anchor(self):
-        body = f"Part of #130\ncloses #130\n{RETRO}"
-        self.assertTrue(any("130" in item for item in pbc.check_pr_body(body, 149, 130)))
-
-    def test_leaf_still_requires_active_close(self):
-        body = f"`closes #149`\n{RETRO}"
-        self.assertTrue(any("closes #149" in item for item in pbc.check_pr_body(body, 149, None)))
-
-    def test_retro_line_still_required(self):
-        self.assertTrue(any("Retro" in item for item in pbc.check_pr_body("closes #149", 149, None)))
-
-    def test_active_close_targets_extracts_all_forms(self):
-        body = ("closes #12\nFixes: #13\n"
-                "resolves https://github.com/iKon85/agent-workflow-kit/issues/14\n"
-                "`closes #99` and Part of #320 and closes #12")
-        self.assertEqual(pbc.active_close_targets(body), ["12", "13", "14"])
-
-    def test_active_close_targets_empty_for_part_of_only(self):
-        self.assertEqual(pbc.active_close_targets("Part of #320\n**Retro:** skipped — x"), [])
-
-    def test_program_prd_label_counts_as_anchor(self):
-        with mock.patch.object(pbc, "_run",
-                               return_value=(0, "type:program\npriority:medium")):
-            self.assertTrue(pbc.fetch_is_anchor(320))
-
-    def test_cluster_label_still_counts_as_anchor(self):
-        with mock.patch.object(pbc, "_run",
-                               return_value=(0, "type:cluster")):
-            self.assertTrue(pbc.fetch_is_anchor(41))
-
-    def test_wave_pr_still_requires_part_of_without_closing_anchor(self):
-        body = f"Part of #130\ncloses #149\n{RETRO}"
-        self.assertEqual(pbc.check_pr_body(body, 130, None, is_anchor=True), [])
-
-
-class ImmutableRangeTrailer(unittest.TestCase):
-    def test_two_commit_range_finds_one_valid_trailer(self):
-        with tempfile.TemporaryDirectory() as temp_dir:
-            repo = Path(temp_dir)
-            subprocess.run(["git", "init", "-q"], cwd=repo, check=True)
-            subprocess.run(
-                ["git", "config", "user.email", "tests@example.invalid"],
-                cwd=repo,
-                check=True,
-            )
-            subprocess.run(
-                ["git", "config", "user.name", "Test User"], cwd=repo, check=True
-            )
-            (repo / "change.txt").write_text("base\n", encoding="utf-8")
-            subprocess.run(["git", "add", "change.txt"], cwd=repo, check=True)
-            subprocess.run(["git", "commit", "-qm", "base"], cwd=repo, check=True)
-            base = subprocess.check_output(
-                ["git", "rev-parse", "HEAD"], cwd=repo, text=True
-            ).strip()
-            (repo / "change.txt").write_text("head\n", encoding="utf-8")
-            subprocess.run(["git", "add", "change.txt"], cwd=repo, check=True)
-            subprocess.run(
-                [
-                    "git",
-                    "commit",
-                    "-qm",
-                    "head\n\nE2E-NA: backend-only change",
-                ],
-                cwd=repo,
-                check=True,
-            )
-            head = subprocess.check_output(
-                ["git", "rev-parse", "HEAD"], cwd=repo, text=True
-            ).strip()
-
-            self.assertTrue(e2e.fetch_has_e2e_na_trailer(base, head, cwd=repo))
-
-    def test_unreadable_range_fails_open(self):
-        self.assertFalse(e2e.fetch_has_e2e_na_trailer("missing-base", "missing-head"))
-
-    def test_empty_or_multiple_trailers_are_not_a_single_valid_trailer(self):
-        with mock.patch.object(
-            e2e, "_collect_e2e_na_trailers", side_effect=[[""], ["one", "two"]]
-        ):
-            self.assertFalse(e2e.fetch_has_e2e_na_trailer("base", "head"))
-            self.assertFalse(e2e.fetch_has_e2e_na_trailer("base", "head"))
-
-    def test_pr_range_reads_immutable_base_and_head_oids(self):
-        payload = '{"baseRefOid":"base-sha","headRefOid":"head-sha"}'
-        with mock.patch.object(e2e, "_run", return_value=(0, payload)):
-            self.assertEqual(e2e.fetch_pr_range("feat/149-guard"), ("base-sha", "head-sha"))
-
-    def test_checker_defaults_to_pr_range_when_no_overrides_are_given(self):
-        args = SimpleNamespace(base_sha=None, head_sha=None)
-        with (
-            mock.patch.object(pbc, "fetch_pr_range", return_value=("base", "head")) as get_range,
-            mock.patch.object(pbc, "fetch_has_e2e_na_trailer", return_value=True) as has_trailer,
-        ):
-            self.assertTrue(pbc.resolve_has_e2e_na(args, "feat/149-guard"))
-        get_range.assert_called_once_with("feat/149-guard")
-        has_trailer.assert_called_once_with("base", "head")
-
-    def test_unavailable_or_invalid_pr_range_fails_open(self):
-        with mock.patch.object(e2e, "_run", side_effect=[(1, ""), (0, "not-json")]):
-            self.assertEqual(e2e.fetch_pr_range("missing"), (None, None))
-            self.assertEqual(e2e.fetch_pr_range("invalid"), (None, None))
-
-    def test_explicit_range_requires_then_accepts_body_evidence(self):
-        with tempfile.TemporaryDirectory() as temp_dir:
-            repo = Path(temp_dir)
-            subprocess.run(["git", "init", "-q"], cwd=repo, check=True)
-            subprocess.run(
-                ["git", "config", "user.email", "tests@example.invalid"],
-                cwd=repo,
-                check=True,
-            )
-            subprocess.run(
-                ["git", "config", "user.name", "Test User"], cwd=repo, check=True
-            )
-            (repo / "change.txt").write_text("base\n", encoding="utf-8")
-            subprocess.run(["git", "add", "change.txt"], cwd=repo, check=True)
-            subprocess.run(["git", "commit", "-qm", "base"], cwd=repo, check=True)
-            base = subprocess.check_output(
-                ["git", "rev-parse", "HEAD"], cwd=repo, text=True
-            ).strip()
-            (repo / "change.txt").write_text("head\n", encoding="utf-8")
-            subprocess.run(["git", "add", "change.txt"], cwd=repo, check=True)
-            subprocess.run(
-                ["git", "commit", "-qm", "head\n\nE2E-NA: backend-only change"],
-                cwd=repo,
-                check=True,
-            )
-            head = subprocess.check_output(
-                ["git", "rev-parse", "HEAD"], cwd=repo, text=True
-            ).strip()
-            body_path = repo / "body.md"
-            base_body = f"Part of #130\ncloses #149\n{RETRO}"
-            command = [
-                sys.executable,
-                str(SCRIPT_PATH),
-                "--issue",
-                "149",
-                "--parent",
-                "130",
-                "--body-file",
-                str(body_path),
-                "--base-sha",
-                base,
-                "--head-sha",
-                head,
-            ]
-
-            body_path.write_text(base_body, encoding="utf-8")
-            missing = subprocess.run(
-                command, cwd=repo, capture_output=True, text=True, env=TEST_ENV
-            )
-            self.assertEqual(missing.returncode, 1, missing.stdout + missing.stderr)
-            self.assertIn("E2E: n/a", missing.stdout)
-
-            body_path.write_text(
-                base_body + "\nE2E: n/a — backend-only change\n", encoding="utf-8"
-            )
-            matching = subprocess.run(
-                command, cwd=repo, capture_output=True, text=True, env=TEST_ENV
-            )
-            self.assertEqual(matching.returncode, 0, matching.stdout + matching.stderr)
-
-
-class ExistingExitCodes(unittest.TestCase):
-    def test_no_issue_is_still_exit_two(self):
-        result = subprocess.run(
-            [sys.executable, str(SCRIPT_PATH), "--branch", "main"],
-            capture_output=True,
-            text=True,
-            env=TEST_ENV,
-        )
-        self.assertEqual(result.returncode, 2, result.stdout + result.stderr)
-
-    def test_unreadable_body_file_is_still_exit_two(self):
-        result = subprocess.run(
-            [
-                sys.executable,
-                str(SCRIPT_PATH),
-                "--issue",
-                "149",
-                "--parent",
-                "130",
-                "--body-file",
-                "/definitely/missing/body.md",
-            ],
-            capture_output=True,
-            text=True,
-            env=TEST_ENV,
-        )
-        self.assertEqual(result.returncode, 2, result.stdout + result.stderr)
-
-
-if __name__ == "__main__":
-    unittest.main()