prizmkit 1.1.153 → 1.1.155

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

@@ -1,7 +1,6 @@
 """Tests for generate-bootstrap-prompt.py core functions."""
 
 import json
-import importlib.util
 import os
 import re
 from argparse import Namespace
@@ -16,10 +15,8 @@ from generate_bootstrap_prompt import (
     format_ac_checklist,
     format_global_context,
     get_completed_dependencies,
-    determine_pipeline_mode,
-    determine_legacy_template_mode,
     process_conditional_blocks,
-    process_mode_blocks,
+    process_template_blocks,
     assemble_sections,
     build_replacements,
     generate_checkpoint_definition,
@@ -87,14 +84,6 @@ def assert_complete_prompt_rendering(prompt):
     assert re.findall(r"\{\{[A-Z][A-Z_0-9]+\}\}", prompt) == []
 
 
-def _load_recovery_prompt_module():
-    path = Path("dev-pipeline/scripts/generate-recovery-prompt.py")
-    spec = importlib.util.spec_from_file_location("generate_recovery_prompt", path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-
 def test_rendered_prompt_validation_rejects_unresolved_control_placeholders():
     content = (
         "## Your Mission\n"
@@ -218,7 +207,6 @@ class TestExplicitProjectRoot:
             state_dir=str(main_checkout / ".prizmkit" / "state" / "features"),
             output=str(main_checkout / ".prizmkit" / "state" / "features" / "F-001" / "sessions" / "session-1" / "bootstrap-prompt.md"),
             template=None,
-            mode=None,
             extract_baselines=False,
             project_root=str(execution_root),
         )
@@ -328,23 +316,6 @@ class TestGetCompletedDependencies:
         assert "no completed dependencies" in result
 
 
-# ---------------------------------------------------------------------------
-# determine_pipeline_mode
-# ---------------------------------------------------------------------------
-
-class TestDeterminePipelineMode:
-    def test_all_complexities_use_unified_full_guidance(self):
-        for complexity in ("low", "medium", "high", "critical", "banana", None):
-            assert determine_pipeline_mode(complexity) == "full"
-
-    def test_legacy_template_mode_mapping_remains_available_for_custom_templates(self):
-        assert determine_legacy_template_mode("low") == "lite"
-        assert determine_legacy_template_mode("medium") == "lite"
-        assert determine_legacy_template_mode("high") == "standard"
-        assert determine_legacy_template_mode("critical") == "full"
-        assert determine_legacy_template_mode("banana") == "lite"
-
-
 # ---------------------------------------------------------------------------
 # process_conditional_blocks
 # ---------------------------------------------------------------------------
@@ -374,29 +345,18 @@ class TestProcessConditionalBlocks:
 
 
 # ---------------------------------------------------------------------------
-# process_mode_blocks
+# explicit custom-template conditionals
 # ---------------------------------------------------------------------------
 
-class TestProcessModeBlocks:
-    def test_lite_mode_keeps_lite(self):
-        tpl = "{{IF_MODE_LITE}}lite content{{END_IF_MODE_LITE}}"
-        result = process_mode_blocks(tpl, "lite", init_done=True)
-        assert "lite content" in result
-        assert "IF_MODE" not in result
-
-    def test_lite_mode_removes_full(self):
-        tpl = "{{IF_MODE_FULL}}full content{{END_IF_MODE_FULL}}"
-        result = process_mode_blocks(tpl, "lite", init_done=True)
-        assert "full content" not in result
-
+class TestProcessTemplateBlocks:
     def test_init_done_keeps_init_done_block(self):
         tpl = "{{IF_INIT_DONE}}\ninit done\n{{END_IF_INIT_DONE}}"
-        result = process_mode_blocks(tpl, "standard", init_done=True)
+        result = process_template_blocks(tpl, init_done=True)
         assert "init done" in result
 
     def test_init_needed_when_not_done(self):
         tpl = "{{IF_INIT_NEEDED}}\nneed init\n{{END_IF_INIT_NEEDED}}"
-        result = process_mode_blocks(tpl, "standard", init_done=False)
+        result = process_template_blocks(tpl, init_done=False)
         assert "need init" in result
 
 
@@ -415,8 +375,7 @@ class TestScopedFeatureTestGate:
         ]
 
     @staticmethod
-    def _write_result(root, result="TEST_PASS", *, unresolved=None,
-                      review_required=False, review_scope=None):
+    def _write_result(root, result="TEST_PASS", *, unresolved=None):
         artifact = root / ".prizmkit" / "specs" / "123-scope-test"
         artifact.mkdir(parents=True, exist_ok=True)
         (artifact / "test-report.md").write_text(
@@ -436,19 +395,16 @@ class TestScopedFeatureTestGate:
             },
             "repair_rounds": 0,
             "production_changed": False,
-            "review_required": review_required,
-            "review_scope": review_scope,
             "unresolved_items": unresolved or [],
         }
         (artifact / "test-result.json").write_text(
             json.dumps(payload), encoding="utf-8",
         )
 
