prizmkit 1.1.154 → 1.1.156

package/bundled/dev-pipeline/scripts/generate-bootstrap-prompt.py

@@ -1,18 +1,14 @@
 #!/usr/bin/env python3
 """Generate a session-specific bootstrap prompt from template and feature list.
 
-Supports two modes:
+Supports two rendering paths:
 1. **Section assembly** (preferred): Loads modular section files from
-   templates/sections/ and assembles the unified full/tier3-equivalent
-   feature guidance by default. Conditional logic is handled in Python code,
-   not regex-based template blocks.
-2. **Legacy template** (fallback): Reads the monolithic bootstrap-tier3.md
-   template, falling back to bootstrap-prompt.md when tier3 is unavailable,
-   and resolves {{PLACEHOLDER}} variables and {{IF_xxx}} blocks.
+   templates/sections/ and assembles one canonical Feature lifecycle prompt.
+2. **Explicit custom template**: When `--template` is supplied, resolves its
+   placeholders and legacy conditional blocks for compatibility.
 
-The section assembly mode is used when templates/sections/ directory exists
-and no explicit --template path is supplied. Otherwise, falls back to legacy
-templates for backward compatibility.
+Canonical section generation fails closed when required sections are missing;
+it never falls back to a reduced or stale built-in prompt.
 
 Usage:
     python3 generate-bootstrap-prompt.py \
@@ -33,7 +29,6 @@ from continuation import add_continuation_args, append_continuation_handoff, is_
 from prompt_framework import (
     artifact_exists,
     browser_enabled_from_item,
-    checkpoint_group,
     checkpoint_skip,
     checkpoint_step,
     completed_test_artifacts_valid,
@@ -103,21 +98,19 @@ def parse_args():
         default=None,
         help="AI-visible project root used for rendered prompt paths",
     )
+    parser.add_argument(
+        "--no-checkpoint-write",
+        action="store_true",
+        help="Render and validate a preview without creating or updating checkpoint state",
+    )
     parser.add_argument(
         "--template",
         default=None,
         help=(
-            "Custom template path. Defaults to section-based full feature "
-            "prompt assembly, or {script_dir}/../templates/bootstrap-tier3.md "
-            "when sections are unavailable."
+            "Explicit custom template path. Without it, canonical section "
+            "assembly is required and missing sections fail closed."
         ),
     )
-    parser.add_argument(
-        "--mode",
-        choices=["lite", "standard", "full"],
-        default=None,
-        help="Override pipeline mode (default: auto-detect from complexity)",
-    )
     parser.add_argument(
         "--extract-baselines",
         action="store_true",
@@ -529,33 +522,9 @@ def process_conditional_blocks(content, resume_phase):
     return content
 
 
-def process_mode_blocks(content, pipeline_mode, init_done,
-                        browser_interaction=False, browser_tool="auto"):
-    """Process pipeline mode, init, and browser conditional blocks.
-
-    Keeps the block matching the current mode, removes the others.
-    Handles {{IF_BROWSER_INTERACTION}} / {{END_IF_BROWSER_INTERACTION}} blocks.
-    Handles {{IF_BROWSER_TOOL_PLAYWRIGHT}} / {{IF_BROWSER_TOOL_OPENCLI}} /
-    {{IF_BROWSER_TOOL_AUTO}} blocks (nested inside browser interaction block).
-    """
-    # Handle lite/standard/full blocks
-    modes = ["lite", "standard", "full"]
-
-    for mode in modes:
-        tag_open = "{{{{IF_MODE_{}}}}}".format(mode.upper())
-        tag_close = "{{{{END_IF_MODE_{}}}}}".format(mode.upper())
-
-        if mode == pipeline_mode:
-            # Keep content, remove tags
-            content = content.replace(tag_open + "\n", "")
-            content = content.replace(tag_open, "")
-            content = content.replace(tag_close + "\n", "")
-            content = content.replace(tag_close, "")
-        else:
-            # Remove entire block
-            pattern = re.escape(tag_open) + r".*?" + re.escape(tag_close) + r"\n?"
-            content = re.sub(pattern, "", content, flags=re.DOTALL)
-
+def process_template_blocks(content, init_done, browser_interaction=False,
+                            browser_tool="auto"):
+    """Process init and browser blocks in an explicit custom template."""
     # Init blocks
     if init_done:
         content = re.sub(r"\{\{IF_INIT_DONE\}\}\n?", "", content)
@@ -634,32 +603,6 @@ def detect_existing_artifacts(project_root, feature_slug):
     return result
 
 
-def determine_pipeline_mode(complexity):
-    """Return the unified feature prompt mode for any complexity.
-
-    ``estimated_complexity`` remains input metadata for planning summaries,
-    dependency ordering, and rendered Session Context, but prompt guidance is
-    intentionally no longer tiered by complexity. Every feature task receives
-    the full/tier3-equivalent guidance by default.
-    """
-    return "full"
-
-
-def determine_legacy_template_mode(complexity):
-    """Map complexity for explicit custom template conditional compatibility.
-
-    This is used only when a caller supplies ``--template`` and omits
-    ``--mode``. The normal feature prompt path never uses this mapping.
-    """
-    mapping = {
-        "low": "lite",
-        "medium": "lite",
-        "high": "standard",
-        "critical": "full",
-    }
-    return mapping.get(complexity, "lite")
-
-
 # ============================================================
 # Checkpoint generation
 # ============================================================
@@ -681,6 +624,7 @@ SECTION_TO_SKILL = {
     "phase-specify-plan": checkpoint_step(
         "context-snapshot-and-plan", "Specify & Plan",
         [".prizmkit/specs/{slug}/context-snapshot.md",
+         ".prizmkit/specs/{slug}/spec.md",
          ".prizmkit/specs/{slug}/plan.md"],
     ),
     "phase-plan": checkpoint_step(
@@ -693,14 +637,23 @@ SECTION_TO_SKILL = {
         [".prizmkit/specs/{slug}/test-report.md",
          ".prizmkit/specs/{slug}/test-result.json"],
     ),
-    "phase-review": checkpoint_step("prizmkit-code-review", "Code Review", []),
+    "phase-review": checkpoint_step(
+        "prizmkit-code-review", "Code Review",
+        [".prizmkit/specs/{slug}/review-report.md"],
+    ),
     "phase-browser": checkpoint_step("browser-verification", "Browser Verification", []),
-    "phase-commit": checkpoint_group([
-        ("prizmkit-retrospective", "Retrospective", []),
-        ("prizmkit-committer", "Commit", []),
-        ("completion-summary", "Completion Summary",
-         [".prizmkit/specs/{slug}/completion-summary.json"]),
-    ]),
+    "feature-completion-summary": checkpoint_step(
+        "completion-summary", "Completion Summary",
+        [".prizmkit/specs/{slug}/completion-summary.json"],
+    ),
+    "phase-commit": checkpoint_step(
+        "prizmkit-retrospective", "Retrospective",
+        [".prizmkit/specs/{slug}/retrospective-result.json"],
+    ),
+    "runtime-commit-handoff": checkpoint_step(
+        "prizmkit-committer", "Runtime Commit Handoff",
+        [".prizmkit/specs/{slug}/runtime-commit-request.json"],
+    ),
 }
 
 _COMMIT_STEPS = []
@@ -737,14 +690,31 @@ def _completed_step_artifacts_valid(project_root, skill_key, artifacts):
     return all(artifact_exists(project_root, artifact) for artifact in artifacts)
 
 
-def generate_checkpoint_definition(sections, pipeline_mode, workflow_type,
-                                   item_id, item_slug, session_id,
-                                   init_done=False):
+def _compatibility_checkpoint_sections(init_done=False, browser_enabled=False):
+    """Return the canonical stage skeleton for an explicit custom template."""
+    sections = [
+        ("phase0-test-baseline" if init_done else "phase0-init", ""),
+        ("phase-specify-plan", ""),
+        ("phase-implement", ""),
+        ("phase-review", ""),
+    ]
+    if browser_enabled:
+        sections.append(("phase-browser", ""))
+    sections.extend([
+        ("phase-prizmkit-test", ""),
+        ("feature-completion-summary", ""),
+        ("phase-commit", ""),
+        ("runtime-commit-handoff", ""),
+    ])
+    return sections
+
+
+def generate_checkpoint_definition(sections, workflow_type, item_id, item_slug,
+                                   session_id, init_done=False):
     """Derive checkpoint step definitions from explicit section contracts."""
     return generate_checkpoint_from_sections(
         sections,
         SECTION_TO_SKILL,
-        pipeline_mode,
         workflow_type,
         item_id,
         item_slug,
@@ -814,110 +784,41 @@ def load_active_agent_prompts(templates_dir):
     return prompt_map
 
 
-def _tier_header(pipeline_mode):
-    """Return the tier-specific header and mission description."""
-    headers = {
-        "lite": (
-            "# Dev-Pipeline Session Bootstrap — Unified Full Guidance "
-            "(compatibility mode: lite)\n",
-            "**Unified Full Guidance**: Feature prompts use the "
-            "full/tier3-equivalent sections for every estimated complexity. "
-            "The lite label remains metadata only for compatibility.\n",
-        ),
-        "standard": (
-            "# Dev-Pipeline Session Bootstrap — Unified Full Guidance "
-            "(compatibility mode: standard)\n",
-            "**Unified Full Guidance**: Feature prompts use the "
-            "full/tier3-equivalent sections for every estimated complexity. "
-            "The standard label remains metadata only for compatibility.\n",
-        ),
-        "full": (
-            "# Dev-Pipeline Session Bootstrap — Full Guidance\n",
-            "**Full Guidance**: Follow the active skills and runtime contracts "
-            "for context, planning, implementation, review, testing, recovery, "
-            "and commit.\n",
-        ),
-    }
-    return headers.get(pipeline_mode, headers["lite"])
-
-
-def _tier_reminders(pipeline_mode):
-    """Return tier-specific reminder text."""
-    common = [
-        "- MANDATORY skills: `/prizmkit-retrospective`, `/prizmkit-committer` "
-        "— never skip these",
-        "- Build context-snapshot.md FIRST; use it throughout instead of "
-        "re-reading files",
-        "- `/prizmkit-committer` is mandatory after all required gates pass — "
-        "do NOT replace it with manual git commit commands",
-        "- Do NOT run `git add`/`git commit` during implementation phases — "
-        "all changes are committed once in the commit phase",
-        "- If any files remain after the commit, amend the existing commit — "
-        "do NOT create a follow-up commit",
-        "- When staging files, always use explicit file names — NEVER use "
-        "`git add -A` or `git add .`",
-    ]
-
-    if pipeline_mode == "lite":
-        specific = [
-            "- Tier 1: compatibility label only; feature prompts now render "
-            "the unified full/tier3-equivalent guidance by default",
-        ]
-    elif pipeline_mode == "standard":
-        specific = [
-            "- Tier 2: compatibility label only; feature prompts now render "
-            "the unified full/tier3-equivalent guidance by default",
-            "- context-snapshot.md is the implementation knowledge base; "
-            "Code Review writes only review-report.md",
-            "- Gate checks require the Implementation Log (with Gate Evidence) "
-            "and a valid review-report.md Final Result before proceeding",
-            "- Follow the active skills and runtime contracts for execution "
-            "units, review ownership, timeout, and recovery",
-        ]
-    else:  # full
-        specific = [
-            "- Tier 3: follow the active skills and runtime contracts for "
-            "execution topology and review ownership",
-            "- context-snapshot.md is the implementation knowledge base; "
-            "Code Review writes only review-report.md",
-            "- Gate checks require the Implementation Log and a valid "
-            "review-report.md Final Result before proceeding",
-            "- Review execution outside the owning skill contract is forbidden",
-            "- Do not infer execution-unit permissions or retry behavior from "
-            "this prompt; use the owning skill/runtime contract",
-            "- NEVER delete, modify, or touch any file under `.prizmkit/state/` "
-            "— those are pipeline runtime files managed by the runner",
-            "- NEVER run `rm -rf`, `git clean`, or destructive filesystem "
-            "cleanup during the feature session",
-            "- On execution-unit timeout: preserve the active checkout and "
-            "artifacts and follow the owning contract's recovery or downgrade "
-            "path",
-        ]
-
-    lines = ["## Reminders\n"] + specific + common
-    return "\n".join(lines) + "\n"
+def _canonical_header():
+    """Return the single canonical Feature guidance header."""
+    return (
+        "# Dev-Pipeline Session Bootstrap — Canonical Guidance\n",
+        "**Canonical Guidance**: Follow the active skills and runtime contracts "
+        "for context, planning, implementation, review, testing, recovery, "
+        "retrospective, and runtime-owned commit execution.\n",
+    )
 
 
-def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
-                      browser_enabled, retry_count=0, browser_tool="auto"):
-    """Assemble prompt sections based on tier and conditions.
+def _canonical_reminders():
+    """Return family-neutral reminders for the canonical guidance profile."""
+    lines = [
+        "## Reminders\n",
+        "- Every formal lifecycle stage is mandatory; only configured optional verification may be skipped with evidence.",
+        "- Use context-snapshot.md for navigation and handoff, then inspect current source and diffs when correctness requires it.",
+        "- Code Review writes only review-report.md and `/prizmkit-test` exclusively owns the test repair loop and terminal test artifacts.",
+        "- Atomic Skills return stage-local results only; this injected session owns checkpoint mapping and routing.",
+        "- Do not run git add, commit, amend, merge, push, reset, clean, or destructive filesystem cleanup.",
+        "- `/prizmkit-committer` prepares the exact runtime commit request; the Python runtime executes and verifies the local commit.",
+        "- On execution-unit timeout, preserve the active checkout and artifacts and follow the owning skill's continuation or downgrade contract.",
+    ]
+    return "\n".join(lines) + "\n"
 
