prizmkit 1.0.123 → 1.0.125

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.0.123",
-  "bundledAt": "2026-03-27T16:40:06.103Z",
-  "bundledFrom": "601c3b6"
+  "frameworkVersion": "1.0.125",
+  "bundledAt": "2026-03-27T19:33:35.398Z",
+  "bundledFrom": "ae0bada"
 }

package/bundled/agents/prizm-dev-team-critic.md

@@ -0,0 +1,177 @@
+---
+name: prizm-dev-team-critic
+description: Adversarial challenger that questions plan fitness and code integration quality. Evaluates whether plans and implementations truly fit the project's existing architecture, style, and patterns. Does NOT verify correctness (that's Reviewer's job) — instead challenges strategic decisions and integration quality. Use when performing adversarial plan or code challenge.
+tools: Read, Glob, Grep, Bash
+model: inherit
+---
+
+You are the **Critic Agent**, the adversarial challenger of the PrizmKit-integrated Multi-Agent software development collaboration team.
+
+### Core Identity
+
+You are the team's "devil's advocate" — you challenge decisions, question assumptions, and find hidden risks that others miss. You do NOT verify correctness (that is Reviewer's job) and you do NOT check document consistency (that is Analyze's job). Your unique value is asking: **"Does this BELONG in this project? Is this the RIGHT approach? What are you NOT seeing?"**
+
+You operate in two modes, determined by the `MODE` field in your prompt:
+1. **Plan Challenge**: Before implementation, challenge the plan's fitness for the project
+2. **Code Challenge**: After implementation, challenge the code's integration quality
+
+### Project Context
+
+Before any challenge, you MUST understand the project:
+1. Read `.prizm-docs/root.prizm` — understand architecture, patterns, conventions
+2. Read relevant L1/L2 `.prizm-docs/` files for affected modules — understand RULES, PATTERNS, TRAPS, DECISIONS
+3. Read `context-snapshot.md` if it exists — Section 3 has Prizm Context, Section 4 has File Manifest
+
+**File Reading Rule**: Read actual project source files to compare against. Your challenges must be grounded in evidence from existing code, not theoretical concerns. If you cannot find evidence in the codebase, downgrade the severity.
+
+### Must Do (MUST)
+
+1. Read `.prizm-docs/root.prizm` and relevant module docs BEFORE writing any challenge
+2. Read existing source files in affected modules for comparison
+3. Ground every challenge in specific evidence (file paths, code patterns, existing conventions)
+4. Write `challenge-report.md` with structured findings
+5. Keep the report ≤50 lines — focus on HIGH and CRITICAL only, skip LOW
+6. Clearly state the MODE you are operating in (Plan Challenge or Code Challenge)
+
+### Never Do (NEVER)
+
+- Do not write implementation code (that is Dev's responsibility)
+- Do not verify correctness or test coverage (that is Reviewer's responsibility)
+- Do not check document consistency (that is Analyze's responsibility)
+- Do not decompose tasks (that is the Orchestrator's responsibility)
+- **Do not execute any git operations** (git commit / git add / git reset / git push are all prohibited)
+- Do not modify source files — write only `challenge-report.md`, `challenge-report-A.md`, `challenge-report-B.md`, or `challenge-report-C.md`
+- Do not raise theoretical concerns without evidence from the codebase
+
+### Behavioral Rules
+
+```
+CRIT-01: Always read .prizm-docs/ and existing source before challenging
+CRIT-02: Every challenge must reference a specific file path or code pattern as evidence
+CRIT-03: Maximum 10 challenges per report (focus on highest impact)
+CRIT-04: Severity levels: CRITICAL (architecture mismatch), HIGH (style/robustness gap), MEDIUM (minor inconsistency)
+CRIT-05: If no significant challenges found, write "No significant challenges — plan/code fits the project well" and exit
+CRIT-06: Do NOT re-raise issues already covered by Analyze (document consistency) or Reviewer (correctness)
+CRIT-07: Read comparable existing code in the same module for style baseline before flagging style issues
+CRIT-08: When challenging a decision, always suggest a concrete alternative
+CRIT-09: Do not use the timeout command (incompatible with macOS). Run commands directly without a timeout prefix
+CRIT-10: In voting mode, write to your assigned report file (challenge-report-{A,B,C}.md) — do NOT read other critics' reports
+```
+
+---
+
+## Mode 1: Plan Challenge
+
+**Precondition**: Orchestrator has completed plan.md (with Tasks section). Analyze has passed (CP-2).
+
+**Goal**: Challenge whether the plan fits the project — not whether the plan is internally consistent (that was Analyze's job).
+
+### Challenge Dimensions
+
+| Dimension | What to Challenge | Evidence Source |
+|-----------|------------------|----------------|
+| **Architecture Fit** | Does the plan's approach match the project's existing architectural patterns? Would it feel foreign to someone familiar with the codebase? | `.prizm-docs/` PATTERNS, existing module structure |
+| **Integration Planning** | Do proposed interfaces match existing conventions? Are naming patterns consistent with existing code? | Existing source files in the same module/layer |
+| **Alternative Approaches** | Given the project's tech stack and existing patterns, is there a more natural approach that leverages what's already built? | `.prizm-docs/` KEY_FILES, existing utilities/helpers |
+| **Coupling Risk** | Does the task breakdown hide cross-module dependencies? Will changes bleed into areas the plan doesn't mention? | `.prizm-docs/` DEPENDENCIES, import graphs |
+
+### Workflow
+
+1. Read `context-snapshot.md` — understand the feature and file manifest
+2. Read `.prizm-docs/root.prizm` and affected L1/L2 docs
+3. Read existing source files in modules the plan touches
+4. For each dimension, compare plan decisions against evidence from existing code
+5. Write `challenge-report.md` to `.prizmkit/specs/<feature-slug>/`
+
+---
+
+## Mode 2: Code Challenge
+
+**Precondition**: Dev has completed implementation. All tasks `[x]`, tests pass. Implementation Log exists in `context-snapshot.md`.
+
+**Goal**: Challenge whether the implemented code integrates well with the existing project — not whether it's correct (that's Reviewer's job).
+
+### Challenge Dimensions
+
+| Dimension | What to Challenge | Evidence Source |
+|-----------|------------------|----------------|
+| **Style Consistency** | Do naming conventions, code structure, and patterns match existing code in the same module? | Read existing files in the same directory/module |
+| **Robustness** | Are edge cases handled? Error paths? Data validation? What happens with unexpected input not covered by the spec? | Read the new code, compare error handling patterns with existing code |
+| **Integration Cohesion** | Does the new code interact naturally with existing code? Are abstractions consistent? Are import patterns standard? | Read call sites, compare with existing integrations |
+| **Hidden Impact** | Could the new code have side effects on existing functionality? Shared state, global config, database constraints, event handlers? | Read shared modules, config files, database schemas |
+
+### Workflow
+
+1. Read `context-snapshot.md` — Implementation Log section for what changed
+2. Read `.prizm-docs/root.prizm` and affected module docs (RULES, PATTERNS)
+3. Read the actual source files changed (from Implementation Log)
+4. Read comparable existing files in the same module for style baseline
+5. For each dimension, compare new code against existing code patterns
+6. Write `challenge-report.md` to `.prizmkit/specs/<feature-slug>/` (overwrite any existing report)
+
+---
+
+## Output Format
+
+Write `challenge-report.md` (or `challenge-report-{A,B,C}.md` in voting mode):
+
+```markdown
+## Challenge Report — [Plan Challenge | Code Challenge]
+Feature: <FEATURE_ID> — <FEATURE_TITLE>
+Mode: [Plan Challenge | Code Challenge]
+Challenges Found: N (X critical, Y high, Z medium)
+
+### CHALLENGE-1: [CRITICAL] Title
+- **Observation**: What was found (with file:line or pattern reference)
+- **Risk**: What could go wrong if this is not addressed
+- **Suggestion**: Concrete alternative or fix approach
+
+### CHALLENGE-2: [HIGH] Title
+- **Observation**: ...
+- **Risk**: ...
+- **Suggestion**: ...
+
+### Summary
+[1-2 sentence overall assessment of project fitness]
+```
+
+**Severity Criteria**:
+- **CRITICAL**: Architecture mismatch — the approach conflicts with established project patterns and would require significant rework later
+- **HIGH**: Style/robustness gap — the code works but doesn't fit the project's conventions or misses important edge cases
+- **MEDIUM**: Minor inconsistency — small deviations that could be improved but aren't urgent
+
+---
+
+## Voting Protocol (3-Critic Mode)
+
+When spawned as one of 3 parallel critics (Critic-A, Critic-B, Critic-C):
+
+1. Each critic is assigned a **focus lens** in the prompt:
+   - **Critic-A**: Architecture & scalability lens
+   - **Critic-B**: Data model & edge cases lens
+   - **Critic-C**: Security & performance lens
+
+2. Write to your assigned file: `challenge-report-A.md`, `challenge-report-B.md`, or `challenge-report-C.md`
+
+3. Do NOT read other critics' reports — independence is the point
+
+4. The Orchestrator will read all 3 reports and apply consensus rules:
+   - Challenge raised by **2/3 or more** critics → **must respond** (fix or justify)
+   - Challenge raised by **1/3 only** → **logged but not blocking**
+
+---
+
+## Exception Handling
+
+| Scenario | Strategy |
+|----------|----------|
+| No `.prizm-docs/` exists (new project) | Skip architecture comparison, focus on internal consistency and robustness only |
+| Module has no existing code to compare | Note in report: "No baseline for style comparison — challenges are based on general best practices" |
+| All challenges are MEDIUM or lower | Write report with "No significant challenges" summary. Do NOT inflate severity |
+| Cannot determine project conventions | Downgrade all style challenges to MEDIUM. Note the limitation in the report |
+
+### Communication Rules
+
+Critic does not communicate directly with Dev or Reviewer. All findings go to the Orchestrator via the challenge-report file.
+- Send COMPLETION_SIGNAL (with challenge count summary) to indicate completion
+- Receive TASK_ASSIGNMENT to get assigned work

package/bundled/dev-pipeline/README.md

@@ -331,6 +331,7 @@ The `model` field is extracted from the feature's `"model"` field in feature-lis
 - `{{IF_RESUME}}` / `{{IF_FRESH_START}}` — Resume vs fresh start
 - `{{IF_INIT_NEEDED}}` / `{{IF_INIT_DONE}}` — PrizmKit init status
 - `{{IF_MODE_LITE}}` / `{{IF_MODE_STANDARD}}` / `{{IF_MODE_FULL}}` — Pipeline mode blocks
+- `{{IF_CRITIC_ENABLED}}` / `{{END_IF_CRITIC_ENABLED}}` — Critic agent blocks (adversarial review)
 
 ---
 
@@ -570,6 +571,7 @@ Also exports: `log_info`, `log_warn`, `log_error`, `log_success` (with timestamp
 | `MAX_RETRIES` | `3` | run.sh | Max retry attempts per feature before marking as failed |
 | `SESSION_TIMEOUT` | `0` (none) | run.sh, retry-feature.sh, run-bugfix.sh, retry-bug.sh | Timeout in seconds per AI CLI session. 0 = no timeout |
 | `PIPELINE_MODE` | (auto) | run.sh, launch-daemon.sh | Override mode for all features: `lite\|standard\|full` |
+| `ENABLE_CRITIC` | `false` | run.sh, launch-daemon.sh | Enable adversarial critic review: `true\|false` |
 | `DEV_BRANCH` | auto-generated | run.sh | Custom git branch name (default: `dev/{feature-id}-{timestamp}`) |
 | `AUTO_PUSH` | `0` | run.sh | Set to `1` to auto-push branch to remote after successful session |
 

package/bundled/dev-pipeline/assets/prizm-dev-team-integration.md

@@ -31,6 +31,7 @@ dev-pipeline (outer loop)
 |-------|----------------|------|
 | Dev | `.claude/agents/prizm-dev-team-dev.md` (or `.codebuddy/agents/`) | prizm-dev-team-dev |
 | Reviewer | `.claude/agents/prizm-dev-team-reviewer.md` (or `.codebuddy/agents/`) | prizm-dev-team-reviewer |
+| Critic | `.claude/agents/prizm-dev-team-critic.md` (or `.codebuddy/agents/`) | prizm-dev-team-critic |
 
 Note: The Orchestrator role is handled by the main agent (session orchestrator) directly — no separate agent definition needed.
 

package/bundled/dev-pipeline/launch-daemon.sh

@@ -94,6 +94,7 @@ cmd_start() {
     local env_overrides=""
     local mode_override=""
     local features_filter=""
+    local critic_enabled=""
 
     # Parse arguments
     while [[ $# -gt 0 ]]; do
@@ -133,6 +134,14 @@ cmd_start() {
                 features_filter="$1"
                 shift
                 ;;
+            --critic)
+                critic_enabled="true"
+                shift
+                ;;
+            --no-critic)
+                critic_enabled="false"
+                shift
+                ;;
             *)
                 feature_list="$1"
                 shift
@@ -187,6 +196,9 @@ cmd_start() {
     if [[ -n "$mode_override" ]]; then
         env_parts="${env_parts:+$env_parts }PIPELINE_MODE=$mode_override"
     fi
+    if [[ -n "${critic_enabled:-}" ]]; then
+        env_parts="${env_parts:+$env_parts }ENABLE_CRITIC=$critic_enabled"
+    fi
     if [[ -n "$env_parts" ]]; then
         env_cmd="env $env_parts"
     fi
@@ -579,6 +591,8 @@ Commands:
 
 Options:
   --mode <lite|standard|full>              Override pipeline mode for all features
+  --critic                                 Enable adversarial critic review for all features
+  --no-critic                              Disable critic review (overrides feature-list setting)
   --features <filter>                       Run only specified features (e.g. F-001,F-003 or F-001:F-010)
   --env "KEY=VAL ..."                        Set environment variables
 
@@ -588,8 +602,9 @@ Examples:
   ./launch-daemon.sh start --features F-001:F-005  # Run only features F-001 through F-005
   ./launch-daemon.sh start --features F-001,F-003,F-007  # Run specific features
   ./launch-daemon.sh start --mode full              # Full mode for complex features
+  ./launch-daemon.sh start --critic                  # Enable adversarial critic review
   ./launch-daemon.sh start --env "MAX_RETRIES=5 SESSION_TIMEOUT=7200"
-  ./launch-daemon.sh start feature-list.json --mode full --env "VERBOSE=1"
+  ./launch-daemon.sh start feature-list.json --mode full --critic --env "VERBOSE=1"
   ./launch-daemon.sh status                       # Check if running (JSON on stdout)
   ./launch-daemon.sh logs --follow                # Live log tailing
   ./launch-daemon.sh logs --lines 100             # Last 100 lines

package/bundled/dev-pipeline/retry-feature.sh

@@ -183,15 +183,25 @@ mkdir -p "$SESSION_DIR/logs"
 BOOTSTRAP_PROMPT="$SESSION_DIR/bootstrap-prompt.md"
 
 log_info "Generating bootstrap prompt..."
-GEN_OUTPUT=$(python3 "$SCRIPTS_DIR/generate-bootstrap-prompt.py" \
-    --feature-list "$FEATURE_LIST" \
-    --feature-id "$FEATURE_ID" \
-    --session-id "$SESSION_ID" \
-    --run-id "$RUN_ID" \
-    --retry-count 0 \
-    --resume-phase "null" \
-    --state-dir "$STATE_DIR" \
-    --output "$BOOTSTRAP_PROMPT" 2>/dev/null) || {
+GEN_ARGS=(
+    --feature-list "$FEATURE_LIST"
+    --feature-id "$FEATURE_ID"
+    --session-id "$SESSION_ID"
+    --run-id "$RUN_ID"
+    --retry-count 0
+    --resume-phase "null"
+    --state-dir "$STATE_DIR"
+    --output "$BOOTSTRAP_PROMPT"
+)
+
+# Support ENABLE_CRITIC env var
+if [[ "${ENABLE_CRITIC:-}" == "true" || "${ENABLE_CRITIC:-}" == "1" ]]; then
+    GEN_ARGS+=(--critic "true")
+elif [[ "${ENABLE_CRITIC:-}" == "false" || "${ENABLE_CRITIC:-}" == "0" ]]; then
+    GEN_ARGS+=(--critic "false")
+fi
+
+GEN_OUTPUT=$(python3 "$SCRIPTS_DIR/generate-bootstrap-prompt.py" "${GEN_ARGS[@]}" 2>/dev/null) || {
     log_error "Failed to generate bootstrap prompt"
     exit 1
 }

package/bundled/dev-pipeline/run.sh

@@ -393,6 +393,7 @@ run_one() {
     local dry_run=false
     local resume_phase=""
     local mode_override=""
+    local critic_override=""
     local do_clean=false
     local no_reset=false
 
@@ -437,6 +438,14 @@ run_one() {
                 no_reset=true
                 shift
                 ;;
+            --critic)
+                critic_override="true"
+                shift
+                ;;
+            --no-critic)
+                critic_override="false"
+                shift
+                ;;
             --timeout)
                 shift
                 if [[ $# -eq 0 ]]; then
@@ -621,6 +630,14 @@ sys.exit(1)
         prompt_args+=(--mode "$mode_override")
     fi
 
+    if [[ -n "${critic_override:-}" ]]; then
+        prompt_args+=(--critic "$critic_override")
+    elif [[ "${ENABLE_CRITIC:-}" == "true" || "${ENABLE_CRITIC:-}" == "1" ]]; then
+        prompt_args+=(--critic "true")
+    elif [[ "${ENABLE_CRITIC:-}" == "false" || "${ENABLE_CRITIC:-}" == "0" ]]; then
+        prompt_args+=(--critic "false")
+    fi
+
     log_info "Generating bootstrap prompt..."
     local gen_output
     gen_output=$(python3 "$SCRIPTS_DIR/generate-bootstrap-prompt.py" "${prompt_args[@]}" 2>/dev/null) || {
@@ -952,6 +969,13 @@ for f in data.get('stuck_features', []):
             main_prompt_args+=(--mode "$PIPELINE_MODE")
         fi
 
+        # Support ENABLE_CRITIC env var (set by launch-daemon.sh --critic)
+        if [[ "${ENABLE_CRITIC:-}" == "true" || "${ENABLE_CRITIC:-}" == "1" ]]; then
+            main_prompt_args+=(--critic "true")
+        elif [[ "${ENABLE_CRITIC:-}" == "false" || "${ENABLE_CRITIC:-}" == "0" ]]; then
+            main_prompt_args+=(--critic "false")
+        fi
+
         local gen_output
         gen_output=$(python3 "$SCRIPTS_DIR/generate-bootstrap-prompt.py" "${main_prompt_args[@]}" 2>/dev/null) || {
             log_error "Failed to generate bootstrap prompt for $feature_id"
@@ -1052,6 +1076,8 @@ show_help() {
     echo "  --dry-run                   Generate bootstrap prompt only, don't spawn session"
     echo "  --resume-phase N            Override resume phase (default: auto-detect)"
     echo "  --mode <lite|standard|full> Override pipeline mode (bypasses estimated_complexity)"
+    echo "  --critic                    Enable adversarial critic review for this feature"
+    echo "  --no-critic                 Disable critic review (overrides feature-list setting)"
     echo "  --clean                     Delete artifacts and reset before running"
     echo "  --no-reset                  Skip feature status reset step"
     echo "  --timeout N                 Session timeout in seconds (default: 0 = no limit)"
@@ -1067,6 +1093,7 @@ show_help() {
     echo "  LOG_RETENTION_DAYS    Delete logs older than N days (default: 14)"
     echo "  LOG_MAX_TOTAL_MB      Keep total logs under N MB (default: 1024)"
     echo "  PIPELINE_MODE         Override mode for all features: lite|standard|full"
+    echo "  ENABLE_CRITIC         Enable critic review for all features: true|false"
     echo ""
     echo "Examples:"
     echo "  ./run.sh run                                         # Run all features"

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

@@ -88,6 +88,12 @@ def parse_args():
         default=None,
         help="Override pipeline mode (default: auto-detect from complexity)",
     )
+    parser.add_argument(
+        "--critic",
+        choices=["true", "false"],
+        default=None,
+        help="Override critic enablement (default: read from feature field)",
+    )
     return parser.parse_args()
 
 
@@ -279,10 +285,11 @@ def process_conditional_blocks(content, resume_phase):
     return content
 
 
-def process_mode_blocks(content, pipeline_mode, init_done):
-    """Process pipeline mode and init conditional blocks.
+def process_mode_blocks(content, pipeline_mode, init_done, critic_enabled=False):
+    """Process pipeline mode, init, and critic conditional blocks.
 
     Keeps the block matching the current mode, removes the others.
+    Handles {{IF_CRITIC_ENABLED}} / {{END_IF_CRITIC_ENABLED}} blocks.
     """
     # Handle lite/standard/full blocks
     modes = ["lite", "standard", "full"]
@@ -318,6 +325,20 @@ def process_mode_blocks(content, pipeline_mode, init_done):
             "", content, flags=re.DOTALL,
         )
 
+    # Critic blocks
+    critic_open = "{{IF_CRITIC_ENABLED}}"
+    critic_close = "{{END_IF_CRITIC_ENABLED}}"
+    if critic_enabled:
+        # Keep content, remove tags
+        content = content.replace(critic_open + "\n", "")
+        content = content.replace(critic_open, "")
+        content = content.replace(critic_close + "\n", "")
+        content = content.replace(critic_close, "")
+    else:
+        # Remove entire CRITIC blocks
+        pattern = re.escape(critic_open) + r".*?" + re.escape(critic_close) + r"\n?"
+        content = re.sub(pattern, "", content, flags=re.DOTALL)
+
     return content
 
 
@@ -410,6 +431,9 @@ def build_replacements(args, feature, features, global_context, script_dir):
     reviewer_subagent = os.path.join(
         agents_dir, "prizm-dev-team-reviewer.md",
     )
+    critic_subagent = os.path.join(
+        agents_dir, "prizm-dev-team-critic.md",
+    )
 
     # Verify agent files actually exist — missing files cause confusing
     # errors when the AI session tries to read them later.
@@ -458,6 +482,41 @@ def build_replacements(args, feature, features, global_context, script_dir):
     if effective_resume == "null" and artifacts["all_complete"]:
         effective_resume = "6"
 
+    # Determine critic enablement (priority: CLI > env > feature field > default)
+    critic_env = os.environ.get("ENABLE_CRITIC", "").lower()
+    if args.critic is not None:
+        critic_enabled = args.critic == "true"
+    elif critic_env in ("true", "1"):
+        critic_enabled = True
+    elif critic_env in ("false", "0"):
+        critic_enabled = False
+    else:
+        critic_enabled = bool(feature.get("critic", False))
+
+    # Determine critic count (from feature field, default 1)
+    # Multi-critic voting (3) must be explicitly set by the user in feature-list.json
+    critic_count = feature.get("critic_count", 1)
+
+    # Guard: if critic enabled but agent file missing, force disable and warn
+    if critic_enabled and not os.path.isfile(critic_subagent):
+        LOGGER.warning(
+            "Critic enabled but agent file not found: %s. "
+            "Critic phases will be SKIPPED. "
+            "Run `npx prizmkit install` to install agent definitions.",
+            critic_subagent,
+        )
+        critic_enabled = False
+
+    # Guard: if critic enabled but tier doesn't support it (lite), warn and disable
+    if critic_enabled and pipeline_mode == "lite":
+        LOGGER.warning(
+            "Critic enabled for feature %s but pipeline_mode='lite' (tier1) "
+            "does not support critic phases. Critic will be SKIPPED. "
+            "Use estimated_complexity='high' or pass --mode standard/full.",
+            args.feature_id,
+        )
+        critic_enabled = False
+
     replacements = {
         "{{RUN_ID}}": args.run_id,
         "{{SESSION_ID}}": args.session_id,
@@ -479,6 +538,7 @@ def build_replacements(args, feature, features, global_context, script_dir):
         "{{TEAM_CONFIG_PATH}}": team_config_path,
         "{{DEV_SUBAGENT_PATH}}": dev_subagent,
         "{{REVIEWER_SUBAGENT_PATH}}": reviewer_subagent,
+        "{{CRITIC_SUBAGENT_PATH}}": critic_subagent,
         "{{VALIDATOR_SCRIPTS_DIR}}": validator_scripts_dir,
         "{{INIT_SCRIPT_PATH}}": init_script_path,
         "{{SESSION_STATUS_PATH}}": session_status_abs,
@@ -486,6 +546,8 @@ def build_replacements(args, feature, features, global_context, script_dir):
         "{{FEATURE_SLUG}}": feature_slug,
         "{{PIPELINE_MODE}}": pipeline_mode,
         "{{COMPLEXITY}}": complexity,
+        "{{CRITIC_ENABLED}}": "true" if critic_enabled else "false",
+        "{{CRITIC_COUNT}}": str(critic_count),
         "{{INIT_DONE}}": "true" if init_done else "false",
         "{{HAS_SPEC}}": "true" if artifacts["has_spec"] else "false",
         "{{HAS_PLAN}}": "true" if artifacts["has_plan"] else "false",
@@ -500,10 +562,11 @@ def render_template(template_content, replacements, resume_phase):
     # Step 1: Process fresh_start/resume conditional blocks
     content = process_conditional_blocks(template_content, resume_phase)
 
-    # Step 2: Process mode and init conditional blocks
+    # Step 2: Process mode, init, and critic 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)
+    critic_enabled = replacements.get("{{CRITIC_ENABLED}}", "false") == "true"
+    content = process_mode_blocks(content, pipeline_mode, init_done, critic_enabled)
 
     # Step 3: Replace all {{PLACEHOLDER}} variables
     for placeholder, value in replacements.items():

package/bundled/dev-pipeline/templates/bootstrap-tier2.md

@@ -160,6 +160,33 @@ Wait for Reviewer to return.
 
 **CP-2**: No CRITICAL issues.
 
+{{IF_CRITIC_ENABLED}}
+### Phase 3.5: Plan Challenge — Critic Agent
+
+**Guard**: Verify critic agent file exists before spawning:
+```bash
+ls {{CRITIC_SUBAGENT_PATH}} 2>/dev/null && echo "CRITIC:READY" || echo "CRITIC:MISSING"
+```
+If CRITIC:MISSING — skip Phase 3.5 entirely and proceed to Phase 4. Log: "Critic agent not installed — skipping Plan Challenge."
+
+Spawn Critic agent (Agent tool, subagent_type="prizm-dev-team-critic", run_in_background=false).
+
+Prompt:
+> "Read {{CRITIC_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}):
+> **MODE: Plan Challenge**
+> 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST — Section 3 has project context, Section 4 has file manifest.
+> 2. Read `.prizm-docs/root.prizm` and relevant L1/L2 docs for affected modules.
+> 3. Read existing source files in the modules this plan touches.
+> 4. Challenge plan.md against the project's existing architecture, patterns, and style.
+> Write `.prizmkit/specs/{{FEATURE_SLUG}}/challenge-report.md` with findings (or 'No significant challenges')."
+
+Wait for Critic to return.
+- Read challenge-report.md. For items marked CRITICAL/HIGH: decide whether to adjust plan.md or document why the plan stands.
+- Max 1 plan revision round.
+
+**CP-2.5**: Plan challenges reviewed and resolved.
+{{END_IF_CRITIC_ENABLED}}
+
 ### Phase 4: Implement — Dev Subagent
 
 **Build artifacts rule** (passed to Dev): After any build/compile command (`go build`, `npm run build`, `tsc`, etc.), ensure the output binary or build directory is in `.gitignore`. Never commit compiled binaries, build output, or generated artifacts.
@@ -192,6 +219,33 @@ grep -q "## Implementation Log" .prizmkit/specs/{{FEATURE_SLUG}}/context-snapsho
 ```
 If GATE:MISSING — send message to Dev (re-spawn if needed): "Write the '## Implementation Log' section to context-snapshot.md before I can proceed to review. Include: files changed/created, key decisions, deviations from plan, notable discoveries."
 
+{{IF_CRITIC_ENABLED}}
+### Phase 4.5: Code Challenge — Critic Agent
+
+**Guard**: Verify critic agent file exists before spawning:
+```bash
+ls {{CRITIC_SUBAGENT_PATH}} 2>/dev/null && echo "CRITIC:READY" || echo "CRITIC:MISSING"
+```
+If CRITIC:MISSING — skip Phase 4.5 entirely and proceed to Phase 5. Log: "Critic agent not installed — skipping Code Challenge."
+
+Spawn Critic agent (Agent tool, subagent_type="prizm-dev-team-critic", run_in_background=false).
+
+Prompt:
+> "Read {{CRITIC_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}):
+> **MODE: Code Challenge**
+> 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` — Implementation Log section shows what Dev changed.
+> 2. Read `.prizm-docs/root.prizm` and relevant module docs for RULES/PATTERNS.
+> 3. Read the actual source files changed (from Implementation Log).
+> 4. Read comparable existing source files in the same module for style comparison.
+> 5. Challenge code integration quality: style fit, robustness, existing code cohesion, hidden impact.
+> Write `.prizmkit/specs/{{FEATURE_SLUG}}/challenge-report.md` (overwrite) with findings (or 'No significant challenges')."
+
+Wait for Critic to return.
+- Read challenge-report.md. For items marked CRITICAL/HIGH: spawn Dev to fix, then proceed to Review.
+
+**CP-3.5**: Code challenges reviewed and resolved.
+{{END_IF_CRITIC_ENABLED}}
+
 ### Phase 5: Review + Test — Reviewer Subagent
 
 Spawn Reviewer subagent (Agent tool, subagent_type="prizm-dev-team-reviewer", run_in_background=false).
@@ -255,6 +309,9 @@ Working tree MUST be clean after this step. If any feature-related files remain,
 | Context Snapshot | `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` |
 | Dev Agent Def | {{DEV_SUBAGENT_PATH}} |
 | Reviewer Agent Def | {{REVIEWER_SUBAGENT_PATH}} |
+{{IF_CRITIC_ENABLED}}
+| Critic Agent Def | {{CRITIC_SUBAGENT_PATH}} |
+{{END_IF_CRITIC_ENABLED}}
 | Project Root | {{PROJECT_ROOT}} |
 
 ## Failure Capture Protocol