prizmkit 1.1.130 → 1.1.131

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
@@ -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

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

@@ -13,8 +13,12 @@ from generate_bugfix_prompt import (
     format_error_source_details,
     format_environment,
     generate_bugfix_checkpoint,
+    bugfix_checkpoint_metadata,
+    merge_bugfix_checkpoint_state,
+    route_bugfix_repair,
     process_conditional_blocks,
     render_template,
+    assemble_bugfix_sections,
 )
 from continuation import append_continuation_handoff
 
@@ -312,6 +316,11 @@ def test_template_source_is_clean_for_headless_prompt_contract():
     content = Path("dev-pipeline/templates/bugfix-bootstrap-prompt.md").read_text(encoding="utf-8")
     for forbidden in HEADLESS_FORBIDDEN_PROMPT_STRINGS:
         assert forbidden not in content
+    assert "FAST_PATH=true" not in content
+    assert "prizmkit-workflow" not in content
+    assert "/prizmkit-test scope=this-change artifact_dir=.prizmkit/bugfix/{{BUG_ID}}/" in content
+    assert "local_commit_authorized=true" in content
+    assert "push_authorized=false" in content
 
 
 def test_bugfix_prompt_keeps_fine_grained_phases_out_of_external_status_contract():
@@ -455,6 +464,129 @@ class TestBugfixBootstrapShellExtraction:
 
 
 class TestBugfixCheckpointGeneration:
+    def test_checkpoint_merge_preserves_family_handoff_state(self, tmp_path):
+        fresh = generate_bugfix_checkpoint("B-001", "new")
+        existing = generate_bugfix_checkpoint("B-001", "old")
+        existing["bugfix_state"] = bugfix_checkpoint_metadata(
+            ".prizmkit/bugfix/B-001",
+            stage="test",
+            status="TEST_BLOCKED",
+            stage_result="TEST_BLOCKED",
+            repair_round=2,
+            next_stage="prizmkit-test",
+            resume_from="prizmkit-test",
+        )
+
+        merged = merge_bugfix_checkpoint_state(existing, fresh, str(tmp_path))
+
+        assert merged["bugfix_state"]["stage_result"] == "TEST_BLOCKED"
+        assert merged["bugfix_state"]["resume_from"] == "prizmkit-test"
+
+    def test_default_checkpoint_has_all_atomic_gates_in_order(self):
+        checkpoint = generate_bugfix_checkpoint("B-001", "session-1")
+
+        assert [step["skill"] for step in checkpoint["steps"]] == [
+            "prizmkit-init",
+            "bug-diagnosis-and-plan",
+            "prizmkit-implement",
+            "prizmkit-code-review",
+            "prizmkit-test",
+            "prizmkit-retrospective",
+            "prizmkit-committer",
+            "bug-report",
+        ]
+        test_step = checkpoint["steps"][4]
+        assert test_step["depends_on"] == "S04"
+        assert test_step["required_artifacts"] == [
+            ".prizmkit/test/evidence/*/manifest.json",
+            ".prizmkit/test/evidence/*/verdict.json",
+            ".prizmkit/test/evidence/*/validation.json",
+        ]
+        assert checkpoint["steps"][5]["depends_on"] == "S05"
+
+    def test_bugfix_repair_routing_preserves_review_and_test_boundaries(self):
+        review = route_bugfix_repair("REVIEW_NEEDS_FIXES", repair_round=0)
+        test_infra = route_bugfix_repair(
+            "TEST_FAIL", "test-infrastructure", repair_round=1,
+        )
+        production = route_bugfix_repair("TEST_FAIL", "public-interface", repair_round=2)
+
+        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 production["repair_round"] == 3
+
+    def test_bugfix_repair_routing_blocks_unsafe_blocked_and_exhausted_results(self):
+        unknown = route_bugfix_repair("TEST_FAIL", "unknown", repair_round=1)
+        blocked = route_bugfix_repair("TEST_BLOCKED", "production", repair_round=1)
+        exhausted = route_bugfix_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 blocked["route"] == []
+        assert "cannot safely edit production" in blocked["reason"]
+        assert exhausted["blocked"] is True
+        assert exhausted["repair_round"] == 3
+
+    def test_bugfix_checkpoint_metadata_preserves_artifact_and_evidence_handoff(self):
+        metadata = bugfix_checkpoint_metadata(
+            ".prizmkit/bugfix/B-001",
+            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",
+            },
+            stage="test",
+            status="TEST_FAIL",
+            stage_result="TEST_FAIL",
+            repair_scope="test-infrastructure",
+            repair_round=2,
+        )
+
+        assert metadata["artifact_dir"] == ".prizmkit/bugfix/B-001"
+        assert metadata["authoritative_evidence_paths"]["validation"].endswith(
+            "/validation.json"
+        )
+        assert metadata["repair_round"] == 2
+        assert metadata["resume_from"] == "prizmkit-implement"
+
+    def test_manual_bugfix_keeps_test_gate_but_omits_commit_authorization(self):
+        sections_dir = Path("dev-pipeline/templates/sections")
+        sections = assemble_bugfix_sections(
+            "standard", str(sections_dir), False, True,
+        )
+        names = [name for name, _ in sections]
+
+        assert "bugfix-phase-review" in names
+        assert "bugfix-phase-test" in names
+        assert "bugfix-manual-gate" in names
+        assert "headless-commit-authorization" not in names
+        assert "bugfix-phase-commit-report" not in names
+
+    def test_rendered_bugfix_prompt_is_atomic_headless_and_local_commit_only(self, tmp_path):
+        prompt = _render_bugfix_prompt(tmp_path)
+
+        assert prompt.index("/prizmkit-code-review") < prompt.index(
+            "/prizmkit-test scope=this-change artifact_dir=.prizmkit/bugfix/B-001/"
+        ) < prompt.index("### Headless Commit Authorization")
+        assert "FAST_PATH=true" not in prompt
+        assert "prizmkit-workflow" not in prompt
+        assert '"local_commit_authorized": true' in prompt
+        assert '"push_authorized": false' in prompt
+        assert "Do not ask questions, wait for user input" in prompt
+        assert "push_authorized\": true" not in prompt
+        assert "automatic push" not in prompt.lower()
+        assert ".prizmkit/bugfix/B-001/" in prompt
+
     def test_setup_section_skips_and_finalization_group_expands(self):
         checkpoint = generate_bugfix_checkpoint(
             "B-001",