-    Uses Python code for conditional logic instead of regex-based
-    template blocks. Each section is loaded from a separate .md file.
 
-    Returns a list of (section_name, content) tuples in order.
-    """
+def assemble_sections(sections_dir, init_done, browser_enabled,
+                      browser_tool="auto"):
+    """Assemble the canonical prompt sections and configured optional gates."""
     sections = []
 
-    # --- Header ---
-    title, tier_desc = _tier_header(pipeline_mode)
+    title, guidance_desc = _canonical_header()
     sections.append(("header", title))
-
-    # --- Session Context ---
     sections.append(("session-context",
                       load_section(sections_dir, "session-context.md")))
 
-    # --- Mission ---
     mission = (
         "## Your Mission\n\n"
         "You are the **session orchestrator**. Implement Feature "
@@ -925,180 +826,69 @@ def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
         "**CRITICAL**: Do not exit while recoverable work remains. "
         "If a required gate is blocked or the workflow cannot safely "
         "continue, record the blocker and stop with a truthful blocked "
-        "status; do not claim success or commit an incomplete change."
-    )
-    if pipeline_mode != "lite":
-        mission += (
-            " Follow the active skill and runtime contracts for any "
-            "execution units they create, including completion, timeout, "
-            "resume, and failure handling."
-        )
-    mission += "\n\n" + tier_desc
+        "status; do not claim success or commit an incomplete change. "
+        "Follow the active skill and runtime contracts for any execution "
+        "units they create, including completion, timeout, resume, and "
+        "failure handling.\n\n"
+    ) + guidance_desc
     sections.append(("mission", mission))
 
-    # --- Task Contract: single source of current scope and gates ---
     sections.append(("task-contract",
                       load_section(sections_dir, "task-contract.md")))
-
-    # --- Feature Context (XML-wrapped, optimization 3) ---
     sections.append(("feature-context",
                       load_section(sections_dir, "feature-context.md")))
-
-    # --- Context Budget Rules ---
     sections.append(("context-budget-rules",
                       load_section(sections_dir, "context-budget-rules.md")))
-
-    # --- Directory Convention (tier-specific) ---
-    if pipeline_mode == "lite":
-        dc_file = "directory-convention-lite.md"
-    elif pipeline_mode == "standard":
-        dc_file = "directory-convention-agent.md"
-    else:
-        dc_file = "directory-convention-full.md"
     sections.append(("directory-convention",
-                      load_section(sections_dir, dc_file)))
+                      load_section(sections_dir, "directory-convention-full.md")))
+    sections.append(("timeout-recovery",
+                      load_section(sections_dir, "subagent-timeout-recovery.md")))
+    sections.append(("artifact-manifest",
+                      load_section(sections_dir, "artifact-manifest.md")))
 
-    # --- Execution-unit timeout recovery ---
-    if pipeline_mode in ("standard", "full"):
-        sections.append(("timeout-recovery",
-                          load_section(sections_dir,
-                                       "subagent-timeout-recovery.md")))
-
-    # --- Checkpoint System ---
     checkpoint_section_path = os.path.join(sections_dir, "checkpoint-system.md")
     if os.path.isfile(checkpoint_section_path):
         sections.append(("checkpoint-system",
                           load_section(sections_dir, "checkpoint-system.md")))
 
-    # --- Execution header ---
     sections.append(("execution-header", "---\n\n## Execution\n"))
-
-    # --- Phase 0: Init or Test Baseline ---
     if not init_done:
         sections.append(("phase0-init",
                           load_section(sections_dir, "phase0-init.md")))
     else:
-        if pipeline_mode in ("standard", "full"):
-            sections.append(("phase0-test-baseline",
-                              load_section(sections_dir,
-                                           "phase0-test-baseline.md")))
-        else:
-            sections.append(("phase0-skip",
-                              "### Phase 0: SKIP (already initialized)\n"))
-
-    # --- Context Snapshot + Plan (tier-dependent) ---
-    if pipeline_mode == "full":
-        # Tier 3: full specify + plan workflow
-        sections.append(("phase-specify-plan",
-                          load_section(sections_dir,
-                                       "phase-specify-plan-full.md")))
-    else:
-        # Tier 1 & 2: separate context snapshot + plan
-        snapshot_base = load_section(sections_dir,
-                                     "phase-context-snapshot-base.md")
-        if pipeline_mode == "lite":
-            snapshot_suffix = load_section(
-                sections_dir, "phase-context-snapshot-lite-suffix.md")
-        else:
-            snapshot_suffix = load_section(
-                sections_dir, "phase-context-snapshot-agent-suffix.md")
-        sections.append(("phase-context-snapshot",
-                          snapshot_base + "\n" + snapshot_suffix))
-
-        if pipeline_mode == "lite":
-            sections.append(("phase-plan",
-                              load_section(sections_dir,
-                                           "phase-plan-lite.md")))
-        else:
-            sections.append(("phase-plan",
-                              load_section(sections_dir,
-                                           "phase-plan-agent.md")))
-
-
-    # --- Implement (tier-dependent) ---
-    if pipeline_mode == "lite":
-        sections.append(("phase-implement",
-                          load_section(sections_dir,
-                                       "phase-implement-lite.md")))
-    elif pipeline_mode == "full":
-        sections.append(("phase-implement",
-                          load_section(sections_dir,
-                                       "phase-implement-full.md")))
-    else:
-        sections.append(("phase-implement",
-                          load_section(sections_dir,
-                                       "phase-implement-agent.md")))
-
-    # Verification Gates are included in Task Contract. Keep AC in one place so
-    # background context and implementation prompts cannot redefine scope.
-    # --- Review ---
-    if pipeline_mode == "full":
-        sections.append(("phase-review",
-                          load_section(sections_dir,
-                                       "phase-review-full.md")))
-    else:
-        sections.append(("phase-review",
-                          load_section(sections_dir,
-                                       "phase-review-agent.md")))
-
-    # --- Test Failure Recovery Protocol (tier-specific) ---
-    if pipeline_mode == "lite":
-        sections.append(("test-failure-recovery",
-                          load_section(sections_dir,
-                                       "test-failure-recovery-lite.md")))
-    else:
-        sections.append(("test-failure-recovery",
-                          load_section(sections_dir,
-                                       "test-failure-recovery-agent.md")))
+        sections.append(("phase0-test-baseline",
+                          load_section(sections_dir, "phase0-test-baseline.md")))
 
-    # --- Scoped Feature Test Gate ---
-    sections.append(("phase-prizmkit-test",
-                      load_section(sections_dir,
-                                   "phase-prizmkit-test.md")))
+    sections.append(("phase-specify-plan",
+                      load_section(sections_dir, "phase-specify-plan-full.md")))
+    sections.append(("phase-implement",
+                      load_section(sections_dir, "phase-implement-full.md")))
+    sections.append(("phase-review",
+                      load_section(sections_dir, "phase-review-full.md")))
 
-    # --- Browser Verification (conditional, tool-aware) ---
     if browser_enabled:
         if browser_tool == "opencli":
             browser_section_file = "phase-browser-verification-opencli.md"
         elif browser_tool == "playwright-cli":
             browser_section_file = "phase-browser-verification.md"
         else:
-            # "auto" or unknown → let AI choose at runtime
             browser_section_file = "phase-browser-verification-auto.md"
         sections.append(("phase-browser",
-                          load_section(sections_dir,
-                                       browser_section_file)))
+                          load_section(sections_dir, browser_section_file)))
 
-    # --- Headless commit authorization ---
-    sections.append(("headless-commit-authorization",
-                      load_section(sections_dir, "headless-commit-authorization.md")))
-
-    # --- Commit (tier-dependent) ---
-    if pipeline_mode == "full":
-        sections.append(("phase-commit", load_section(sections_dir, "phase-commit-full.md")))
-    else:
-        sections.append(("phase-commit",
-                          load_section(sections_dir,
-                                       "phase-commit.md")))
-
-    # --- Critical Paths ---
-    if pipeline_mode == "lite":
-        cp_file = "critical-paths-lite.md"
-    elif pipeline_mode == "full":
-        cp_file = "critical-paths-full.md"
-    else:
-        cp_file = "critical-paths-agent.md"
+    sections.append(("phase-prizmkit-test",
+                      load_section(sections_dir, "phase-prizmkit-test.md")))
+    sections.append(("feature-completion-summary",
+                      load_section(sections_dir, "feature-completion-summary.md")))
+    sections.append(("phase-commit",
+                      load_section(sections_dir, "phase-commit-full.md")))
+    sections.append(("runtime-commit-handoff",
+                      load_section(sections_dir, "runtime-commit-handoff.md")))
     sections.append(("critical-paths",
-                      load_section(sections_dir, cp_file)))
-
-    # --- Failure Capture ---
+                      load_section(sections_dir, "critical-paths-full.md")))
     sections.append(("failure-capture",
                       load_section(sections_dir, "failure-capture.md")))
-
-    # --- Reminders ---
-    sections.append(("reminders",
-                      _tier_reminders(pipeline_mode)))
-
+    sections.append(("reminders", _canonical_reminders()))
     return sections
 
 
@@ -1208,16 +998,6 @@ def build_replacements(args, feature, features, global_context, script_dir):
         "estimated_complexity",
         feature.get("complexity", "medium"),
     )
-    if args.template:
-        pipeline_mode = args.mode or determine_legacy_template_mode(complexity)
-    else:
-        pipeline_mode = determine_pipeline_mode(complexity)
-    if args.mode and args.mode != pipeline_mode and not args.template:
-        LOGGER.info(
-            "Ignoring feature prompt --mode=%s; unified full guidance is used",
-            args.mode,
-        )
-
     # Auto-detect resume: if all planning artifacts exist and resume_phase
     # is "null" (fresh start), skip to Phase 6
     effective_resume = args.resume_phase
@@ -1277,10 +1057,14 @@ def build_replacements(args, feature, features, global_context, script_dir):
         "{{PROJECT_ROOT}}": project_root,
         "{{FEATURE_SLUG}}": feature_slug,
         "{{ARTIFACT_DIR}}": os.path.join(".prizmkit", "specs", feature_slug),
+        "{{FAMILY_ARTIFACTS}}": "├── completion-summary.json",
         "{{CHECKPOINT_PATH}}": os.path.join(
             ".prizmkit", "specs", feature_slug, "workflow-checkpoint.json",
         ),
-        "{{PIPELINE_MODE}}": pipeline_mode,
+        "{{CHECKPOINT_SYSTEM}}": load_section(
+            os.path.join(os.path.dirname(__file__), "..", "templates", "sections"),
+            "checkpoint-system.md",
+        ),
         "{{COMPLEXITY}}": complexity,
         "{{INIT_DONE}}": "true" if init_done else "false",
         "{{HAS_SPEC}}": "true" if artifacts["has_spec"] else "false",
@@ -1314,10 +1098,10 @@ def render_template(template_content, replacements, resume_phase,
     content = process_conditional_blocks(template_content, resume_phase)
 
     # Step 2: Process mode, init, and browser conditional blocks
-    pipeline_mode = replacements.get("{{PIPELINE_MODE}}", "standard")
     init_done = replacements.get("{{INIT_DONE}}", "false") == "true"
-    content = process_mode_blocks(content, pipeline_mode, init_done,
-                                  browser_enabled, browser_tool)
+    content = process_template_blocks(
+        content, init_done, browser_enabled, browser_tool,
+    )
 
     # Step 3: Replace all {{PLACEHOLDER}} variables (two passes for nested
     # agent prompt templates that may contain their own placeholders)
@@ -1389,7 +1173,6 @@ def main():
     replacements.update(agent_prompt_replacements)
 
     # Extract state needed for assembly
-    pipeline_mode = replacements.get("{{PIPELINE_MODE}}", "lite")
     init_done = replacements.get("{{INIT_DONE}}", "false") == "true"
     is_resume = effective_resume != "null"
     # ── Choose rendering path ──────────────────────────────────────────
@@ -1400,31 +1183,17 @@ def main():
         LOGGER.info("Using section assembly from %s", sections_dir)
         try:
             sections = assemble_sections(
-                pipeline_mode, sections_dir, init_done, is_resume,
-                browser_enabled,
-                retry_count=int(args.retry_count),
+                sections_dir, init_done, browser_enabled,
                 browser_tool=browser_tool,
             )
             rendered = render_from_sections(sections, replacements)
         except FileNotFoundError as exc:
-            LOGGER.warning(
-                "Section assembly failed (%s), falling back to legacy "
-                "template", exc,
-            )
-            use_sections = False
+            emit_failure("Section assembly failed: {}".format(exc))
 
     if not use_sections:
-        # Legacy monolithic template path (backward compatible)
-        if args.template:
-            template_path = args.template
-        else:
-            tier3_path = os.path.join(templates_dir, "bootstrap-tier3.md")
-            if os.path.isfile(tier3_path):
-                template_path = tier3_path
-            else:
-                template_path = os.path.join(
-                    templates_dir, "bootstrap-prompt.md"
-                )
+        if not args.template:
+            emit_failure("Canonical prompt sections are unavailable")
+        template_path = args.template
 
         template_content, err = read_text_file(template_path)
         if err:
@@ -1438,11 +1207,7 @@ def main():
     # ── Validate rendered output ───────────────────────────────────────
     is_valid, warnings, errors = validate_rendered(rendered)
     if not is_valid:
-        LOGGER.error(
-            "Rendered prompt failed validation: %s",
-            "; ".join(errors),
-        )
-        # Continue anyway — a partially valid prompt is better than none
+        emit_failure("Rendered prompt failed validation: {}".format("; ".join(errors)))
 
     # ── Write output ───────────────────────────────────────────────────
     err = write_output(args.output, rendered)
@@ -1455,10 +1220,13 @@ def main():
     checkpoint_path = ""
     checkpoint = {}
 
-    if use_sections and feature_slug:
+    if feature_slug:
+        checkpoint_sections = (
+            sections if use_sections
+            else _compatibility_checkpoint_sections(init_done, browser_enabled)
+        )
         checkpoint = generate_checkpoint_definition(
-            sections=sections,
-            pipeline_mode=pipeline_mode,
+            sections=checkpoint_sections,
             workflow_type="feature-pipeline",
             item_id=args.feature_id,
             item_slug=feature_slug,
@@ -1469,10 +1237,11 @@ def main():
         checkpoint_dir = os.path.join(
             project_root, ".prizmkit", "specs", feature_slug,
         )
-        os.makedirs(checkpoint_dir, exist_ok=True)
         checkpoint_path = os.path.join(
             checkpoint_dir, "workflow-checkpoint.json",
         )
+        if not args.no_checkpoint_write:
+            os.makedirs(checkpoint_dir, exist_ok=True)
 
         # Pipeline metadata remains separate from the skill workflow-state contract.
         checkpoint["feature_state"] = feature_checkpoint_metadata(
@@ -1485,7 +1254,7 @@ def main():
         )
 
         # On resume, merge existing completed state (with artifact validation)
-        if (is_resume or is_continuation(args)) and os.path.exists(checkpoint_path):
+        if not args.no_checkpoint_write and (is_resume or is_continuation(args)) and os.path.exists(checkpoint_path):
             try:
                 with open(checkpoint_path, "r", encoding="utf-8") as f:
                     existing = json.load(f)
@@ -1500,15 +1269,25 @@ def main():
                     exc,
                 )
 
-        with open(checkpoint_path, "w", encoding="utf-8") as f:
-            json.dump(checkpoint, f, indent=2, ensure_ascii=False)
-        LOGGER.info("Wrote checkpoint to %s", checkpoint_path)
+        if not args.no_checkpoint_write:
+            with open(checkpoint_path, "w", encoding="utf-8") as f:
+                json.dump(checkpoint, f, indent=2, ensure_ascii=False)
+            LOGGER.info("Wrote checkpoint to %s", checkpoint_path)
 
     if is_continuation(args):
         rendered = append_continuation_handoff(
             rendered, args, project_root, args.task_type, args.feature_id,
             feature_slug, checkpoint,
         )
+        final_valid, final_warnings, final_errors = validate_rendered(rendered)
+        if not final_valid:
+            emit_failure(
+                "Rendered continuation prompt failed validation: {}".format(
+                    "; ".join(final_errors)
+                )
+            )
+        warnings.extend(final_warnings)
+        errors.extend(final_errors)
         err = write_output(args.output, rendered)
         if err:
             emit_failure(err)
@@ -1519,11 +1298,10 @@ def main():
         "success": True,
         "output_path": os.path.abspath(args.output),
         "model": feature_model,
-        "pipeline_mode": pipeline_mode,
         "render_mode": "sections" if use_sections else "legacy",
         "validation_warnings": len(warnings),
         "validation_errors": len(errors),
-        "checkpoint_path": checkpoint_path,
+        "checkpoint_path": "" if args.no_checkpoint_write else checkpoint_path,
     }
     print(json.dumps(output, indent=2, ensure_ascii=False))
     sys.exit(0)