@ikon85/agent-workflow-kit 0.27.1 → 0.28.0

package/scripts/test_census_backstop.py

@@ -4,6 +4,7 @@ import os
 import subprocess
 import sys
 import tempfile
+import time
 import unittest
 from pathlib import Path
 from unittest.mock import patch
@@ -45,6 +46,35 @@ class CensusBackstopTest(unittest.TestCase):
             json.dumps(fresh) + "\n", encoding="utf-8"
         )
 
+    def test_census_bridge_uses_production_scale_budgets_and_clamps_proofs(self):
+        temporary, root = self.make_repo()
+        self.addCleanup(temporary.cleanup)
+        self.enable(root)
+        calls = []
+
+        def complete_scan(*args, **kwargs):
+            calls.append(kwargs)
+            return subprocess.CompletedProcess(
+                args=args[0], returncode=0,
+                stdout=json.dumps({"state": "bootstrap"}), stderr="",
+            )
+
+        with patch.object(DRIFT_GUARD.subprocess, "run", side_effect=complete_scan):
+            DRIFT_GUARD.scan_census_status(root)
+            DRIFT_GUARD.scan_census_status(root, proof_timeout_ms=10**9)
+
+        default_input = json.loads(calls[0]["input"])
+        clamped_input = json.loads(calls[1]["input"])
+        self.assertEqual(calls[0]["timeout"], 30)
+        self.assertEqual(default_input["proofTimeoutMs"], 12_000)
+        self.assertGreater(clamped_input["proofTimeoutMs"], 0)
+        self.assertLess(clamped_input["proofTimeoutMs"], calls[1]["timeout"] * 1_000)
+
+        for invalid in (False, 1.5, "12000"):
+            with self.subTest(invalid=invalid):
+                with self.assertRaisesRegex(ValueError, "proof timeout must be an integer"):
+                    DRIFT_GUARD.scan_census_status(root, proof_timeout_ms=invalid)
+
     def test_missing_disabled_bootstrap_and_offline_are_visible_but_fail_open(self):
         temporary, root = self.make_repo()
         self.addCleanup(temporary.cleanup)
@@ -322,15 +352,14 @@ class CensusBackstopTest(unittest.TestCase):
                          ("refresh_required", True))
         self.assertIn("proof:src", failed_test["reasons"])
 
-    def test_activated_census_blocks_when_local_proof_times_out(self):
+    def test_production_scale_proof_completes_and_hung_proofs_stay_bounded(self):
         temporary, root = self.make_repo()
         self.addCleanup(temporary.cleanup)
         module = root / "scanner.mjs"
         test = root / "scanner.test.mjs"
         module.write_text("export function scanLocal() { return ['src']; }\n", encoding="utf-8")
         test.write_text(
-            "import { test } from 'node:test'; "
-            "test('hang', async () => new Promise(resolve => setTimeout(resolve, 250)));\n",
+            "import { test } from 'node:test'; test('proof', () => {});\n",
             encoding="utf-8",
         )
         subprocess.run(["git", "add", "scanner.mjs", "scanner.test.mjs"], cwd=root, check=True)
@@ -341,11 +370,32 @@ class CensusBackstopTest(unittest.TestCase):
         self.enable(root, local_scanners=[scanner])
         self.activate_current(root)
 
+        module.write_text(
+            "export async function scanLocal() { "
+            "await new Promise(resolve => setTimeout(resolve, 5200)); return ['src']; }\n",
+            encoding="utf-8",
+        )
+        valid_started = time.monotonic()
+        valid = DRIFT_GUARD.evaluate_census(root)
+        valid_elapsed = time.monotonic() - valid_started
+        self.assertEqual((valid["state"], valid["block_handoff"]), ("current", False))
+        self.assertGreater(valid_elapsed, 5)
+        self.assertLess(valid_elapsed, DRIFT_GUARD.CENSUS_BRIDGE_TIMEOUT_SECONDS)
+
+        test.write_text(
+            "import { test } from 'node:test'; "
+            "test('hang', async () => new Promise(resolve => setTimeout(resolve, 250)));\n",
+            encoding="utf-8",
+        )
+        module.write_text("export function scanLocal() { return ['src']; }\n", encoding="utf-8")
+        timeout_started = time.monotonic()
         result = DRIFT_GUARD.evaluate_census(root, proof_timeout_ms=25)
+        timeout_elapsed = time.monotonic() - timeout_started
 
         self.assertEqual((result["state"], result["block_handoff"]),
                          ("refresh_required", True))
         self.assertIn("proof:src", result["reasons"])
+        self.assertLess(timeout_elapsed, 2)
 
         test.write_text("import { test } from 'node:test'; test('proof', () => {});\n",
                         encoding="utf-8")
@@ -353,10 +403,13 @@ class CensusBackstopTest(unittest.TestCase):
             "export async function scanLocal() { return new Promise(() => {}); }\n",
             encoding="utf-8",
         )
+        scanner_timeout_started = time.monotonic()
         scanner_timeout = DRIFT_GUARD.evaluate_census(root, proof_timeout_ms=25)
