@ikon85/agent-workflow-kit 0.42.1 → 0.44.0

package/scripts/test_render_anchor.py

@@ -1,267 +0,0 @@
-#!/usr/bin/env python3
-"""Behavior tests for the pure Tier-2 anchor renderer."""
-
-from __future__ import annotations
-
-import importlib.util
-import os
-import subprocess
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-
-
-SCRIPTS = Path(__file__).resolve().parent
-REPO = SCRIPTS.parent
-SKILLS = (
-    REPO / ".claude/skills/to-issues/SKILL.md",
-    REPO / ".agents/skills/to-issues/SKILL.md",
-)
-sys.path.insert(0, str(SCRIPTS))
-SPEC = importlib.util.spec_from_file_location(
-    "render_anchor", SCRIPTS / "render-anchor.py"
-)
-render_anchor = importlib.util.module_from_spec(SPEC)
-assert SPEC.loader is not None
-SPEC.loader.exec_module(render_anchor)
-
-
-class RenderDocumentsGoldenTest(unittest.TestCase):
-    def test_filled_template_and_prd_render_both_documents(self):
-        template = "**Welle 12 — Safer publish.**\n\n## Slices\n| K1 |\n"
-        prd = (
-            "<!-- prd-source-id: safer-publish -->\n"
-            "<!-- prd-content-fp: abc123 -->\n"
-            "**plan_revision:** r4\n"
-            "<!-- prd: awaiting-decomposition -->\n\n"
-            "# Safer publish\n\nFull rationale.\n"
-        )
-
-        rendered = render_anchor.render_documents(template, prd)
-
-        self.assertEqual(rendered.anchor_body, template)
-        self.assertEqual(
-            rendered.archive_body,
-            "📄 Full PRD (archive, r4) — the body carries navigation/decisions only\n\n"
-            "# Safer publish\n\nFull rationale.\n",
-        )
-
-    def test_only_canonical_markers_in_the_head_block_are_stripped(self):
-        template = "Lean anchor\n"
-        prd = (
-            "<!-- wave-stub-source: safer-publish -->\n"
-            "<!-- prd-source-id: safer-publish -->\n"
-            "**plan_revision:** r5\n"
-            "<!-- prd: awaiting-decomposition -->\n\n"
-            "# PRD\n\n"
-            "```md\n**plan_revision:** fake\n"
-            "<!-- prd-source-id: quoted-example -->\n```\n\n"
-            "> **plan_revision:** quoted-fake\n"
-        )
-
-        rendered = render_anchor.render_documents(template, prd)
-
-        self.assertEqual(
-            rendered.archive_body,
-            "📄 Full PRD (archive, r5) — the body carries navigation/decisions only\n\n"
-            "<!-- wave-stub-source: safer-publish -->\n\n# PRD\n\n"
-            "```md\n**plan_revision:** fake\n"
-            "<!-- prd-source-id: quoted-example -->\n```\n\n"
-            "> **plan_revision:** quoted-fake\n",
-        )
-
-    def test_duplicate_plan_revisions_fail_closed(self):
-        for revisions in (("r5", "r5"), ("r5", "r6")):
-            with self.subTest(revisions=revisions):
-                prd = (
-                    f"**plan_revision:** {revisions[0]}\n"
-                    f"**plan_revision:** {revisions[1]}\n\n# PRD\n"
-                )
-                with self.assertRaisesRegex(
-                    ValueError, "exactly one canonical plan_revision"
-                ):
-                    render_anchor.render_documents("Lean anchor\n", prd)
-
-    def test_plan_revision_requires_numeric_canonical_value(self):
-        for lookalike in ("rfoo", "r5!"):
-            with self.subTest(lookalike=lookalike, valid_revision=True):
-                malformed = f"**plan_revision:** {lookalike}"
-                prd = f"{malformed}\n**plan_revision:** r5\n\n# PRD\n"
-                rendered = render_anchor.render_documents("Lean anchor\n", prd)
-                self.assertIn(malformed, rendered.archive_body)
-
-            with self.subTest(lookalike=lookalike, valid_revision=False):
-                with self.assertRaisesRegex(
-                    ValueError, "exactly one canonical plan_revision"
-                ):
-                    render_anchor.render_documents(
-                        "Lean anchor\n", f"**plan_revision:** {lookalike}\n# PRD\n"
-                    )
-
-    def test_malformed_marker_lookalikes_are_preserved(self):
-        lookalikes = (
-            "<!-- prd-source-id: alpha --> trailing -->",
-            "<!-- prd-content-fp: abc > trailing -->",
-            "<!-- prd: program > trailing -->",
-        )
-        for lookalike in lookalikes:
-            with self.subTest(lookalike=lookalike):
-                prd = (
-                    f"{lookalike}\n"
-                    "<!-- prd-source-id: canonical -->\n"
-                    "<!-- prd-content-fp: abc123 -->\n"
-                    "**plan_revision:** r5\n"
-                    "<!-- prd: awaiting-decomposition -->\n\n# PRD\n"
-                )
-
-                rendered = render_anchor.render_documents("Lean anchor\n", prd)
-
-                self.assertIn(lookalike, rendered.archive_body)
-                self.assertNotIn(
-                    "<!-- prd-source-id: canonical -->", rendered.archive_body
-                )
-                self.assertNotIn(
-                    "<!-- prd-content-fp: abc123 -->", rendered.archive_body
-                )
-                self.assertNotIn(
-                    "<!-- prd: awaiting-decomposition -->", rendered.archive_body
-                )
-
-    def test_cli_emits_each_document_without_mutating_inputs(self):
-        with tempfile.TemporaryDirectory() as temporary:
-            root = Path(temporary)
-            template = root / "anchor.md"
-            prd = root / "prd.md"
-            template.write_text("Lean anchor\n", encoding="utf-8")
-            prd.write_text(
-                "**plan_revision:** r2\n\n# Full PRD\n", encoding="utf-8"
-            )
-            original = (template.read_bytes(), prd.read_bytes())
-
-            first = self._run_cli(template, prd, "archive")
-            second = self._run_cli(template, prd, "archive")
-            anchor = self._run_cli(template, prd, "anchor")
-
-            self.assertEqual(first.stdout, second.stdout)
-            self.assertEqual(anchor.stdout, b"Lean anchor\n")
-            self.assertEqual((template.read_bytes(), prd.read_bytes()), original)
-
-    def test_cli_archive_is_utf8_when_python_io_encoding_is_ascii(self):
-        with tempfile.TemporaryDirectory() as temporary:
-            root = Path(temporary)
-            template = root / "anchor.md"
-            prd = root / "prd.md"
-            template.write_text("Lean anchor\n", encoding="utf-8")
-            prd.write_text("**plan_revision:** r2\n\n# PRD\n", encoding="utf-8")
-
-            result = self._run_cli(
-                template,
-                prd,
-                "archive",
-                env={**os.environ, "PYTHONIOENCODING": "ascii"},
-            )
-
-            self.assertTrue(result.stdout.startswith("📄".encode("utf-8")))
-
-    def _run_cli(
-        self, template: Path, prd: Path, document: str, env: dict | None = None
-    ):
-        return subprocess.run(
-            [
-                sys.executable,
-                str(SCRIPTS / "render-anchor.py"),
-                "--template",
-                str(template),
-                "--prd",
-                str(prd),
-                "--document",
-                document,
-            ],
-            check=True,
-            capture_output=True,
-            env=env,
-        )
-
-
-class PromotionStateTableTest(unittest.TestCase):
-    EXPECTED_ROWS = {
-        "initial": (
-            "`S=yes`, `B=no`, `C=0`, `P=absent`",
-            "render + write body",
-        ),
-        "body-written": (
-            "`S=n/a`, `B=yes`, `C=0`, `P=absent`",
-            "reconcile + write archive comment",
-        ),
-        "comment-written": (
-            "`S=n/a`, `B=yes`, `C=exact-1`, `P=absent`",
-            "promote board state",
-        ),
-        "promoted": (
-            "`S=n/a`, `B=yes`, `C=exact-1`, `P=complete`",
-            "no-op; continue publish audit",
-        ),
-    }
-    EXPECTED_BOARD_OBSERVATIONS = {
-        "ordinary-prestate": "absent",
-        "stufe-1p-prestate": "absent",
-        "promoted": "complete",
-        "cluster-only": "partial",
-        "wrong-wave": "partial",
-    }
-
-    def test_all_four_observable_states_have_one_resume_action(self):
-        for path in SKILLS:
-            text = path.read_text(encoding="utf-8")
-            start = text.index("<!-- promotion-state-table:start -->")
-            end = text.index("<!-- promotion-state-table:end -->", start)
-            rows = {}
-            for line in text[start:end].splitlines():
-                if line.startswith("| `"):
-                    cells = [cell.strip() for cell in line.strip("|").split("|")]
-                    rows[cells[0].strip("`")] = (cells[1], cells[2])
-            self.assertEqual(rows, self.EXPECTED_ROWS, str(path))
-
-    def test_corrupt_comments_and_partial_board_writes_are_drift(self):
-        for path in SKILLS:
-            text = path.read_text(encoding="utf-8")
-            self.assertIn("`C=wrong-1`", text, str(path))
-            self.assertIn("`C=duplicates(<ids>)`", text, str(path))
-            self.assertIn("`P=partial`", text, str(path))
-            self.assertIn("drift and enters repair", text, str(path))
-
-    def test_stufe_1p_prestamp_is_not_partial_promotion(self):
-        for path in SKILLS:
-            text = path.read_text(encoding="utf-8")
-            start = text.index("<!-- promotion-board-observation-table:start -->")
-            end = text.index("<!-- promotion-board-observation-table:end -->", start)
-            rows = {}
-            for line in text[start:end].splitlines():
-                if line.startswith("| `"):
-                    cells = [cell.strip() for cell in line.strip("|").split("|")]
-                    rows[cells[0].strip("`")] = cells[2].strip("`")
-            self.assertEqual(rows, self.EXPECTED_BOARD_OBSERVATIONS, str(path))
-
-    def test_post_initial_body_drift_requires_an_operator_decision(self):
-        for path in SKILLS:
-            text = path.read_text(encoding="utf-8")
-            self.assertIn("outside the valid `initial` tuple", text, str(path))
-            self.assertIn("report the body diff", text, str(path))
-            self.assertRegex(text, r"explicit\s+operator decision", str(path))
-            self.assertNotIn(
-                "wrong/missing `B` → rerender and rewrite the body", text, str(path)
-            )
-
-    def test_stale_source_snapshot_stops_before_body_write(self):
-        for path in SKILLS:
-            text = path.read_text(encoding="utf-8")
-            self.assertRegex(text, r"Pre:\s+`S=yes`, `B=no`", str(path))
-            self.assertRegex(text, r"Post:\s+`S=n/a`, `B=yes`", str(path))
-            self.assertIn("`S=no`", text, str(path))
-            self.assertIn("re-fetch the remote body", text, str(path))
-            self.assertRegex(text, r"never\s+write the\s+stale render", str(path))
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)