-    def test_standard_sections_insert_prizmkit_test_after_review(self):
+    def test_canonical_sections_insert_prizmkit_test_after_review(self):
         sections_dir = Path(__file__).resolve().parents[1] / "templates" / "sections"
         sections = assemble_sections(
-            "standard", str(sections_dir), init_done=True,
-            is_resume=False, browser_enabled=False,
+            str(sections_dir), init_done=True, browser_enabled=False,
         )
         names = [name for name, _ in sections]
         rendered = "\n".join(content for _, content in sections)
@@ -461,11 +417,10 @@ class TestScopedFeatureTestGate:
         assert ".prizmkit/test/evidence" not in rendered
         assert "TEST_FAIL" not in rendered
 
-    def test_standard_sections_include_central_checkpoint_helper(self):
+    def test_canonical_sections_include_central_checkpoint_helper(self):
         sections_dir = Path(__file__).resolve().parents[1] / "templates" / "sections"
         sections = assemble_sections(
-            "standard", str(sections_dir), init_done=True,
-            is_resume=False, browser_enabled=False,
+            str(sections_dir), init_done=True, browser_enabled=False,
         )
         rendered = "\n".join(content for _, content in sections)
 
@@ -479,27 +434,82 @@ class TestScopedFeatureTestGate:
         assert "--status completed --stage-result TEST_PASS" in rendered
         assert "--status completed --stage-result RETRO_COMPLETE" in rendered
         assert "--status in_progress --stage-result COMMIT_PENDING" in rendered
-        assert "--status completed --stage-result COMMITTED" in rendered
+        assert "Python runtime" in rendered
+        assert "alone advances this step to `completed/COMMITTED`" in rendered
         assert "Do not hand-edit `workflow-checkpoint.json` directly." in rendered
         assert "authoritative_evidence_paths" not in rendered
 
     def test_checkpoint_orders_test_after_review_with_terminal_artifacts(self):
         sections_dir = Path(__file__).resolve().parents[1] / "templates" / "sections"
         sections = assemble_sections(
-            "standard", str(sections_dir), init_done=True,
-            is_resume=False, browser_enabled=False,
+            str(sections_dir), init_done=True, browser_enabled=False,
         )
         checkpoint = generate_checkpoint_definition(
-            sections, pipeline_mode="standard", workflow_type="feature-pipeline",
+            sections, workflow_type="feature-pipeline",
             item_id="F-123", item_slug="123-scope-test",
             session_id="F-123-session", init_done=True,
         )
         skills = [step["skill"] for step in checkpoint["steps"]]
+        plan_step = next(
+            step for step in checkpoint["steps"]
+            if step["skill"] == "context-snapshot-and-plan"
+        )
+        review_step = next(
+            step for step in checkpoint["steps"]
+            if step["skill"] == "prizmkit-code-review"
+        )
         test_step = next(step for step in checkpoint["steps"] if step["skill"] == "prizmkit-test")
 
         assert skills.index("prizmkit-code-review") < skills.index("prizmkit-test")
+        assert plan_step["required_artifacts"] == [
+            ".prizmkit/specs/123-scope-test/context-snapshot.md",
+            ".prizmkit/specs/123-scope-test/spec.md",
+            ".prizmkit/specs/123-scope-test/plan.md",
+        ]
+        assert review_step["required_artifacts"] == [
+            ".prizmkit/specs/123-scope-test/review-report.md"
+        ]
         assert test_step["required_artifacts"] == self._artifacts()
 