+        scanner_timeout_elapsed = time.monotonic() - scanner_timeout_started
         self.assertEqual((scanner_timeout["state"], scanner_timeout["block_handoff"]),
                          ("refresh_required", True))
         self.assertIn("proof:src", scanner_timeout["reasons"])
+        self.assertLess(scanner_timeout_elapsed, 2)
 
     def test_activated_census_fails_closed_when_bridge_is_unavailable(self):
         temporary, root = self.make_repo()

package/scripts/test_orchestrate_wave_contract.py

@@ -0,0 +1,116 @@
+#!/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"
+)
+
+
+# Outcome -> fragments whose conjunction proves that portable behavior.
+BEHAVIORAL_PARITY = {
+    "collision-safe claim": (
+        "wave-active/<anchor>",
+        "ahead",
+        "uncommitted changes",
+        "LOCAL annotated tag",
+        "never push",
+    ),
+    "owner-safe abort cleanup": (
+        "this run planted",
+        "On ANY wave STOP/abort",
+        "Never delete a claim marker observed during a preflight collision",
+    ),
+    "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",
+    ),
+}
+
+
+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]
+
+
+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_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_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

@@ -0,0 +1,245 @@
+#!/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_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()

package/scripts/test_retro_wrapup_contract.py

@@ -0,0 +1,111 @@
+"""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_upstream_or_own_and_exact_sanitized_approval_survive(self):
+        required = (
+            "generic or project-specific",
+            "recommend `own`",
+            "sanitized preview",
+            "explicitly approves that exact text",
+            "does not need to be the kit maintainer",
+            "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_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` 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_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 `/wrapup` input IS the explicit", text)
+                self.assertIn("program-sync", text)
+                self.assertIn("Phasen-Gates", 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_tdd_contract.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Contract tests for existing-test-first TDD without weakening RED-first."""
+
+from pathlib import Path
+import re
+import unittest
+
+
+ROOT = Path(__file__).resolve().parents[1]
+SURFACES = (
+    ROOT / ".claude" / "skills" / "tdd" / "SKILL.md",
+    ROOT / ".agents" / "skills" / "tdd" / "SKILL.md",
+)
+DECISIONS = ("REUSE", "EXTEND", "REPLACE", "NEW", "RETIRE", "NO-NEW-TEST")
+
+
+class TddContractTest(unittest.TestCase):
+    def texts(self):
+        return {path: path.read_text(encoding="utf-8") for path in SURFACES}
+
+    def test_each_behavior_gets_exactly_one_existing_test_first_decision(self):
+        for path, text in self.texts().items():
+            with self.subTest(surface=path.relative_to(ROOT)):
+                self.assertIn("### 2. Existing-Test-First Decision", text)
+                self.assertIn("For each planned behavior, record exactly one", text)
+                for decision in DECISIONS:
+                    self.assertEqual(
+                        len(re.findall(rf"^- \*\*{re.escape(decision)}\*\*", text, re.MULTILINE)),
+                        1,
+                        f"{decision} must have exactly one canonical definition",
+                    )
+
+    def test_new_files_require_rejecting_the_nearest_owner_with_a_reason(self):
+        for path, text in self.texts().items():
+            with self.subTest(surface=path.relative_to(ROOT)):
+                self.assertIn("nearest existing owner", text)
+                self.assertIn("rejected with a reason", text)
+
+    def test_red_first_is_unconditional_for_executable_behavior_and_bug_fixes(self):
+        for path, text in self.texts().items():
+            with self.subTest(surface=path.relative_to(ROOT)):
+                self.assertIn(
+                    "Every executable new behavior and bug fix must begin with a failing assertion",
+                    text,
+                )
+                self.assertIn("REUSE and NO-NEW-TEST never bypass this RED-first invariant", text)
+                self.assertRegex(
+                    text,
+                    r"an already-green\s+assertion does not prove the requested change",
+                )
+
+    def test_retirement_keeps_negative_tests_only_for_durable_absence(self):
+        for path, text in self.texts().items():
+            with self.subTest(surface=path.relative_to(ROOT)):
+                self.assertIn("delete the tests that specified the retired behavior", text)
+                self.assertIn("only when absence itself is a durable", text)
+
+    def test_worked_matrix_and_counted_handoff_cover_all_decisions(self):
+        for path, text in self.texts().items():
+            with self.subTest(surface=path.relative_to(ROOT)):
+                matrix = re.search(
+                    r"### Worked decision matrix\n(?P<body>.*?)(?=\n### |\n## )",
+                    text,
+                    re.DOTALL,
+                )
+                self.assertIsNotNone(matrix)
+                body = matrix.group("body")
+                for decision in DECISIONS:
+                    self.assertRegex(body, rf"\|\s*{re.escape(decision)}\s*\|")
+                self.assertIn("list every behavior and its one decision", text)
+                self.assertIn(
+                    "Reused X · Extended Y · New Z · Replaced/retired W",
+                    text,
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()