package/scripts/test_retro_wrapup_contract.py

@@ -1,153 +0,0 @@
-"""Contract tests for retro enforcement and safe wrapup workflow chaining."""
-
-from pathlib import Path
-import re
-import unittest
-
-
-ROOT = Path(__file__).resolve().parents[1]
-SURFACES = (".claude", ".agents")
-
-
-def skill(surface: str, name: str) -> str:
-    return (ROOT / surface / "skills" / name / "SKILL.md").read_text(
-        encoding="utf-8"
-    )
-
-
-def contract_text(surface: str, name: str) -> str:
-    """Return prose with Markdown emphasis removed for wording assertions."""
-    return re.sub(r"\s+", " ", skill(surface, name).replace("**", ""))
-
-
-class RetroEnforcementContract(unittest.TestCase):
-    def test_mechanical_check_precedes_target_and_weight_ladder(self):
-        for surface in SURFACES:
-            with self.subTest(surface=surface):
-                text = contract_text(surface, "retro")
-                mechanical = text.index("### 3a. Mechanical enforcement check")
-                ladder = text.index("### 3b. Determine target + weight")
-                self.assertLess(mechanical, ladder)
-
-    def test_machine_checkable_findings_cannot_stop_at_prose(self):
-        required = (
-            "Could a machine decide this",
-            "implement the enforcement",
-            "tracked enforcement issue",
-            "explicit trade-off",
-        )
-        for surface in SURFACES:
-            with self.subTest(surface=surface):
-                text = contract_text(surface, "retro")
-                for phrase in required:
-                    self.assertIn(phrase, text)
-
-    def test_capability_route_and_exact_sanitized_approval_survive(self):
-        required = (
-            "generic or project-specific",
-            "recommend `own`",
-            "contribute status <path> --surface=retro",
-            "Missing, disabled, invalid, or unverifiable configuration",
-            "never infer maintainer status",
-            "sanitized exact preview",
-            "separate explicit approval",
-            "docs/agents/skills/<skill>.md",
-        )
-        for surface in SURFACES:
-            with self.subTest(surface=surface):
-                text = contract_text(surface, "retro")
-                for phrase in required:
-                    self.assertIn(phrase, text)
-
-
-class WrapupChainingContract(unittest.TestCase):
-    def test_prod_readiness_degrades_reporting_without_blocking_landing(self):
-        required = (
-            "readiness.mjs check --skill wrapup --json",
-            "Prod readiness is pending or missing; deploy reporting omitted.",
-            "landing continues normally",
-            "never authorizes the agent to invent or configure a deploy target",
-            "<!-- readiness:block deployReport -->",
-            "<!-- readiness:end -->",
-        )
-        for surface in SURFACES:
-            with self.subTest(surface=surface):
-                text = skill(surface, "wrapup")
-                for phrase in required:
-                    self.assertIn(phrase, text)
-                self.assertEqual(text.count("<!-- readiness:block deployReport -->"), 1)
-                self.assertEqual(text.count("<!-- readiness:end -->"), 1)
-
-    def test_retro_is_model_invocable_on_both_surfaces(self):
-        for surface in SURFACES:
-            with self.subTest(surface=surface):
-                frontmatter = skill(surface, "retro").split("---", 2)[1]
-                self.assertIn("disable-model-invocation: false", frontmatter)
-
-    def test_affirmative_retro_gate_chains_without_landing(self):
-        required = (
-            "invoke the `retro` skill immediately in this run",
-            "land nothing in this run",
-            "fresh explicit `$wrapup` or `/wrapup` invocation",
-        )
-        for surface in SURFACES:
-            with self.subTest(surface=surface):
-                text = contract_text(surface, "wrapup")
-                for phrase in required:
-                    self.assertIn(phrase, text)
-
-    def test_wrapup_does_not_forbid_its_affirmative_retro_chain(self):
-        for surface in SURFACES:
-            with self.subTest(surface=surface):
-                text = contract_text(surface, "wrapup")
-                self.assertNotIn("never run by this skill", text.lower())
-
-    def test_only_model_invocable_non_deploying_workflows_chain(self):
-        required = (
-            "model-invocable",
-            "non-deploying",
-            "return control to the user",
-            "state the reason",
-        )
-        for surface in SURFACES:
-            with self.subTest(surface=surface):
-                text = contract_text(surface, "wrapup")
-                for phrase in required:
-                    self.assertIn(phrase, text)
-
-    def test_wrapup_remains_manual_and_program_propagation_remains_present(self):
-        for surface in SURFACES:
-            with self.subTest(surface=surface):
-                text = skill(surface, "wrapup")
-                self.assertIn("disable-model-invocation: true", text)
-                self.assertIn(
-                    "user's direct `$wrapup` or `/wrapup` input IS the explicit",
-                    text,
-                )
-                self.assertIn("program-sync", text)
-                self.assertIn("Phasen-Gates", text)
-
-    def test_wrapup_accepts_only_direct_user_dollar_or_slash_invocations(self):
-        required = (
-            "direct `$wrapup` or `/wrapup`",
-            "Natural-language requests",
-            "indirect skill chaining",
-            "autonomous invocation",
-            "fresh explicit `$wrapup` or `/wrapup` invocation",
-        )
-        for surface in SURFACES:
-            with self.subTest(surface=surface):
-                text = contract_text(surface, "wrapup")
-                for phrase in required:
-                    self.assertIn(phrase, text)
-
-    def test_new_contract_is_reference_free(self):
-        for surface in SURFACES:
-            with self.subTest(surface=surface):
-                combined = skill(surface, "retro") + skill(surface, "wrapup")
-                self.assertNotIn("testreporter", combined.lower())
-                self.assertIsNone(re.search(r"#[0-9]{3,}", combined))
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)

