prizmkit 1.1.130 → 1.1.134

package/bundled/dev-pipeline/tests/test_generate_bootstrap_prompt.py

@@ -1,6 +1,7 @@
 """Tests for generate-bootstrap-prompt.py core functions."""
 
 import json
+import hashlib
 import importlib.util
 import os
 import re
@@ -27,6 +28,9 @@ from generate_bootstrap_prompt import (
     merge_checkpoint_state,
     load_active_agent_prompts,
     validate_rendered,
+    validate_feature_test_evidence,
+    route_feature_repair,
+    feature_checkpoint_metadata,
     main as generate_bootstrap_main,
 )
 from continuation import append_continuation_handoff, checkpoint_cursor
@@ -47,9 +51,9 @@ FORBIDDEN_THREE_STRIKE = "3-" + "strike"
 FORBIDDEN_TWENTY_STEP = "20-" + "step window"
 
 REVIEW_PROMPT_REQUIRED = (
-    "The current Main Agent is the only Code Review executor",
-    "Do not invoke another review skill or review workflow",
-    "finder, verifier, audit, compatibility review, verification, or gap sweep",
+    "mandatory Main-Agent review",
+    "strict structural capability gate",
+    "skill-owned independent Reviewer",
     "`review-report.md` is the only persisted review artifact",
 )
 