+    def test_merge_rewinds_completed_atomic_stage_without_domain_result(self, tmp_path):
+        existing = {
+            "steps": [
+                {
+                    "id": "S01",
+                    "skill": "context-snapshot-and-plan",
+                    "status": "completed",
+                    "required_artifacts": [],
+                },
+                {
+                    "id": "S02",
+                    "skill": "prizmkit-implement",
+                    "status": "completed",
+                    "stage_result": "IMPLEMENTED",
+                    "required_artifacts": [],
+                },
+            ]
+        }
+        fresh = {
+            "steps": [
+                {
+                    "id": "S01",
+                    "skill": "context-snapshot-and-plan",
+                    "status": "pending",
+                    "required_artifacts": [],
+                },
+                {
+                    "id": "S02",
+                    "skill": "prizmkit-implement",
+                    "status": "pending",
+                    "required_artifacts": [],
+                },
+            ]
+        }
+
+        merged = merge_checkpoint_state(existing, fresh, str(tmp_path))
+
+        assert [step["status"] for step in merged["steps"]] == ["pending", "pending"]
+
     def test_merge_keeps_only_consistent_test_pass_artifacts(self, tmp_path):
         self._write_result(tmp_path)
         existing = {"steps": [{
@@ -536,8 +546,7 @@ class TestScopedFeatureTestGate:
         self._write_result(tmp_path)
         result_path = tmp_path / ".prizmkit/specs/123-scope-test/test-result.json"
         payload = json.loads(result_path.read_text(encoding="utf-8"))
-        payload["review_required"] = True
-        payload["review_scope"] = None
+        payload["caller_route"] = "prizmkit-code-review"
         result_path.write_text(json.dumps(payload), encoding="utf-8")
         existing = {"steps": [{
             "id": "S01", "skill": "prizmkit-test", "status": "completed",
@@ -552,21 +561,32 @@ class TestScopedFeatureTestGate:
 
         assert merged["steps"][0]["status"] == "pending"
 
-    def test_feature_result_routing_stops_test_non_pass_without_outer_repair(self):
-        review = route_feature_repair("REVIEW_NEEDS_FIXES", repair_round=0)
-        needs_fixes = route_feature_repair("TEST_NEEDS_FIXES", repair_round=1)
+    def test_feature_result_routing_owns_bounded_outer_repair(self):
+        review = route_feature_repair(
+            "REVIEW_NEEDS_FIXES", repair_scope="production", repair_round=0,
+        )
+        needs_fixes = route_feature_repair(
+            "TEST_NEEDS_FIXES", repair_scope="production", repair_round=1,
+        )
         blocked = route_feature_repair("TEST_BLOCKED", repair_round=1)
+        passed = route_feature_repair("TEST_PASS", repair_round=1)
 
         assert review["route"] == [
             "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
         ]
         assert review["repair_round"] == 1
-        assert needs_fixes["blocked"] is True
-        assert needs_fixes["route"] == []
-        assert needs_fixes["blocked_reason"] == "test_needs_fixes"
+        assert needs_fixes["blocked"] is False
+        assert needs_fixes["route"] == [
+            "prizmkit-implement", "prizmkit-code-review", "prizmkit-test",
+        ]
+        assert needs_fixes["repair_round"] == 2
         assert blocked["blocked"] is True
         assert blocked["blocked_reason"] == "test_blocked"
         assert blocked["terminal_status"] == "WORKFLOW_BLOCKED"
+        assert passed["route"] == ["family-report", "prizmkit-retrospective"]
+        assert passed["next_stage"] == "family-report"
+        unsafe = route_feature_repair("TEST_NEEDS_FIXES", repair_round=0)
+        assert unsafe["blocked_reason"] == "unsafe_repair_scope"
 
     def test_pipeline_checkpoint_metadata_rejects_legacy_or_mismatched_status(self):
         invalid = [
@@ -627,26 +647,24 @@ class TestHeadlessRecoveryReframing:
         deleted_title = "Session " + "Checkpoint Awareness"
         placeholder = "{{LOG_" + "SIZE_AWARENESS}}"
 
-        for mode in ("lite", "standard", "full"):
-            rendered = "\n".join(
-                section for _name, section in assemble_sections(
-                    mode, str(sections_dir), init_done=True, is_resume=False,
-                    browser_enabled=False,
-                )
+        rendered = "\n".join(
+            section for _name, section in assemble_sections(
+                str(sections_dir), init_done=True, browser_enabled=False,
             )
-            assert deleted_title not in rendered
-            assert placeholder not in rendered
-            assert REMOVED_MAX_LOG_ENV not in rendered
-            assert REMOVED_MAX_LOG_HUMAN not in rendered
-            assert ("209" + "7152") not in rendered
-            assert ("2" + "MB") not in rendered
-            assert "monitor-log" not in rendered
-            assert "COMPACT_NEEDED" not in rendered
-            assert "log-size monitor" not in rendered
-            assert "The log-size monitor is the only allowed" not in rendered
-            assert "Run this command and keep it running" not in rendered
-            assert "Execute `/compact`" not in rendered
-            assert "run `/compact` after" not in rendered
+        )
+        assert deleted_title not in rendered
+        assert placeholder not in rendered
+        assert REMOVED_MAX_LOG_ENV not in rendered
+        assert REMOVED_MAX_LOG_HUMAN not in rendered
+        assert ("209" + "7152") not in rendered
+        assert ("2" + "MB") not in rendered
+        assert "monitor-log" not in rendered
+        assert "COMPACT_NEEDED" not in rendered
+        assert "log-size monitor" not in rendered
+        assert "The log-size monitor is the only allowed" not in rendered
+        assert "Run this command and keep it running" not in rendered
+        assert "Execute `/compact`" not in rendered
+        assert "run `/compact` after" not in rendered
 
 
 class TestDirectOrchestratorImplementationPrompts:
@@ -668,57 +686,44 @@ class TestDirectOrchestratorImplementationPrompts:
         assert (templates_dir / "agent-prompts" / FORBIDDEN_DEV_FIX_PROMPT).exists() is False
         assert (templates_dir / "agent-prompts" / FORBIDDEN_DEV_RESUME_PROMPT).exists() is False
 
-    def test_sections_all_modes_use_direct_orchestrator_implementation(self):
+    def test_canonical_sections_use_direct_orchestrator_implementation(self):
         sections_dir = Path("dev-pipeline/templates/sections").resolve()
 
-        for mode in ("lite", "standard", "full"):
-            rendered = "\n".join(
-                section for _name, section in assemble_sections(
-                    mode, str(sections_dir), init_done=True, is_resume=False,
-                    browser_enabled=False,
-                )
+        rendered = "\n".join(
+            section for _name, section in assemble_sections(
+                str(sections_dir), init_done=True, browser_enabled=False,
             )
+        )
 
-            assert "/prizmkit-implement" in rendered
-            assert "orchestrator) execute" in rendered or "Run `/prizmkit-implement`" in rendered
-            assert "Spawn Dev subagent" not in rendered
-            assert "Spawn Dev agent" not in rendered
-            assert "Implement — Dev" not in rendered
-            assert "{{AGENT_PROMPT_DEV_IMPLEMENT}}" not in rendered
-            assert "dev-implement.md" not in rendered
-            assert FORBIDDEN_REVIEW_DEV_FIX not in rendered
-            assert FORBIDDEN_REVIEWER_DEV_SPAWN not in rendered
-            assert FORBIDDEN_EXPLORE_SUBAGENT not in rendered
-            assert FORBIDDEN_TEST_CMD_PLACEHOLDER not in rendered
-            assert FORBIDDEN_THREE_STRIKE not in rendered
-            assert FORBIDDEN_TWENTY_STEP not in rendered
-            assert "review-report.md" in rendered
-            assert "Final Result" in rendered
-            assert "low=0" not in rendered
-            assert "Reviewer 3" not in rendered
+        assert "/prizmkit-implement" in rendered
+        assert "orchestrator) execute" in rendered or "Run `/prizmkit-implement`" in rendered
+        assert "Spawn Dev subagent" not in rendered
+        assert "Spawn Dev agent" not in rendered
+        assert "Implement — Dev" not in rendered
+        assert "{{AGENT_PROMPT_DEV_IMPLEMENT}}" not in rendered
+        assert "dev-implement.md" not in rendered
+        assert FORBIDDEN_REVIEW_DEV_FIX not in rendered
+        assert FORBIDDEN_REVIEWER_DEV_SPAWN not in rendered
+        assert FORBIDDEN_EXPLORE_SUBAGENT not in rendered
+        assert FORBIDDEN_TEST_CMD_PLACEHOLDER not in rendered
+        assert FORBIDDEN_THREE_STRIKE not in rendered
+        assert FORBIDDEN_TWENTY_STEP not in rendered
+        assert "review-report.md" in rendered
+        assert "Final Result" in rendered
+        assert "low=0" not in rendered
+        assert "Reviewer 3" not in rendered
 
     def test_all_rendered_pipeline_prompts_have_one_main_agent_review_model(self, tmp_path):
-        recovery = _load_recovery_prompt_module()
         prompts = [
-            _render_feature_prompt(tmp_path / "feature-lite", mode="lite"),
-            _render_feature_prompt(tmp_path / "feature-standard", mode="standard"),
-            _render_feature_prompt(tmp_path / "feature-full", mode="full"),
+            _render_feature_prompt(tmp_path / "feature-low", complexity="low"),
+            _render_feature_prompt(tmp_path / "feature-medium", complexity="medium"),
+            _render_feature_prompt(tmp_path / "feature-high", complexity="high"),
             _render_feature_prompt(
-                tmp_path / "feature-tier3",
-                mode="full",
+                tmp_path / "feature-compatibility-template",
                 template="bootstrap-tier3.md",
             ),
             _render_bugfix_prompt(tmp_path / "bugfix"),
             _render_refactor_prompt(tmp_path / "refactor"),
-            recovery.build_bugfix_prompt(
-                {
-                    "workflow_type": "bug-fix-workflow",
-                    "phase": 5,
-                    "phase_name": "Review",
-                    "workflow_data": {"bug_id": "B-001"},
-                },
-                str(tmp_path),
-            ),
         ]
 
         for prompt in prompts:
@@ -824,7 +829,6 @@ class TestContinuationHandoff:
 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"],
     )
 
@@ -854,7 +858,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, user_context=None):
+def _render_feature_prompt(tmp_path, template=None, platform="claude", browser_interaction=None, complexity=None, user_context=None, continuation_mode=None):
     project = tmp_path / "project"
     project.mkdir(parents=True)
     (project / ".prizmkit" / "plans").mkdir(parents=True)
@@ -865,7 +869,7 @@ def _render_feature_prompt(tmp_path, mode="standard", template=None, platform="c
         "id": "F-123",
         "title": "Prompt Cleanup",
         "description": "Clean prompt text",
-        "estimated_complexity": complexity or {"lite": "low", "standard": "medium", "full": "high"}[mode],
+        "estimated_complexity": complexity or "medium",
         "acceptance_criteria": ["Prompts are clean"],
     }
     if user_context is not None:
@@ -886,8 +890,9 @@ def _render_feature_prompt(tmp_path, mode="standard", template=None, platform="c
         "--state-dir", str(project / ".prizmkit" / "state" / "features"),
         "--project-root", str(project),
         "--output", str(output),
-        "--mode", mode,
     ]
+    if continuation_mode:
+        args.extend(["--continuation-mode", continuation_mode])
     if template:
         template_path = Path(template)
         if not template_path.is_absolute():
@@ -1045,12 +1050,11 @@ def _render_refactor_prompt(tmp_path, platform="claude", explicit_platform=None,
     return output.read_text(encoding="utf-8")
 
 
-class TestFeaturePromptUnifiedFullGuidance:
-    def test_default_sections_prompt_uses_full_guidance_for_all_complexities(self, tmp_path):
+class TestFeaturePromptCanonicalGuidance:
+    def test_default_sections_prompt_uses_same_guidance_for_all_complexities(self, tmp_path):
         prompts = {
             complexity: _render_feature_prompt(
                 tmp_path / f"complexity-{complexity}",
-                mode="lite",
                 complexity=complexity,
             )
             for complexity in ("low", "medium", "high", "critical")
@@ -1061,83 +1065,96 @@ class TestFeaturePromptUnifiedFullGuidance:
             assert "## Task Contract" in prompt
             assert "## Workflow Checkpoint System" in prompt
             assert "### Specify + Plan (Full Workflow)" in prompt
-            assert "### Plan Self-Check — Orchestrator Direct" in prompt
+            assert "The injected session validates artifact presence but does not perform a second planning review" in prompt
             assert "### Scoped Feature Test Gate — PrizmKit Test" in prompt
-            assert "## Test Failure Recovery Protocol" in prompt
+            assert "## Test Failure Recovery Protocol" not in prompt
             assert "test-report.md" in prompt
             assert "test-result.json" in prompt
             assert "### Browser Verification — MANDATORY" not in prompt
-            assert "### TERMINAL STOP — Commit Completed" in prompt
+            assert "### Feature Completion Summary" in prompt
+            assert "### Runtime Commit Handoff" in prompt
             assert "# Dev-Pipeline Session Bootstrap — Tier 1" not in prompt
             assert "# Dev-Pipeline Session Bootstrap — Tier 2" not in prompt
             assert "### Phase 0: SKIP (already initialized)" not in prompt
 
-        # The complexity value remains planning metadata, but guidance markers are
-        # the same full/tier3-equivalent composition for every complexity.
-    def test_cli_mode_override_does_not_downgrade_default_sections_guidance(self, tmp_path):
-        prompt = _render_feature_prompt(tmp_path / "mode-lite", mode="lite", complexity="low")
+        # Complexity remains planning metadata; every task gets the same guidance.
+    def test_canonical_guidance_has_no_pipeline_mode_context(self, tmp_path):
+        prompt = _render_feature_prompt(tmp_path / "canonical", complexity="low")
 
         assert "{{PIPELINE_MODE}}" not in prompt
+        assert "compatibility mode" not in prompt
         assert "### Specify + Plan (Full Workflow)" in prompt
-        assert "### Plan Self-Check — Orchestrator Direct" in prompt
+        assert "### Plan Self-Check — Orchestrator Direct" not in prompt
+        assert "does not perform a second planning review" in prompt
         assert "### Phase 0: SKIP (already initialized)" not in prompt
 
     def test_explicit_custom_template_override_still_renders(self, tmp_path):
         custom = tmp_path / "custom-template.md"
         custom.write_text(
-            "CUSTOM {{FEATURE_ID}} {{FEATURE_TITLE}} {{COMPLEXITY}} {{IF_FRESH_START}}fresh{{END_IF_FRESH_START}}",
+            "## Your Mission\nCUSTOM {{FEATURE_ID}} {{FEATURE_TITLE}} {{COMPLEXITY}} "
+            "{{IF_FRESH_START}}fresh{{END_IF_FRESH_START}}\n\n## Execution\ncustom\n\n"
+            "## Failure Capture\ncustom",
             encoding="utf-8",
         )
 
         prompt = _render_feature_prompt(
             tmp_path / "custom-template-project",
-            mode="lite",
             complexity="low",
             template=custom,
         )
 
-        assert prompt == "CUSTOM F-123 Prompt Cleanup low fresh"
+        assert "CUSTOM F-123 Prompt Cleanup low fresh" in prompt
+        checkpoint_path = (
+            tmp_path / "custom-template-project" / "project" / ".prizmkit"
+            / "specs" / "123-prompt-cleanup" / "workflow-checkpoint.json"
+        )
+        checkpoint = json.loads(checkpoint_path.read_text(encoding="utf-8"))
+        assert [step["skill"] for step in checkpoint["steps"]] == [
+            "prizmkit-init",
+            "context-snapshot-and-plan",
+            "prizmkit-implement",
+            "prizmkit-code-review",
+            "prizmkit-test",
+            "completion-summary",
+            "prizmkit-retrospective",
+            "prizmkit-committer",
+        ]
 
-    def test_fallback_without_sections_prefers_tier3_then_bootstrap_prompt(self, tmp_path, monkeypatch):
+    def test_malformed_continuation_addendum_fails_closed(self, tmp_path, monkeypatch):
+        import generate_bootstrap_prompt as gbp
+
+        monkeypatch.setattr(
+            gbp,
+            "append_continuation_handoff",
+            lambda rendered, *_args, **_kwargs: rendered + "\n{{BROKEN_CONTINUATION}}",
+        )
+        try:
+            _render_feature_prompt(
+                tmp_path / "malformed-continuation",
+                continuation_mode="ai_error",
+            )
+        except SystemExit as exc:
+            assert exc.code == 1
+        else:
+            raise AssertionError("malformed continuation Prompt did not fail closed")
+
+    def test_missing_canonical_sections_fails_closed(self, tmp_path, monkeypatch):
         import generate_bootstrap_prompt as gbp
 
         original_isdir = os.path.isdir
-        original_isfile = os.path.isfile
-        requested = []
 
         def fake_isdir(path):
             if str(path).endswith(os.path.join("templates", "sections")):
                 return False
             return original_isdir(path)
 
-        def fake_isfile(path):
-            requested.append(Path(path).name)
-            return original_isfile(path)
-
         monkeypatch.setattr(gbp.os.path, "isdir", fake_isdir)
-        monkeypatch.setattr(gbp.os.path, "isfile", fake_isfile)
-        prompt = _render_feature_prompt(tmp_path / "fallback-tier3", mode="lite", complexity="low")
-
-        assert requested.index("bootstrap-tier3.md") < requested.index("bootstrap-prompt.md") if "bootstrap-prompt.md" in requested else True
-        assert "# Dev-Pipeline Session Bootstrap — Full Guidance" in prompt
-        assert "bootstrap-tier1.md" not in requested
-        assert "bootstrap-tier2.md" not in requested
-
-        requested.clear()
-
-        def fake_isfile_without_tier3(path):
-            requested.append(Path(path).name)
-            if Path(path).name == "bootstrap-tier3.md":
-                return False
-            return original_isfile(path)
-
-        monkeypatch.setattr(gbp.os.path, "isfile", fake_isfile_without_tier3)
-        prompt = _render_feature_prompt(tmp_path / "fallback-bootstrap-prompt", mode="lite", complexity="low")
-
-        assert "bootstrap-tier3.md" in requested
-        assert "bootstrap-tier1.md" not in requested
-        assert "bootstrap-tier2.md" not in requested
-        assert "# Dev-Pipeline Fallback Bootstrap Prompt" in prompt
+        try:
+            _render_feature_prompt(tmp_path / "missing-sections", complexity="low")
+        except SystemExit as exc:
+            assert exc.code == 1
+        else:
+            raise AssertionError("missing canonical sections did not fail closed")
 
 
 class TestBrowserBlockingPromptPolicy:
@@ -1153,10 +1170,16 @@ class TestBrowserBlockingPromptPolicy:
             _render_refactor_prompt(tmp_path / "refactor-browser-blocking", refactor_overrides={"browser_interaction": browser_interaction}),
         ]
 
-        for prompt in prompts:
+        test_markers = (
+            "### Scoped Feature Test Gate — PrizmKit Test",
+            "### Bugfix Test Gate — PrizmKit Test",
+            "### Refactor Test Gate — PrizmKit Test",
+        )
+        for prompt, test_marker in zip(prompts, test_markers, strict=True):
             assert "Browser blocking policy: `true`" in prompt
             assert "stop before commit" in prompt
             assert "Failures do NOT block the commit" not in prompt
+            assert prompt.index("### Browser Verification — MANDATORY") < prompt.index(test_marker)
 
     def test_feature_bugfix_refactor_nonblocking_browser_policy_continues(self, tmp_path):
         browser_interaction = {
@@ -1278,7 +1301,8 @@ class TestBrowserOptInPromptPolicy:
         assert "Manual / Hybrid Verification Gate" 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 "### Runtime Commit Handoff" in prompt
+        assert prompt.index("Manual / Hybrid Verification Gate") < prompt.index("### Bugfix Test Gate")
         assert "status=\"partial\"" not in prompt
 
     def test_recovery_manual_bugfix_uses_same_automatic_policy(self, tmp_path):
@@ -1291,14 +1315,16 @@ class TestBrowserOptInPromptPolicy:
         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
+        assert "### Runtime Commit Handoff" in prompt
 
 
 class TestHeadlessPromptCleanupF033:
     def test_rendered_feature_bugfix_refactor_prompts_are_clean(self, tmp_path):
-        prompts = []
-        for mode in ("lite", "standard", "full"):
-            prompts.append(_render_feature_prompt(tmp_path / mode, mode=mode))
+        prompts = [
+            _render_feature_prompt(tmp_path / "low", complexity="low"),
+            _render_feature_prompt(tmp_path / "medium", complexity="medium"),
+            _render_feature_prompt(tmp_path / "high", complexity="high"),
+        ]
         prompts.append(_render_bugfix_prompt(tmp_path))
         prompts.append(_render_refactor_prompt(tmp_path))
 
@@ -1326,8 +1352,47 @@ class TestHeadlessPromptCleanupF033:
                 assert "which " not in prompt  # no which-command shell glue
             assert "python3 {{INIT_SCRIPT_PATH}}" not in prompt
 
+    def test_all_families_render_shared_manifest_and_precommit_order(self, tmp_path):
+        prompts = {
+            "feature": _render_feature_prompt(tmp_path / "manifest-feature"),
+            "bugfix": _render_bugfix_prompt(tmp_path / "manifest-bugfix"),
+            "refactor": _render_refactor_prompt(tmp_path / "manifest-refactor"),
+        }
+        common_artifacts = (
+            "spec.md",
+            "plan.md",
+            "context-snapshot.md",
+            "review-report.md",
+            "test-report.md",
+            "test-result.json",
+            "retrospective-result.json",
+            "failure-log.md",
+            "workflow-checkpoint.json",
+            "runtime-commit-request.json",
+        )
+        test_markers = {
+            "feature": "### Scoped Feature Test Gate — PrizmKit Test",
+            "bugfix": "### Bugfix Test Gate — PrizmKit Test",
+            "refactor": "### Refactor Test Gate — PrizmKit Test",
+        }
+        for family, prompt in prompts.items():
+            assert "## Requirement Artifact Manifest" in prompt
+            for artifact in common_artifacts:
+                assert artifact in prompt
+            assert "Atomic Skills write only their stage-owned artifacts and domain results" in prompt
+            assert "COMMIT_REQUEST_READY" in prompt
+            assert "workflow_state_path" not in prompt
+            assert "outcome=RETRO_COMPLETE" in prompt
+            assert "Never recreate the testing-local repair loop" in prompt
+            assert prompt.index(test_markers[family]) < prompt.index("### Retrospective")
+            assert prompt.index("### Retrospective") < prompt.index("### Runtime Commit Handoff")
+
+        assert prompts["feature"].index("### Feature Completion Summary") < prompts["feature"].index("### Retrospective")
+        assert prompts["bugfix"].index("### Bug Fix Report") < prompts["bugfix"].index("### Retrospective")
+        assert prompts["refactor"].index("### Refactor Report") < prompts["refactor"].index("### Retrospective")
+
     def test_retained_tier3_template_is_clean_when_rendered(self, tmp_path):
-        prompt = _render_feature_prompt(tmp_path / "bootstrap-tier3.md", mode="full", template="bootstrap-tier3.md")
+        prompt = _render_feature_prompt(tmp_path / "bootstrap-tier3.md", template="bootstrap-tier3.md")
         for forbidden in HEADLESS_FORBIDDEN_PROMPT_STRINGS:
             assert forbidden not in prompt
         assert "prizmkit-test-gate.py" not in prompt
@@ -1357,7 +1422,6 @@ class TestHeadlessPromptCleanupF033:
         ]
         prompt = _render_feature_prompt(
             tmp_path / "browser-bootstrap-tier3.md",
-            mode="full",
             template="bootstrap-tier3.md",
             browser_interaction={"tool": "auto", "verify_steps": ["Open the page"]},
         )
@@ -1380,7 +1444,6 @@ class TestHeadlessPromptCleanupF033:
             bug_id="B-001", session_id="session-1", run_id="run-1",
             retry_count="0", resume_phase="null", state_dir=None,
             output="out.md", project_root=str(bug_project), template=None,
-            mode=None,
         )
         replacements = bugfix_build_replacements(
             args, {"id": "B-001", "title": "Broken"}, {}, str(Path("dev-pipeline/scripts").resolve())
@@ -1403,7 +1466,6 @@ class TestHeadlessPromptCleanupF033:
             bug_id="B-001", session_id="session-1", run_id="run-1",
             retry_count="0", resume_phase="null", state_dir=None,
             output="out.md", project_root=str(bug_project), template=None,
-            mode=None,
         )
         replacements = bugfix_build_replacements(
             args, {"id": "B-001", "title": "Broken"}, {}, str(Path("dev-pipeline/scripts").resolve())
@@ -1455,11 +1517,11 @@ class TestFeatureBootstrapShellExtraction:
         assert "text final-verdict .prizmkit/specs/123-prompt-cleanup/review-report.md" in prompt
 
     def test_rendered_section_feature_prompts_use_runtime_helper_not_extracted_bash(self, tmp_path):
-        for mode in ("lite", "standard", "full"):
+        for complexity in ("low", "medium", "high"):
             prompt = _render_feature_prompt(
-                tmp_path / f"section-{mode}",
-                mode=mode,
-                                browser_interaction={"tool": "auto", "verify_steps": ["Open the page"]},
+                tmp_path / f"section-{complexity}",
+                complexity=complexity,
+                browser_interaction={"tool": "auto", "verify_steps": ["Open the page"]},
             )
 
             self.assert_shell_extracted_operations_removed(prompt)
@@ -1474,7 +1536,6 @@ class TestFeatureBootstrapShellExtraction:
     def test_rendered_retained_tier3_feature_prompt_uses_runtime_helper_not_extracted_bash(self, tmp_path):
         prompt = _render_feature_prompt(
             tmp_path / "legacy-bootstrap-tier3.md",
-            mode="full",
             template="bootstrap-tier3.md",
             browser_interaction={"tool": "playwright-cli", "verify_steps": ["Open the page"]},
         )
@@ -1488,12 +1549,18 @@ class TestFeatureBootstrapShellExtraction:
     def test_retained_tier3_specific_extracted_operations_map_to_helper_commands(self, tmp_path):
         tier3 = _render_feature_prompt(
             tmp_path / "legacy-tier3-helper-map",
-            mode="full",
             template="bootstrap-tier3.md",
         )
         assert "text search . --pattern \"123-prompt-cleanup\" --json" in tier3
         assert "text count .prizmkit/specs/123-prompt-cleanup/plan.md --pattern \"- [ ]\"" in tier3
-        assert "Check if feature already committed by inspecting recent git history" in tier3
+        assert "/prizmkit-committer operation=prepare-runtime-commit" in tier3
+        assert "Require `COMMIT_REQUEST_READY`; this session records `COMMIT_PENDING`" in tier3
+        assert "The Python runtime validates the request" in tier3
+        assert "all `.prizmkit/**` paths are PrizmKit-internal" in tier3
+        assert "project-specific transient data must already be covered by git ignore rules" in tier3.lower()
+        assert "Unknown Git-visible paths are not silently ignored" in tier3
+        assert "git add" not in tier3
+        assert "git commit" not in tier3
 
 
 # ---------------------------------------------------------------------------
@@ -1587,16 +1654,17 @@ class TestDetectTestCommands:
 
 
 
-def test_feature_checkpoint_generation_skips_noop_and_expands_only_finalization_group():
+def test_feature_checkpoint_generation_skips_noop_and_preserves_finalization_order():
     from generate_bootstrap_prompt import generate_checkpoint_definition
 
     checkpoint = generate_checkpoint_definition(
         [
             ("phase0-test-baseline", "noop"),
             ("phase-context-snapshot", "context"),
-            ("phase-commit", "finalize"),
+            ("feature-completion-summary", "summary"),
+            ("phase-commit", "retrospective"),
+            ("runtime-commit-handoff", "commit"),
         ],
-        "standard",
         "feature-pipeline",
         "F-123",
         "123-prompt-cleanup",
@@ -1605,9 +1673,9 @@ def test_feature_checkpoint_generation_skips_noop_and_expands_only_finalization_
 
     assert [step["skill"] for step in checkpoint["steps"]] == [
         "context-snapshot",
+        "completion-summary",
         "prizmkit-retrospective",
         "prizmkit-committer",
-        "completion-summary",
     ]
     assert checkpoint["steps"][0]["depends_on"] is None
     assert checkpoint["steps"][1]["depends_on"] == "S01"