package/scripts/test_skill_code_review_seed.py

@@ -1,89 +0,0 @@
-#!/usr/bin/env python3
-"""code-review skill + its setup-workflow project-layer seed (Welle 49).
-
-Companion to test_skill_setup_workflow_seeds.py (not touched here — a sibling
-slice edits it concurrently). Pins the two machine-checkable parts specific to
-this skill:
-
-1. The seed template setup-workflow ships (`code-review.md`) is structurally
-   valid for the skill that reads it — same "structured-but-empty crust"
-   contract as the existing spec-self-critique / spec-completeness seeds.
-2. The sentinel-based idempotency rule applies to it the same way (reference
-   implementation duplicated locally so this file has no import-order
-   dependency on the sibling-owned test module).
-
-Run: python3 scripts/test_skill_code_review_seed.py
-"""
-import re
-import unittest
-from pathlib import Path
-
-REPO = Path(__file__).resolve().parent.parent
-SETUP_WORKFLOW = REPO / ".claude/skills/setup-workflow"
-CODE_REVIEW = REPO / ".claude/skills/code-review"
-
-SENTINEL_RE = re.compile(
-    r"^<!--\s*setup-workflow:\s*state=(stub|filled|not-applicable)"
-    r"(?:;\s*mode=(github-projects-v2|none))?\s*-->\s*$"
-)
-
-
-class SeedTemplateValid(unittest.TestCase):
-    def test_code_review_seed_has_both_headings(self):
-        """The two structured-but-empty headings the `code-review` skill's
-        Standards axis expects to find once this file is filled."""
-        t = (SETUP_WORKFLOW / "code-review.md").read_text(encoding="utf-8")
-        self.assertIn("## Standards sources in this repo", t)
-        self.assertIn("## Adjacent review tooling", t)
-
-    def test_code_review_seed_is_generic(self):
-        """No project-coupled tokens in a template shipped to every consumer."""
-        t = (SETUP_WORKFLOW / "code-review.md").read_text(encoding="utf-8")
-        for token in ("Testreporter", "iKon85", "/home/"):
-            self.assertNotIn(token, t)
-        self.assertNotRegex(t, r"#\d{3,5}\b")
-        self.assertNotRegex(t, r"\bHR\d+\b")
-
-    def test_setup_workflow_skill_registers_the_seed(self):
-        """SKILL.md wires the target path + seed link into its Targets table
-        and process, so a reader (or the manifest-completeness lint's sibling
-        checks) can trace the seed from the skill body."""
-        skill = (SETUP_WORKFLOW / "SKILL.md").read_text(encoding="utf-8")
-        self.assertIn("docs/agents/code-review.md", skill)
-        self.assertIn("[code-review.md](./code-review.md)", skill)
-
-    def test_code_review_skill_names_its_project_layer_and_fallback(self):
-        """The skill states the project-layer path + the /setup-workflow
-        fallback (self-containment-lint's LookupContract pattern)."""
-        body = (CODE_REVIEW / "SKILL.md").read_text(encoding="utf-8")
-        self.assertIn("docs/agents/code-review.md", body)
-        self.assertIn("/setup-workflow", body)
-
-
-class FreshFillProducesValidSentinel(unittest.TestCase):
-    """Simulate the write step: prepend the documented sentinel to the seed
-    body and assert the result is a well-formed project-layer file."""
-
-    def test_prepended_sentinel_parses(self):
-        body = (SETUP_WORKFLOW / "code-review.md").read_text(encoding="utf-8")
-        written = "<!-- setup-workflow: state=filled -->\n" + body
-        self.assertRegex(written.splitlines()[0], SENTINEL_RE)
-
-
-class ManifestEntryValid(unittest.TestCase):
-    def test_code_review_is_own_generic_dual_surface_publish_true(self):
-        import json
-
-        manifest = json.loads(
-            (REPO / ".claude/skills/skill-manifest.json").read_text(encoding="utf-8")
-        )
-        entry = manifest["skills"].get("code-review")
-        self.assertIsNotNone(entry, "code-review missing from skill-manifest.json")
-        self.assertEqual(entry["class"], "generic")
-        self.assertIs(entry["publish"], True)
-        self.assertEqual(entry["provenance"], "own")
-        self.assertEqual(set(entry["surfaces"]), {"claude", "codex"})
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)