@@ -157,7 +161,7 @@ def scoped_report_text(verdict="PASS", boundary_missing=0,
 
 
 def write_fresh_scoped_report(project_root, report_path, report_text=None):
-    """Write marker, in-scope files, and a fresh scoped report."""
+    """Write marker, in-scope files, and a fresh derived report."""
     source = project_root / "src" / "feature.js"
     test = project_root / "tests" / "feature.test.js"
     marker = project_root / ".prizmkit" / "specs" / "123-scope-test" / ".prizmkit-test-started"
@@ -173,6 +177,135 @@ def write_fresh_scoped_report(project_root, report_path, report_text=None):
     return source, test, marker
 
 
+def write_fresh_structured_evidence(project_root):
+    """Create the smallest protocol-shaped, validator-attested pass package."""
+    source, test, marker = write_fresh_scoped_report(
+        project_root,
+        project_root / ".prizmkit" / "test" / "unused" / "test-report.md",
+    )
+    evidence_base = project_root / ".prizmkit" / "test" / "evidence"
+    environment = {}
+    plan_inputs = {"feature": "123-scope-test"}
+    categories = {
+        "source": [{"path": "src/feature.js", "sha256": hashlib.sha256(source.read_bytes()).hexdigest()}],
+        "tests": [{"path": "tests/feature.test.js", "sha256": hashlib.sha256(test.read_bytes()).hexdigest()}],
+        "contracts": [],
+        "lockfiles": [],
+    }
+    target_hashes = {
+        category: hashlib.sha256(json.dumps(
+            sorted(records, key=lambda item: item["path"]),
+            sort_keys=True, separators=(",", ":"),
+        ).encode()).hexdigest()
+        for category, records in categories.items()
+    }
+    target_hashes["environment"] = hashlib.sha256(b"{}").hexdigest()
+    target_hashes["plan"] = hashlib.sha256(json.dumps(
+        plan_inputs, sort_keys=True, separators=(",", ":"),
+    ).encode()).hexdigest()
+    inventory = {
+        "categories": categories,
+        "plan_inputs": plan_inputs,
+    }
+    scope = {"feature": "123-scope-test"}
+    zero_hash = "0" * 64
+    identity = {
+        "baseline_commit": "baseline",
+        "working_diff_sha256": zero_hash,
+        "scope_sha256": hashlib.sha256(json.dumps(
+            scope, sort_keys=True, separators=(",", ":"),
+        ).encode()).hexdigest(),
+    }
+    evidence_id = hashlib.sha256(json.dumps(
+        identity, sort_keys=True, separators=(",", ":"),
+    ).encode()).hexdigest()
+    evidence_root = evidence_base / evidence_id
+    evidence_root.mkdir(parents=True, exist_ok=True)
+    (evidence_root / "environment.json").write_text("{}\n", encoding="utf-8")
+    (evidence_root / "target-inventory.json").write_text(
+        json.dumps(inventory), encoding="utf-8",
+    )
+    (evidence_root / "scope.json").write_text(json.dumps(scope), encoding="utf-8")
+    verdict = {
+        "verdict": "TEST_PASS",
+        "testing_domain_only": True,
+        "authorizes_commit_or_release": False,
+        "real_environment_validated": False,
+        "repairs_business_defects": False,
+        "code_evidence_replayable": True,
+        "blockers": [],
+        "reproduced_failures": [],
+    }
+    (evidence_root / "verdict.json").write_text(json.dumps(verdict), encoding="utf-8")
+    report = scoped_report_text()
+    (evidence_root / "test-report.md").write_text(report, encoding="utf-8")
+    stages = []
+    stage_names = [
+        "CHANGE_CLASSIFY", "SCOPE_DISCOVER", "CONTRACT_MODEL", "TEST_PLAN",
+        "INFRA_READY", "TEST_BUILD", "EXECUTE_PROVE", "EVIDENCE_PACKAGE",
+        "EVIDENCE_VALIDATE",
+    ]
+    for name in stage_names:
+        stages.append({"name": name, "status": "complete", "input_sha256": zero_hash, "outputs": []})
+    manifest = {
+        "protocol_version": "1.0",
+        "evidence_id": evidence_id,
+        "evidence_id_inputs": identity,
+        "sensitivity": "project-controlled",
+        "environment_claim": "mocked-code-level-only",
+        "compatibility": "legacy-test-report-interface-not-supported",
+        "change_class": "lightweight",
+        "baseline_commit": "baseline",
+        "working_diff_sha256": zero_hash,
+        "target_hashes": target_hashes,
+        "stages": stages,
+        "files": [],
+        "final_verdict": "TEST_PASS",
+    }
+    file_records = []
+    for path in sorted(evidence_root.rglob("*")):
+        if path.is_file():
+            relative = path.relative_to(evidence_root).as_posix()
+            file_records.append({
+                "path": relative,
+                "sha256": hashlib.sha256(path.read_bytes()).hexdigest(),
+                "produced_by": "EVIDENCE_PACKAGE",
+            })
+    payload = sorted(
+        ({"path": item["path"], "sha256": item["sha256"]}
+         for item in file_records
+         if item["path"] not in {"verdict.json", "test-report.md"}),
+        key=lambda item: item["path"],
+    )
+    validation = {
+        "validator": "validate_test_evidence.py",
+        "validator_sha256": zero_hash,
+        "payload_sha256": hashlib.sha256(json.dumps(
+            payload, sort_keys=True, separators=(",", ":"),
+        ).encode()).hexdigest(),
+        "result": "passed",
+        "verdict": "TEST_PASS",
+        "semantics": "integrity-and-protocol-validation-not-hostile-producer-proof",
+        "replay_receipt_ids": [],
+    }
+    (evidence_root / "validation.json").write_text(json.dumps(validation), encoding="utf-8")
+    file_records.append({
+        "path": "validation.json",
+        "sha256": hashlib.sha256((evidence_root / "validation.json").read_bytes()).hexdigest(),
+        "produced_by": "EVIDENCE_VALIDATE",
+    })
+    manifest["files"] = file_records
+    (evidence_root / "manifest.json").write_text(json.dumps(manifest), encoding="utf-8")
+    pointer = project_root / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
+    pointer.parent.mkdir(parents=True, exist_ok=True)
+    pointer.write_text(str(evidence_root / "test-report.md"), encoding="utf-8")
+    report_path = evidence_root / "test-report.md"
+    now = time.time()
+    os.utime(marker, (now, now))
+    os.utime(report_path, (now + 1, now + 1))
+    return evidence_root
+
+
 # ---------------------------------------------------------------------------
 # compute_feature_slug
 # ---------------------------------------------------------------------------
@@ -469,6 +602,13 @@ class TestProcessModeBlocks:
 # ---------------------------------------------------------------------------
 
 class TestScopedFeatureTestGate:
+    @staticmethod
+    def _trust_fixture_validator(monkeypatch):
+        monkeypatch.setattr(
+            "generate_bootstrap_prompt._evidence_validator_passes",
+            lambda _project_root, _evidence_root, _validation: True,
+        )
+
     def test_standard_sections_insert_prizmkit_test_after_review(self):
         sections_dir = Path(__file__).resolve().parents[1] / "templates" / "sections"
         sections = assemble_sections(
@@ -561,7 +701,9 @@ class TestScopedFeatureTestGate:
         test_step = next(step for step in checkpoint["steps"] if step["skill"] == "prizmkit-test")
         assert test_step["required_artifacts"] == [
             ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
+            ".prizmkit/test/evidence/*/manifest.json",
+            ".prizmkit/test/evidence/*/verdict.json",
+            ".prizmkit/test/evidence/*/validation.json",
         ]
 
     def test_merge_resets_completed_prizmkit_test_without_report_artifact(self, tmp_path):
@@ -596,19 +738,19 @@ class TestScopedFeatureTestGate:
 
         assert [step["status"] for step in merged["steps"]] == ["pending", "pending"]
 
-    def test_merge_keeps_completed_prizmkit_test_only_for_scoped_pass_report(self, tmp_path):
-        report = tmp_path / ".prizmkit" / "test" / "run" / "test-report.md"
-        write_fresh_scoped_report(tmp_path, report)
+    def test_merge_keeps_completed_prizmkit_test_only_for_scoped_pass_report(self, tmp_path, monkeypatch):
+        self._trust_fixture_validator(monkeypatch)
+        evidence_root = write_fresh_structured_evidence(tmp_path)
         pointer = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
         pointer.parent.mkdir(parents=True, exist_ok=True)
-        pointer.write_text(".prizmkit/test/run/test-report.md\n", encoding="utf-8")
+        pointer.write_text(str(evidence_root / "test-report.md") + "\n", encoding="utf-8")
         existing = {
             "steps": [
-                {"id": "S01", "skill": "prizmkit-test", "status": "completed", "required_artifacts": [
+                {"id": "S01", "skill": "prizmkit-test", "status": "completed", "stage_result": "TEST_PASS", "required_artifacts": [
                     ".prizmkit/specs/123-scope-test/test-report-path.txt",
                     ".prizmkit/test/*/test-report.md",
                 ]},
-                {"id": "S02", "skill": "prizmkit-code-review", "status": "completed", "required_artifacts": []},
+                {"id": "S02", "skill": "prizmkit-code-review", "status": "completed", "stage_result": "REVIEW_PASS", "required_artifacts": []},
             ],
         }
         fresh = {
@@ -834,25 +976,171 @@ class TestScopedFeatureTestGate:
 
         assert merged["steps"][0]["status"] == "pending"
 
-    def test_merge_resets_completed_prizmkit_test_without_in_scope_sources(self, tmp_path):
+    def test_structured_evidence_accepts_current_matching_package(self, tmp_path, monkeypatch):
+        self._trust_fixture_validator(monkeypatch)
+        evidence_root = write_fresh_structured_evidence(tmp_path)
+
+        evidence = validate_feature_test_evidence(
+            str(tmp_path), ".prizmkit/specs/123-scope-test",
+        )
+
+        assert evidence is not None
+        assert evidence["verdict"] == "TEST_PASS"
+        assert evidence["manifest_path"] == str(
+            (evidence_root / "manifest.json").relative_to(tmp_path),
+        )
+        assert evidence["validation_path"].endswith("/validation.json")
+
+    def test_structured_evidence_requires_authoritative_validator(self, tmp_path, monkeypatch):
+        write_fresh_structured_evidence(tmp_path)
+        monkeypatch.setattr(
+            "generate_bootstrap_prompt._evidence_validator_passes",
+            lambda _project_root, _evidence_root, _validation: False,
+        )
+
+        assert validate_feature_test_evidence(
+            str(tmp_path), ".prizmkit/specs/123-scope-test",
+        ) is None
+
+    def test_structured_evidence_rejects_legacy_markdown_only_pass(self, tmp_path):
         report = tmp_path / ".prizmkit" / "test" / "run" / "test-report.md"
-        report_text = scoped_report_text().replace("- In-Scope Source Files:\n  - src/feature.js\n", "- In-Scope Source Files:\n")
-        write_fresh_scoped_report(tmp_path, report, report_text)
+        write_fresh_scoped_report(tmp_path, report)
         pointer = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
-        pointer.write_text(".prizmkit/test/run/test-report.md\n", encoding="utf-8")
-        existing = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "completed", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
-        fresh = {"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "pending", "required_artifacts": [
-            ".prizmkit/specs/123-scope-test/test-report-path.txt",
-            ".prizmkit/test/*/test-report.md",
-        ]}]}
+        pointer.write_text(str(report), encoding="utf-8")
+
+        assert validate_feature_test_evidence(
+            str(tmp_path), ".prizmkit/specs/123-scope-test",
+        ) is None
+
+    def test_structured_evidence_rejects_missing_validation(self, tmp_path):
+        evidence_root = write_fresh_structured_evidence(tmp_path)
+        (evidence_root / "validation.json").unlink()
+
+        assert validate_feature_test_evidence(
+            str(tmp_path), ".prizmkit/specs/123-scope-test",
+        ) is None
+
+    def test_structured_evidence_rejects_tampered_verdict(self, tmp_path, monkeypatch):
+        self._trust_fixture_validator(monkeypatch)
+        evidence_root = write_fresh_structured_evidence(tmp_path)
+        verdict_path = evidence_root / "verdict.json"
+        verdict = json.loads(verdict_path.read_text(encoding="utf-8"))
+        verdict["verdict"] = "TEST_BLOCKED"
+        verdict_path.write_text(json.dumps(verdict), encoding="utf-8")
+
+        assert validate_feature_test_evidence(
+            str(tmp_path), ".prizmkit/specs/123-scope-test",
+        ) is None
+
+    def test_structured_evidence_rejects_wrong_artifact_scope(self, tmp_path, monkeypatch):
+        self._trust_fixture_validator(monkeypatch)
+        evidence_root = write_fresh_structured_evidence(tmp_path)
+        report_path = evidence_root / "test-report.md"
+        report_path.write_text(
+            scoped_report_text().replace(
+                ".prizmkit/specs/123-scope-test/",
+                ".prizmkit/specs/999-other/",
+            ),
+            encoding="utf-8",
+        )
 
-        merged = merge_checkpoint_state(existing, fresh, str(tmp_path))
+        assert validate_feature_test_evidence(
+            str(tmp_path), ".prizmkit/specs/123-scope-test",
+        ) is None
 
-        assert merged["steps"][0]["status"] == "pending"
+    def test_structured_evidence_rejects_stale_report(self, tmp_path, monkeypatch):
+        self._trust_fixture_validator(monkeypatch)
+        evidence_root = write_fresh_structured_evidence(tmp_path)
+        report = evidence_root / "test-report.md"
+        marker = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / ".prizmkit-test-started"
+        now = time.time()
+        os.utime(report, (now, now))
+        os.utime(marker, (now + 10, now + 10))
+
+        assert validate_feature_test_evidence(
+            str(tmp_path), ".prizmkit/specs/123-scope-test",
+        ) is None
+
+    def test_structured_evidence_rejects_live_inventory_drift(self, tmp_path, monkeypatch):
+        self._trust_fixture_validator(monkeypatch)
+        write_fresh_structured_evidence(tmp_path)
+        source = tmp_path / "src" / "feature.js"
+        source.write_text("export const feature = false;\n", encoding="utf-8")
 
+        assert validate_feature_test_evidence(
+            str(tmp_path), ".prizmkit/specs/123-scope-test",
+        ) is None
+
+    def test_feature_repair_routing_preserves_review_and_test_boundaries(self):
+        review = route_feature_repair("REVIEW_NEEDS_FIXES", repair_round=0)
+        test_infra = route_feature_repair(
+            "TEST_FAIL", "test-infrastructure", repair_round=1,
+        )
+        production = route_feature_repair("TEST_FAIL", "production", repair_round=1)
+
+        assert review["route"] == [
+            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
+        ]
+        assert test_infra["route"] == ["prizmkit-implement", "prizmkit-test"]
+        assert production["route"] == [
+            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
+        ]
+        assert review["repair_round"] == 1
+
+    def test_feature_repair_routing_blocks_unsafe_and_exhausted_routes(self):
+        unknown = route_feature_repair("TEST_FAIL", "unknown", repair_round=1)
+        blocked = route_feature_repair("TEST_BLOCKED", "production", repair_round=1)
+        exhausted = route_feature_repair("TEST_FAIL", "production", repair_round=3)
+
+        assert unknown["blocked"] is True
+        assert unknown["route"] == []
+        assert blocked["blocked"] is True
+        assert blocked["resumable"] is False
+        assert blocked["next_stage"] is None
+        assert blocked["terminal_status"] == "WORKFLOW_BLOCKED"
+        assert blocked["blocked_reason"] == "test_blocked"
+        assert exhausted["blocked"] is True
+        assert exhausted["repair_round"] == 3
+
+    def test_feature_checkpoint_metadata_records_l1_handoff_fields(self):
+        evidence = {
+            "manifest_path": ".prizmkit/test/evidence/id/manifest.json",
+            "verdict_path": ".prizmkit/test/evidence/id/verdict.json",
+            "validation_path": ".prizmkit/test/evidence/id/validation.json",
+        }
+
+        metadata = feature_checkpoint_metadata(
+            ".prizmkit/specs/123-scope-test",
+            evidence=evidence,
+            stage="test",
+            status="TEST_FAIL",
+            stage_result="TEST_FAIL",
+            repair_scope="test-infrastructure",
+            repair_round=2,
+            next_stage="prizmkit-implement",
+            resume_from="prizmkit-implement",
+        )
+
+        assert metadata == {
+            "schema_version": 1,
+            "artifact_dir": ".prizmkit/specs/123-scope-test",
+            "orchestrator": "prizmkit-l4",
+            "stage": "test",
+            "current_stage": "test",
+            "status": "TEST_FAIL",
+            "stage_result": "TEST_FAIL",
+            "repair_scope": "test-infrastructure",
+            "repair_round": 2,
+            "authoritative_evidence_paths": {
+                "manifest": ".prizmkit/test/evidence/id/manifest.json",
+                "verdict": ".prizmkit/test/evidence/id/verdict.json",
+                "validation": ".prizmkit/test/evidence/id/validation.json",
+            },
+            "next_stage": "prizmkit-implement",
+            "resume_from": "prizmkit-implement",
+            "blocked_reason": None,
+            "terminal_status": None,
+        }
 
 # ---------------------------------------------------------------------------
 # Active compaction harness rollback
@@ -947,10 +1235,10 @@ class TestDirectOrchestratorImplementationPrompts:
             assert FORBIDDEN_TEST_CMD_PLACEHOLDER not in rendered
             assert FORBIDDEN_THREE_STRIKE not in rendered
             assert FORBIDDEN_TWENTY_STEP not in rendered
-            assert "Main-Agent review loop" in rendered
+            assert "mandatory Main-Agent review" in rendered
             assert "up to ten completed rounds" in rendered
-            assert "The current Main Agent is the only Code Review executor" in rendered
-            assert "Do not invoke another review skill or review workflow" in rendered
+            assert "strict structural capability gate" in rendered
+            assert "skill-owned independent Reviewer" in rendered
             assert "low=0" not in rendered
             assert "Reviewer 3" not in rendered
 
@@ -1078,9 +1366,19 @@ class TestContinuationHandoff:
         assert checkpoint_cursor(checkpoint)["first_cursor"] == "S02 (active)"
 
 
-# ---------------------------------------------------------------------------
-# F-033 headless prompt cleanup and platform-aware paths
-# ---------------------------------------------------------------------------
+def test_modular_feature_prompt_renders_user_context(tmp_path):
+    prompt = _render_feature_prompt(
+        tmp_path / "user-context",
+        mode="standard",
+        user_context=["Use the existing event envelope", "Keep the public API backward compatible"],
+    )
+
+    assert "Use the existing event envelope" in prompt
+    assert "Keep the public API backward compatible" in prompt
+    assert "These materials were provided by the user" in prompt
+    assert "{{USER_CONTEXT}}" not in prompt
+
+
 
 HEADLESS_FORBIDDEN_PROMPT_STRINGS = [
     "### Interactive Claude Code Note",
@@ -1101,7 +1399,7 @@ def _write_feature_list(path, feature):
     path.write_text(json.dumps({"features": [feature], "global_context": {"language": "Python"}}), encoding="utf-8")
 
 
-def _render_feature_prompt(tmp_path, mode="standard", template=None, platform="claude", browser_interaction=None, complexity=None):
+def _render_feature_prompt(tmp_path, mode="standard", template=None, platform="claude", browser_interaction=None, complexity=None, user_context=None):
     project = tmp_path / "project"
     project.mkdir(parents=True)
     (project / ".prizmkit" / "plans").mkdir(parents=True)
@@ -1115,6 +1413,8 @@ def _render_feature_prompt(tmp_path, mode="standard", template=None, platform="c
         "estimated_complexity": complexity or {"lite": "low", "standard": "medium", "full": "high"}[mode],
         "acceptance_criteria": ["Prompts are clean"],
     }
+    if user_context is not None:
+        feature["user_context"] = user_context
     if browser_interaction is not None:
         feature["browser_interaction"] = browser_interaction
     feature_list = project / ".prizmkit" / "plans" / "feature-list.json"
@@ -1513,28 +1813,29 @@ class TestBrowserOptInPromptPolicy:
         assert "browser-verification" not in self._checkpoint_skills(tmp_path / "global-disable" / "bugfix", "bugfix")
         assert "browser-verification" not in self._checkpoint_skills(tmp_path / "global-disable" / "refactor", "refactor")
 
-    def test_fresh_manual_bugfix_prompt_stops_before_commit_phase(self, tmp_path):
+    def test_manual_bugfix_prompt_remains_headless_and_committable(self, tmp_path):
         prompt = _render_bugfix_prompt(
-            tmp_path / "fresh-manual-bugfix",
+            tmp_path / "manual-bugfix",
             bug_overrides={"verification_type": "manual"},
         )
 
         assert "Manual / Hybrid Verification Gate" in prompt
-        assert "Stop before `/prizmkit-retrospective` and `/prizmkit-committer`" in prompt
-        assert "### Phase 4: Commit & Learn" not in prompt
-        assert "Run `/prizmkit-committer` with commit prefix" not in prompt
+        assert "must complete manual/hybrid verification automatically" in prompt
+        assert "Stop before `/prizmkit-retrospective` and `/prizmkit-committer`" not in prompt
+        assert "### Headless Commit Authorization" in prompt
+        assert "status=\"partial\"" not in prompt
 
-    def test_recovery_manual_bugfix_prompt_includes_commit_phase_with_substitution_policy(self, tmp_path):
+    def test_recovery_manual_bugfix_uses_same_automatic_policy(self, tmp_path):
         prompt = _render_bugfix_prompt(
             tmp_path / "recovery-manual-bugfix",
             bug_overrides={"verification_type": "manual"},
             retry_count="1",
         )
 
-        assert "Manual / Hybrid Verification Gate" not in prompt
-        assert "Recovery-class session: automated verification may substitute for manual/hybrid UAT" in prompt
-        assert "### Phase 4: Commit & Learn" in prompt
-        assert "Run `/prizmkit-committer` with commit prefix" in prompt
+        assert "Manual / Hybrid Verification Gate" in prompt
+        assert "must complete manual/hybrid verification automatically" in prompt
+        assert "Recovery-class session: automated verification may substitute" not in prompt
+        assert "### Headless Commit Authorization" in prompt
 
 
 class TestHeadlessPromptCleanupF033:
@@ -1630,9 +1931,9 @@ class TestHeadlessPromptCleanupF033:
         refactor_prompt = _render_refactor_prompt(tmp_path / "refactor-mixed", platform="claude")
 
         assert "{{" + "REVIEWER_" + "SUBAGENT_PATH" + "}}" not in replacements
-        assert "Main-Agent review loop" in refactor_prompt
-        assert "The current Main Agent is the only Code Review executor" in refactor_prompt
-        assert "Do not invoke another review skill or review workflow" in refactor_prompt
+        assert "mandatory Main-Agent review" in refactor_prompt
+        assert "strict structural capability gate" in refactor_prompt
+        assert "skill-owned independent Reviewer" in refactor_prompt
         assert "Reviewer 3" not in refactor_prompt
 
     def test_bugfix_refactor_explicit_codex_override(self, tmp_path, monkeypatch):
@@ -1654,9 +1955,9 @@ class TestHeadlessPromptCleanupF033:
         refactor_prompt = _render_refactor_prompt(tmp_path / "refactor-codex", platform="claude", explicit_platform="codex")
 
         assert "{{" + "REVIEWER_" + "SUBAGENT_PATH" + "}}" not in replacements
-        assert "Main-Agent review loop" in refactor_prompt
-        assert "The current Main Agent is the only Code Review executor" in refactor_prompt
-        assert "Do not invoke another review skill or review workflow" in refactor_prompt
+        assert "mandatory Main-Agent review" in refactor_prompt
+        assert "strict structural capability gate" in refactor_prompt
+        assert "skill-owned independent Reviewer" in refactor_prompt
         assert "Reviewer 3" not in refactor_prompt