prizmkit 1.0.123 → 1.0.124

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.0.123",
-  "bundledAt": "2026-03-27T16:40:06.103Z",
-  "bundledFrom": "601c3b6"
+  "frameworkVersion": "1.0.124",
+  "bundledAt": "2026-03-27T18:24:06.959Z",
+  "bundledFrom": "a7ba656"
 }

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

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

@@ -212,6 +212,54 @@ Wait for Reviewer to return.
 
 **CP-2**: No CRITICAL issues.
 
+{{IF_CRITIC_ENABLED}}
+### Phase 3.5: Plan Challenge — Critic Agent(s)
+
+**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."
+
+**Choose ONE path based on `{{CRITIC_COUNT}}`:**
+
+**If {{CRITIC_COUNT}} = 1 → Single Critic** (skip to CP-2.5 after this):
+
+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')."
+
+**If {{CRITIC_COUNT}} = 3 → Multi-Critic Voting** (skip Single Critic above):
+
+Spawn 3 Critic agents sequentially (each with run_in_background=false), each with a different focus lens:
+
+Critic-A prompt (append to base prompt above):
+> "**Focus Lens: Architecture & Scalability.** Prioritize: architectural pattern fit, scalability implications, over-engineering risks, component boundary design.
+> Write `.prizmkit/specs/{{FEATURE_SLUG}}/challenge-report-A.md`."
+
+Critic-B prompt (append to base prompt above):
+> "**Focus Lens: Data Model & Edge Cases.** Prioritize: data model design fit, entity relationships, edge cases in business logic, missing boundary conditions.
+> Write `.prizmkit/specs/{{FEATURE_SLUG}}/challenge-report-B.md`."
+
+Critic-C prompt (append to base prompt above):
+> "**Focus Lens: Security & Performance.** Prioritize: security attack surface, authentication/authorization gaps, performance bottlenecks, resource leaks.
+> Write `.prizmkit/specs/{{FEATURE_SLUG}}/challenge-report-C.md`."
+
+After all critics return, read all 3 reports:
+- Challenge raised by **2/3 or more** critics → **must respond** (adjust plan or justify why not)
+- Challenge raised by **1/3 only** → logged in context-snapshot but not blocking
+- Max 1 plan revision round.
+
+**CP-2.5**: Plan challenges reviewed and resolved.
+{{END_IF_CRITIC_ENABLED}}
+
 ### Phase 4: Implement — Dev Agent
 
 **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.
@@ -263,6 +311,33 @@ Wait for Dev to return. **If Dev times out before all tasks are `[x]`**:
 
 All tasks `[x]`, tests pass.
 
+{{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 Agent
 
 Spawn Reviewer agent (Agent tool, subagent_type="prizm-dev-team-reviewer", run_in_background=false).
@@ -346,6 +421,9 @@ Working tree MUST be clean after this step. If any feature-related files remain,
 | Team Config | `{{TEAM_CONFIG_PATH}}` |
 | 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}} |
 | Feature List Path | {{FEATURE_LIST_PATH}} |
 

package/bundled/dev-pipeline/templates/feature-list-schema.json

@@ -100,6 +100,16 @@
           "model": {
             "type": "string",
             "description": "AI model ID for this feature. Overrides $MODEL env var."
+          },
+          "critic": {
+            "type": "boolean",
+            "description": "Enable adversarial critic review for this feature. Default: false.",
+            "default": false
+          },
+          "critic_count": {
+            "type": "integer",
+            "description": "Number of parallel critic agents. 1 = single critic, 3 = multi-critic voting. Default: 1.",
+            "enum": [1, 3]
           }
         }
       }

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

@@ -191,3 +191,21 @@ class TestProcessModeBlocks:
         tpl = "{{IF_INIT_NEEDED}}\nneed init\n{{END_IF_INIT_NEEDED}}"
         result = process_mode_blocks(tpl, "standard", init_done=False)
         assert "need init" in result