package/scripts/test_skill_codex_exec_lifecycle.py

@@ -1,123 +0,0 @@
-"""Guard the Claude-only cross-model skills' thin codex-exec lifecycle."""
-
-import json
-import re
-import subprocess
-import unittest
-from pathlib import Path
-
-
-REPO = Path(__file__).resolve().parents[1]
-MANIFEST = REPO / ".claude/skills/skill-manifest.json"
-TARGETS = {
-    "codex-review": ("review", "read-only"),
-    "codex-build": ("build", "workspace-write"),
-    "grill-me-codex": ("review", "read-only"),
-    "grill-with-docs-codex": ("review", "read-only"),
-}
-
-
-class CodexExecSkillLifecycleTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        manifest = json.loads(MANIFEST.read_text(encoding="utf-8"))["skills"]
-        cls.skills = {}
-        for name, expected in TARGETS.items():
-            entry = manifest[name]
-            if entry["surfaces"] != ["claude"]:
-                raise AssertionError(f"{name} must remain Claude-only")
-            path = REPO / ".claude/skills" / name / "SKILL.md"
-            cls.skills[name] = (expected, path.read_text(encoding="utf-8"))
-
-    def test_all_four_skills_use_the_thin_wrapper_lifecycle(self):
-        self.assertEqual(len(self.skills), 4)
-        for name, ((profile, mode), body) in self.skills.items():
-            with self.subTest(skill=name):
-                self.assertIn(
-                    f"scripts/codex-exec.sh new --profile {profile} --mode {mode}",
-                    body,
-                )
-                self.assertRegex(body, r"scripts/codex-exec\.sh resume [\"']?\$RUN_ID")
-                self.assertRegex(body, r"scripts/codex-exec\.sh finalize [\"']?\$RUN_ID")
-                self.assertEqual(body.count("scripts/codex-exec.sh handle-failure"), 2)
-                self.assertNotRegex(
-                    body,
-                    r"scripts/codex-exec\.sh resume[^\n]*--mode",
-                    "resume must inherit the persisted mode",
-                )
-
-    def test_new_and_resume_are_thin_ordered_and_valid_bash(self):
-        for name, (_, body) in self.skills.items():
-            blocks = re.findall(
-                r"```bash\n(if ROUND_RESULT=\$\(scripts/codex-exec\.sh (?:new|resume).*?\nfi)\n```",
-                body,
-                re.DOTALL,
-            )
-            self.assertEqual(len(blocks), 2, name)
-            for block in blocks:
-                first_line = block.splitlines()[0]
-                is_resume = "scripts/codex-exec.sh resume " in first_line
-                success, failure = block.split("\nelse\n", 1)
-                self.assertIn("CODEX_REPORT=", success)
-                self.assertNotIn("CODEX_REPORT=", failure)
-                self.assertIn("scripts/codex-exec.sh handle-failure", failure)
-                self.assertIn("|| :", failure)
-                self.assertNotIn("json.load", failure)
-                handler = failure.index("handle-failure")
-                surfaced = failure.index('printf \'%s\\n\' "$FAILURE_RESULT" >&2')
-                stopped = failure.index("exit 1")
-                self.assertLess(handler, surfaced)
-                self.assertLess(surfaced, stopped)
-                if is_resume:
-                    self.assertIn('--run-id "$RUN_ID"', failure)
-                    self.assertNotIn("\n  RUN_ID=", success)
-                else:
-                    self.assertNotIn("--run-id", failure)
-                    self.assertLess(success.index("RUN_ID="), success.index("CODEX_REPORT="))
-                parsed = subprocess.run(
-                    ["bash", "-n"],
-                    input=block,
-                    text=True,
-                    capture_output=True,
-                    check=False,
-                )
-                self.assertEqual(parsed.returncode, 0, parsed.stderr)
-
-    def test_all_skills_abort_known_run_on_orchestration_cancellation(self):
-        for name, (_, body) in self.skills.items():
-            with self.subTest(skill=name):
-                cancellation = re.search(
-                    r"[Cc]ancellation or a decision to stop (?:orchestration|delegation)"
-                    r".*?scripts/codex-exec\.sh abort \"\$RUN_ID\"",
-                    body,
-                    re.DOTALL,
-                )
-                self.assertIsNotNone(cancellation)
-                self.assertRegex(body, r"scripts/codex-exec\.sh finalize [\"']?\$RUN_ID")
-
-        build = self.skills["codex-build"][1]
-        gate = build.split("## Step 5 — Human gate", 1)[1].split("## Hard rules", 1)[0]
-        self.assertLess(
-            gate.index("Rejected with another requested fix"),
-            gate.index("Cancellation or a decision to stop delegation"),
-        )
-
-    def test_no_skill_reimplements_codex_process_or_failure_mechanics(self):
-        forbidden = {
-            "copied round function": re.compile(r"\brun_codex_round\b"),
-            "copied status parser": re.compile(r"\bROUND_STATUS\b|\.get\(\"status\""),
-            "copied run-id cleanup": re.compile(r"\bFAILED_RUN_ID\b"),
-            "raw codex exec": re.compile(r"(?m)^\s*codex\s+exec\b"),
-            "manual liveness sleep": re.compile(r"\bsleep\s+90\b"),
-            "manual sandbox override": re.compile(r"\bsandbox_mode\s*="),
-            "manual process probe": re.compile(r"\bkill\s+-0\b"),
-            "manual codex pid": re.compile(r"\bCODEX_PID\b"),
-        }
-        for name, (_, body) in self.skills.items():
-            for label, pattern in forbidden.items():
-                with self.subTest(skill=name, forbidden=label):
-                    self.assertIsNone(pattern.search(body))
-
-
-if __name__ == "__main__":
-    unittest.main()