prizmkit 1.0.153 → 1.1.0

package/bin/create-prizmkit.js

@@ -7,6 +7,8 @@
  *   npx prizmkit install .
  *   npx prizmkit install my-project --platform claude --non-interactive
  *   npx prizmkit uninstall . --dry-run
+ *   npx prizmkit upgrade .
+ *   npx prizmkit config . --platform codebuddy
  */
 
 import { readFileSync } from 'fs';
@@ -16,20 +18,21 @@ import { program } from 'commander';
 import { runScaffold } from '../src/index.js';
 import { runClean } from '../src/clean.js';
 import { runUpgrade } from '../src/upgrade.js';
+import { runConfig } from '../src/config.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
 
 program
   .name('prizmkit')
-  .description('PrizmKit project installer/uninstaller')
+  .description('PrizmKit project installer/uninstaller/configurator')
   .version(pkg.version);
 
 program
   .command('install [directory]')
   .description('Install PrizmKit into a project directory')
   .option('--platform <platform>', 'Target platform: codebuddy, claude, or both')
-  .option('--skills <suite>', 'Skill suite: full, core, minimal, or recommended:<type> (frontend/backend/fullstack/library)', 'full')
+  .option('--skills <suite>', 'Skill suite: core, minimal, or recommended:<type> (frontend/backend/fullstack/library)', 'core')
   .option('--team', 'Enable multi-agent team mode (default: true)')
   .option('--no-team', 'Disable multi-agent team mode')
   .option('--pipeline', 'Install dev-pipeline (default: true)')
@@ -77,4 +80,26 @@ program
     }
   });
 
+program
+  .command('config [directory]')
+  .description('Reconfigure existing PrizmKit installation (change platform, skills, rules, options)')
+  .option('--platform <platform>', 'Target platform: codebuddy, claude, or both')
+  .option('--skills <suite>', 'Skill suite: core, minimal, or recommended:<type>')
+  .option('--rules <preset>', 'Rules preset: recommended, minimal, or none')
+  .option('--ai-cli <command>', 'AI CLI executable command (e.g. cbc, claude)')
+  .option('--team', 'Enable multi-agent team mode')
+  .option('--no-team', 'Disable multi-agent team mode')
+  .option('--pipeline', 'Enable dev-pipeline')
+  .option('--no-pipeline', 'Disable dev-pipeline')
+  .option('--non-interactive', 'Skip interactive prompts')
+  .option('--dry-run', 'Show what would change without applying')
+  .action(async (directory = '.', options) => {
+    try {
+      await runConfig(directory, options);
+    } catch (err) {
+      console.error(`\n  Error: ${err.message}\n`);
+      process.exit(1);
+    }
+  });
+
 program.parse();

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.0.153",
-  "bundledAt": "2026-04-02T01:37:22.899Z",
-  "bundledFrom": "6fee0f0"
+  "frameworkVersion": "1.1.0",
+  "bundledAt": "2026-04-02T15:24:18.389Z",
+  "bundledFrom": "f9bf2b6"
 }

package/bundled/adapters/claude/paths.js

@@ -17,7 +17,7 @@ export const GLOBAL_CONFIG_DIR = '.claude';
 export const GLOBAL_AGENTS_DIR = '.claude/agents';
 
 // Command file conventions (equivalent to skills)
-// Note: Actual command files are named <skill-name>.md (e.g. prizmkit-specify.md)
+// Note: Actual command files are named <skill-name>.md 
 // Directory-based commands with assets also use <skill-name>.md inside the directory.
 // Claude Code does not have a native ${COMMAND_DIR} variable equivalent.
 

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

@@ -1,9 +1,16 @@
 #!/usr/bin/env python3
 """Generate a session-specific bootstrap prompt from template and feature list.
 
-Reads a bootstrap-prompt.md template and a feature-list.json, resolves all
-{{PLACEHOLDER}} variables, handles conditional blocks, and writes the rendered
-prompt to the specified output path.
+Supports two modes:
+1. **Section assembly** (preferred): Loads modular section files from
+   templates/sections/ and assembles them based on tier, conditions, and
+   feature configuration. Conditional logic is handled in Python code,
+   not regex-based template blocks.
+2. **Legacy template** (fallback): Reads a monolithic bootstrap-tier{1,2,3}.md
+   template and resolves {{PLACEHOLDER}} variables and {{IF_xxx}} blocks.
+
+The section assembly mode is used when templates/sections/ directory exists.
+Otherwise, falls back to legacy templates for backward compatibility.
 
 Usage:
     python3 generate-bootstrap-prompt.py \
@@ -239,6 +246,24 @@ def get_prev_session_status(state_dir, feature_id):
     return result
 
 
+def _read_project_brief(project_root):
+    """Read project-brief.md from project root if it exists.
+
+    Returns the file content as a string, or a fallback message if absent.
+    This brief is generated by app-planner during interactive planning and
+    captures cross-feature design decisions, business intent, and user
+    preferences that individual feature descriptions may not include.
+    """
+    brief_path = os.path.join(project_root, "project-brief.md")
+    if os.path.isfile(brief_path):
+        try:
+            with open(brief_path, "r", encoding="utf-8") as f:
+                return f.read().strip()
+        except IOError:
+            return "(project-brief.md exists but could not be read)"
+    return "(No project brief available)"
+
+
 def resolve_project_root(script_dir):
     """Resolve project root as the parent directory of dev-pipeline/.
 
@@ -403,6 +428,385 @@ def determine_pipeline_mode(complexity):
     return mapping.get(complexity, "lite")
 
 
+# ============================================================
+# Section Assembly (new modular approach)
+# ============================================================
+
+
+def load_section(sections_dir, name):
+    """Load a section file from the sections directory.
+
+    Returns the file content as a string, or raises FileNotFoundError.
+    """
+    path = os.path.join(sections_dir, name)
+    if not os.path.isfile(path):
+        raise FileNotFoundError("Section file not found: {}".format(path))
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def _tier_header(pipeline_mode):
+    """Return the tier-specific header and mission description."""
+    headers = {
+        "lite": (
+            "# Dev-Pipeline Session Bootstrap — Tier 1 (Single Agent)\n",
+            "**Tier 1 — Single Agent**: You handle everything directly. "
+            "No subagents, no TeamCreate.\n",
+        ),
+        "standard": (
+            "# Dev-Pipeline Session Bootstrap — Tier 2 (Dual Agent)\n",
+            "**Tier 2 — Dual Agent**: You handle context + planning "
+            "directly. Then spawn Dev and Reviewer subagents. Spawn Dev "
+            "and Reviewer agents via the Agent tool.\n",
+        ),
+        "full": (
+            "# Dev-Pipeline Session Bootstrap — Tier 3 (Full Team)\n",
+            "**Tier 3 — Full Team**: For complex features, use the full "
+            "pipeline with Dev + Reviewer agents spawned via the Agent "
+            "tool.\n",
+        ),
+    }
+    return headers.get(pipeline_mode, headers["lite"])
+
+
+def _tier_reminders(pipeline_mode, critic_enabled=False):
+    """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 — do NOT skip the commit phase, "
+        "and 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: you handle everything directly — no subagents needed",
+        ]
+    elif pipeline_mode == "standard":
+        specific = [
+            "- Tier 2: orchestrator builds context+plan, Analyzer checks "
+            "consistency, Dev implements, Reviewer reviews+tests — use "
+            "direct Agent spawn for agents",
+            "- context-snapshot.md is append-only: orchestrator writes "
+            "Sections 1-4, Dev appends Implementation Log, Reviewer "
+            "appends Review Notes",
+            "- Gate checks enforce Implementation Log and Review Notes are "
+            "written before proceeding",
+            "- Do NOT use `run_in_background=true` when spawning subagents",
+            "- On timeout: check snapshot + git diff HEAD → model:lite → "
+            "remaining steps only → max 2 retries per phase → "
+            "orchestrator fallback",
+        ]
+    else:  # full
+        specific = [
+            "- Tier 3: full team — Dev (implementation) → Reviewer "
+            "(review + test) — spawn agents directly via Agent tool",
+            "- context-snapshot.md is append-only: orchestrator writes "
+            "Sections 1-4, Dev appends Implementation Log, Reviewer "
+            "appends Review Notes",
+            "- Gate checks enforce Implementation Log and Review Notes are "
+            "written before proceeding",
+            "- Do NOT use `run_in_background=true` when spawning agents",
+            "- On timeout: check snapshot → model:lite → remaining steps "
+            "only → max 2 retries → orchestrator fallback",
+        ]
+
+    lines = ["## Reminders\n"] + specific + common
+    return "\n".join(lines) + "\n"
+
+
+def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
+                      critic_enabled, browser_enabled):
+    """Assemble prompt sections based on tier and conditions.
+
+    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.
+    """
+    sections = []
+
+    # --- Header ---
+    title, tier_desc = _tier_header(pipeline_mode)
+    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 "
+        "{{FEATURE_ID}}: \"{{FEATURE_TITLE}}\".\n\n"
+        "**CRITICAL**: You MUST NOT exit until ALL work is complete "
+        "and committed."
+    )
+    if pipeline_mode != "lite":
+        mission += (
+            " When you spawn subagents, wait for each to finish "
+            "(run_in_background=false)."
+        )
+    if pipeline_mode == "full":
+        mission += (
+            " Do NOT spawn agents in background and exit — "
+            "that kills the session."
+        )
+    mission += "\n\n" + tier_desc
+    sections.append(("mission", mission))
+
+    # --- 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)))
+
+    # --- Subagent Timeout Recovery (only for agent tiers) ---
+    if pipeline_mode in ("standard", "full"):
+        sections.append(("timeout-recovery",
+                          load_section(sections_dir,
+                                       "subagent-timeout-recovery.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"))
+
+    # --- Resume header (if resuming) ---
+    if is_resume:
+        sections.append(("resume-header",
+                          load_section(sections_dir, "resume-header.md")))
+
+    # --- Failure log check ---
+    sections.append(("failure-log-check",
+                      load_section(sections_dir, "failure-log-check.md")))
+
+    # --- 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")))
+
+    # --- Analyze (only for agent tiers) ---
+    if pipeline_mode == "standard":
+        sections.append(("phase-analyze",
+                          load_section(sections_dir,
+                                       "phase-analyze-agent.md")))
+    elif pipeline_mode == "full":
+        sections.append(("phase-analyze",
+                          load_section(sections_dir,
+                                       "phase-analyze-full.md")))
+
+    # --- Critic: Plan Challenge (only if critic enabled) ---
+    if critic_enabled:
+        if pipeline_mode == "full":
+            sections.append(("phase-critic-plan",
+                              load_section(sections_dir,
+                                           "phase-critic-plan-full.md")))
+        else:
+            sections.append(("phase-critic-plan",
+                              load_section(sections_dir,
+                                           "phase-critic-plan.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")))
+
+    # --- Critic: Code Challenge (only if critic enabled, agent tiers) ---
+    if critic_enabled and pipeline_mode in ("standard", "full"):
+        sections.append(("phase-critic-code",
+                          load_section(sections_dir,
+                                       "phase-critic-code.md")))
+
+    # --- Review (only for agent tiers) ---
+    if pipeline_mode == "full":
+        sections.append(("phase-review",
+                          load_section(sections_dir,
+                                       "phase-review-full.md")))
+    elif pipeline_mode == "standard":
+        sections.append(("phase-review",
+                          load_section(sections_dir,
+                                       "phase-review-agent.md")))
+
+    # --- Browser Verification (conditional) ---
+    if browser_enabled:
+        sections.append(("phase-browser",
+                          load_section(sections_dir,
+                                       "phase-browser-verification.md")))
+
+    # --- Deploy Verification ---
+    sections.append(("phase-deploy",
+                      load_section(sections_dir,
+                                   "phase-deploy-verification.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(("critical-paths",
+                      load_section(sections_dir, cp_file)))
+
+    # --- Failure Capture ---
+    sections.append(("failure-capture",
+                      load_section(sections_dir, "failure-capture.md")))
+
+    # --- Reminders ---
+    sections.append(("reminders",
+                      _tier_reminders(pipeline_mode, critic_enabled)))
+
+    return sections
+
+
+def render_from_sections(sections, replacements):
+    """Join assembled sections and replace all {{PLACEHOLDER}} variables.
+
+    No regex-based conditional block processing needed — all conditions
+    were resolved during assembly.
+    """
+    content = "\n".join(text for _, text in sections)
+
+    # Replace all placeholders
+    for placeholder, value in replacements.items():
+        content = content.replace(placeholder, value)
+
+    return content
+
+
+# ============================================================
+# Rendered output validation (optimization 7)
+# ============================================================
+
+
+def validate_rendered(content):
+    """Validate rendered prompt content for completeness.
+
+    Checks:
+    1. No unreplaced {{PLACEHOLDER}} variables remain
+    2. No unclosed conditional blocks (legacy {{IF_xxx}} tags)
+    3. Required sections present
+
+    Returns (is_valid, warnings, errors) tuple.
+    """
+    warnings = []
+    errors = []
+
+    # Check for unreplaced placeholders (excluding code blocks that may
+    # contain literal double braces like Jinja or Go templates)
+    unreplaced = re.findall(r"\{\{[A-Z][A-Z_0-9]+\}\}", content)
+    if unreplaced:
+        # Deduplicate
+        unique = sorted(set(unreplaced))
+        warnings.append(
+            "Unreplaced placeholders: {}".format(", ".join(unique))
+        )
+
+    # Check for unclosed conditional blocks (legacy)
+    unclosed_if = re.findall(
+        r"\{\{(?:IF|END_IF)_[A-Z_]+\}\}", content
+    )
+    if unclosed_if:
+        unique = sorted(set(unclosed_if))
+        errors.append(
+            "Unclosed conditional blocks: {}".format(", ".join(unique))
+        )
+
+    # Check required sections exist
+    required_markers = [
+        ("## Your Mission", "Mission section"),
+        ("## Execution", "Execution section"),
+        ("## Failure Capture", "Failure Capture Protocol"),
+    ]
+    for marker, label in required_markers:
+        if marker not in content:
+            errors.append("Missing required section: {}".format(label))
+
+    is_valid = len(errors) == 0
+
+    # Log results
+    for w in warnings:
+        LOGGER.warning("VALIDATE: %s", w)
+    for e in errors:
+        LOGGER.error("VALIDATE: %s", e)
+
+    return is_valid, warnings, errors
+
+
 def build_replacements(args, feature, features, global_context, script_dir):
     """Build the full dict of placeholder -> replacement value."""
     project_root = resolve_project_root(script_dir)
@@ -574,6 +978,7 @@ def build_replacements(args, feature, features, global_context, script_dir):
             features, feature
         ),
         "{{GLOBAL_CONTEXT}}": format_global_context(global_context, project_root),
+        "{{PROJECT_BRIEF}}": _read_project_brief(project_root),
         "{{TEAM_CONFIG_PATH}}": team_config_path,
         "{{DEV_SUBAGENT_PATH}}": dev_subagent,
         "{{REVIEWER_SUBAGENT_PATH}}": reviewer_subagent,
@@ -646,87 +1051,104 @@ def main():
 
     # Resolve script directory
     script_dir = os.path.dirname(os.path.abspath(__file__))
+    templates_dir = os.path.join(script_dir, "..", "templates")
+    sections_dir = os.path.join(templates_dir, "sections")
 
-    # Resolve template path
-    if args.template:
-        template_path = args.template
-    else:
-        # Determine pipeline mode to select the right tier template
-        _complexity = None
-        try:
-            _fl, _ = load_json_file(args.feature_list)
-            if _fl:
-                for _f in _fl.get("features", []):
-                    if isinstance(_f, dict) and _f.get("id") == args.feature_id:
-                        _complexity = _f.get("estimated_complexity", "medium")
-                        break
-        except Exception:
-            pass
-        _mode = args.mode or determine_pipeline_mode(_complexity or "medium")
-        _tier_file_map = {
-            "lite": "bootstrap-tier1.md",
-            "standard": "bootstrap-tier2.md",
-            "full": "bootstrap-tier3.md",
-        }
-        _tier_file = _tier_file_map.get(_mode, "bootstrap-tier2.md")
-        _tier_path = os.path.join(script_dir, "..", "templates", _tier_file)
-        # Fall back to legacy monolithic template if tier file doesn't exist
-        if os.path.isfile(_tier_path):
-            template_path = _tier_path
-        else:
-            template_path = os.path.join(
-                script_dir, "..", "templates", "bootstrap-prompt.md"
-            )
-
-    # Load template
-    template_content, err = read_text_file(template_path)
-    if err:
-        emit_failure("Template error: {}".format(err))
-
-    # Load feature list
+    # Load feature list early (needed for both code paths)
     feature_list_data, err = load_json_file(args.feature_list)
     if err:
         emit_failure("Feature list error: {}".format(err))
 
-    # Extract features array
     features = feature_list_data.get("features")
     if not isinstance(features, list):
         emit_failure("Feature list does not contain a 'features' array")
 
-    # Find the target feature
     feature = find_feature(features, args.feature_id)
     if feature is None:
-        emit_failure("Feature '{}' not found in feature list".format(args.feature_id))
+        emit_failure(
+            "Feature '{}' not found in feature list".format(args.feature_id)
+        )
 
-    # Extract global context
     global_context = feature_list_data.get("global_context", {})
     if not isinstance(global_context, dict):
         global_context = {}
 
-    # Build replacements
+    # Build replacements (shared by both code paths)
     replacements, effective_resume, browser_enabled = build_replacements(
         args, feature, features, global_context, script_dir
     )
-
-    # Update RESUME_PHASE in replacements to reflect auto-detection
     replacements["{{RESUME_PHASE}}"] = effective_resume
 
-    # Render the template
-    rendered = render_template(
-        template_content, replacements, effective_resume, browser_enabled
-    )
+    # 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"
+    critic_enabled = replacements.get("{{CRITIC_ENABLED}}", "false") == "true"
+
+    # ── Choose rendering path ──────────────────────────────────────────
+    use_sections = os.path.isdir(sections_dir) and not args.template
+
+    if use_sections:
+        # New modular section assembly (code-level conditional logic)
+        LOGGER.info("Using section assembly from %s", sections_dir)
+        try:
+            sections = assemble_sections(
+                pipeline_mode, sections_dir, init_done, is_resume,
+                critic_enabled, browser_enabled,
+            )
+            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
 
-    # Write the output
+    if not use_sections:
+        # Legacy monolithic template path (backward compatible)
+        if args.template:
+            template_path = args.template
+        else:
+            complexity = feature.get("estimated_complexity", "medium")
+            _mode = args.mode or determine_pipeline_mode(complexity)
+            _tier_file_map = {
+                "lite": "bootstrap-tier1.md",
+                "standard": "bootstrap-tier2.md",
+                "full": "bootstrap-tier3.md",
+            }
+            _tier_file = _tier_file_map.get(_mode, "bootstrap-tier2.md")
+            _tier_path = os.path.join(templates_dir, _tier_file)
+            if os.path.isfile(_tier_path):
+                template_path = _tier_path
+            else:
+                template_path = os.path.join(
+                    templates_dir, "bootstrap-prompt.md"
+                )
+
+        template_content, err = read_text_file(template_path)
+        if err:
+            emit_failure("Template error: {}".format(err))
+
+        rendered = render_template(
+            template_content, replacements, effective_resume, browser_enabled
+        )
+
+    # ── 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
+
+    # ── Write output ───────────────────────────────────────────────────
     err = write_output(args.output, rendered)
     if err:
         emit_failure(err)
 
-    # Success
+    # ── Success JSON ───────────────────────────────────────────────────
     feature_model = feature.get("model", "")
-    pipeline_mode = replacements.get("{{PIPELINE_MODE}}", "lite")
-    critic_enabled = replacements.get("{{CRITIC_ENABLED}}", "false") == "true"
-    # Map mode to agent count for logging
-    # lite=1 (single agent), standard/full=3 (orchestrator + dev + reviewer)
     mode_agent_counts = {"lite": 1, "standard": 3, "full": 3}
     agent_count = mode_agent_counts.get(pipeline_mode, 1)
     critic_count_val = int(replacements.get("{{CRITIC_COUNT}}", "1"))
@@ -739,6 +1161,9 @@ def main():
         "pipeline_mode": pipeline_mode,
         "agent_count": agent_count,
         "critic_enabled": "true" if critic_enabled else "false",
+        "render_mode": "sections" if use_sections else "legacy",
+        "validation_warnings": len(warnings),
+        "validation_errors": len(errors),
     }
     print(json.dumps(output, indent=2, ensure_ascii=False))
     sys.exit(0)