+
+    def test_critic_enabled_keeps_critic_block(self):
+        tpl = "before\n{{IF_CRITIC_ENABLED}}\ncritic content\n{{END_IF_CRITIC_ENABLED}}\nafter"
+        result = process_mode_blocks(tpl, "standard", init_done=True, critic_enabled=True)
+        assert "critic content" in result
+        assert "IF_CRITIC_ENABLED" not in result
+
+    def test_critic_disabled_removes_critic_block(self):
+        tpl = "before\n{{IF_CRITIC_ENABLED}}\ncritic content\n{{END_IF_CRITIC_ENABLED}}\nafter"
+        result = process_mode_blocks(tpl, "standard", init_done=True, critic_enabled=False)
+        assert "critic content" not in result
+        assert "before" in result
+        assert "after" in result
+
+    def test_critic_default_is_disabled(self):
+        tpl = "{{IF_CRITIC_ENABLED}}critic{{END_IF_CRITIC_ENABLED}}"
+        result = process_mode_blocks(tpl, "standard", init_done=True)
+        assert "critic" not in result

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.123",
+  "version": "1.0.124",
   "skills": {
     "prizm-kit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",

package/bundled/skills/app-planner/SKILL.md

@@ -137,8 +137,9 @@ Execute the selected scenario workflow in conversation mode with mandatory check
 4. refine descriptions and acceptance criteria
 5. verify DAG/order/priorities
 6. build or append `feature-list.json`
-7. validate and fix until pass
-8. summarize final feature table
+7. ask whether to enable adversarial critic review for high/critical features
+8. validate and fix until pass
+9. summarize final feature table
 
 ### Checkpoints (Mandatory Gates)
 
@@ -150,8 +151,9 @@ Checkpoints catch cascading errors early — skipping one means the next phase b
 | **CP-AP-1** | Vision Summary | Goal/users/differentiators confirmed by user | 1-2 |
 | **CP-AP-2** | Feature Proposals | Feature set with titles+deps identified (pre-validation) | 3-5 |
 | **CP-AP-3** | DAG Validity | No cycles, dependencies resolved (validation dry-run) | 6 |
-| **CP-AP-4** | `feature-list.json` Generated | Schema validates, all required keys present | 6 |
-| **CP-AP-5** | Final Validation Pass | Python script returns `"valid": true` with zero errors | 7 |
+| **CP-AP-3.5** | Critic Decision | User decided on critic review for high/critical features | 7 |
+| **CP-AP-4** | `feature-list.json` Generated | Schema validates, all required keys present | 6-7 |
+| **CP-AP-5** | Final Validation Pass | Python script returns `"valid": true` with zero errors | 8 |
 
 **Resume Detection**: See §Resume Support for checkpoint-based resumption.
 
@@ -252,6 +254,8 @@ AI: "Ready to proceed to dev-pipeline."
 - new items default `status: "pending"`
 - English feature titles for stable slug generation
 - `model` field is optional — omitting it means the pipeline uses $MODEL env or CLI default
+- `critic` field is optional (boolean). If user requested adversarial critic review during planning, set `"critic": true` for relevant features. Omitting defaults to `false`.
+- `critic_count` field is optional (integer, 1 or 3). If omitted, defaults to 1 (single critic). Set to 3 for multi-critic voting mode on critical features.
 - **descriptions must be implementation-ready** — minimum 15 words (error), recommended 30/50/80 words for low/medium/high complexity (warning). See `planning-guide.md` §4 for what to include.
 
 ## Next-Step Execution Policy (after planning)

package/bundled/skills/app-planner/scripts/validate-and-generate.py

@@ -320,6 +320,18 @@ def validate_feature_list(data, planning_mode="new"):
 
         # -- Sub-features --
         subs = feat.get("sub_features")
+
+        # -- Critic fields (optional but validated if present) --
+        critic = feat.get("critic")
+        if critic is not None and not isinstance(critic, bool):
+            errors.append(
+                "{}: 'critic' must be a boolean, got {}".format(label, type(critic).__name__)
+            )
+        critic_count = feat.get("critic_count")
+        if critic_count is not None and critic_count not in (1, 3):
+            errors.append(
+                "{}: 'critic_count' must be 1 or 3, got {}".format(label, critic_count)
+            )
         if isinstance(subs, list):
             for sidx, sub in enumerate(subs):
                 sub_label = "{}->sub_features[{}]".format(label, sidx)

package/bundled/skills/dev-pipeline-launcher/SKILL.md

@@ -144,28 +144,37 @@ Detect user intent from their message, then follow the corresponding workflow:
    dev-pipeline/run.sh status feature-list.json
    ```
 
-5. **Ask user to confirm**: "Ready to launch the pipeline? It will process N features."
+5. **Ask whether to enable Critic Agent** (adversarial review):
+   Present the choice:
+   - **(a) No — standard pipeline (default)**: No adversarial review. Faster execution, lower token cost.
+   - **(b) Yes — enable Critic review**: Adds adversarial challenge after planning and implementation. Challenges plan fitness and code integration quality. Increases pipeline time by ~5-10 minutes per feature.
 
-6. **Launch** (based on chosen mode from step 4):
-   - Foreground: `dev-pipeline/run.sh run feature-list.json`
-   - Background: `dev-pipeline/launch-daemon.sh start feature-list.json`
+   Default to (a). Only suggest (b) if features have `estimated_complexity: "high"` or above.
+
+   If user chooses (b), add `--critic` flag to the launch command in step 6.
+
+6. **Ask user to confirm**: "Ready to launch the pipeline? It will process N features."
+
+7. **Launch** (based on chosen mode from step 4, with `--critic` if chosen in step 5):
+   - Foreground: `dev-pipeline/run.sh run feature-list.json [--critic]`
+   - Background: `dev-pipeline/launch-daemon.sh start feature-list.json [--critic]`
    - If user specified environment overrides:
      ```bash
      dev-pipeline/launch-daemon.sh start feature-list.json --env "SESSION_TIMEOUT=7200 MAX_RETRIES=5"
      ```
 
-7. **Verify launch**:
+8. **Verify launch**:
    ```bash
    dev-pipeline/launch-daemon.sh status
    ```
 
-8. **Start log monitoring** -- Use the Bash tool with `run_in_background: true`:
+9. **Start log monitoring** -- Use the Bash tool with `run_in_background: true`:
    ```bash
    tail -f dev-pipeline/state/pipeline-daemon.log
    ```
    This runs in background so you can continue interacting with the user.
 
-9. **Report to user**:
+10. **Report to user**:
    - Pipeline PID
    - Log file location
    - "You can ask me 'pipeline status' or 'show logs' at any time"
@@ -250,6 +259,7 @@ When user specifies custom settings, map to environment variables:
 | "max 5 retries" | `MAX_RETRIES=5` |
 | "verbose mode" | `VERBOSE=1` |
 | "heartbeat every 60s" | `HEARTBEAT_INTERVAL=60` |
+| "enable critic review" | `--critic` flag |
 
 Pass via `--env`:
 ```bash

package/bundled/skills/feature-workflow/SKILL.md

@@ -274,7 +274,8 @@ Present this summary to the user and get explicit confirmation before proceeding
 2. **Invoke `dev-pipeline-launcher` skill**:
    - The launcher handles all prerequisites checks
    - The launcher presents execution mode choices to the user (foreground/background/manual)
-   - Do NOT duplicate execution mode selection here — let the launcher handle it
+   - The launcher asks whether to enable Critic Agent (adversarial review) — passes `--critic` flag if chosen
+   - Do NOT duplicate execution mode or critic selection here — let the launcher handle it
    - Returns PID/status and log file location
 
 3. **Verify launch success**:

package/bundled/team/prizm-dev-team.json

@@ -1,7 +1,7 @@
 {
   "name": "prizm-dev-team",
   "team_name": "prizm-dev-team",
-  "description": "PrizmKit-integrated Multi-Agent software development team. 2 specialized agents (Dev, Reviewer) following PrizmKit spec-driven workflow with 7-phase pipeline and 4 checkpoints.",
+  "description": "PrizmKit-integrated Multi-Agent software development team. 3 specialized agents (Dev, Reviewer, Critic) following PrizmKit spec-driven workflow with pipeline and checkpoints.",
   "lead": "team-lead",
   "communication": {
     "protocol": "SendMessage",
@@ -28,6 +28,13 @@
       "agentDefinition": "prizm-dev-team-reviewer",
       "prompt": "You are the Reviewer Agent of the prizm-dev-team. In Phase 4: run /prizmkit-analyze for cross-document consistency. In Phase 6: run /prizmkit-code-review for diagnosis + fix strategy formulation, write and execute integration tests. Produce structured Fix Instructions (Root Cause, Impact, Fix Strategy, Code Guidance, Verification) so Dev can follow them precisely. Write Fix Instructions to context-snapshot.md '## Review Notes' section.",
       "subscriptions": ["*"]
+    },
+    {
+      "name": "critic",
+      "role": "critic",
+      "agentDefinition": "prizm-dev-team-critic",
+      "prompt": "You are the Critic Agent of the prizm-dev-team. Challenge plans and implementations for project fitness, style consistency, robustness, and integration quality. Do NOT verify correctness — that is the Reviewer's job. Write challenge-report.md with adversarial findings.",
+      "subscriptions": ["*"]
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.0.123",
+  "version": "1.0.124",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {