prizmkit 1.1.79 → 1.1.81

package/bundled/skills-windows/prizmkit-code-review/SKILL.md

@@ -26,114 +26,104 @@ The loop repeats until the Reviewer finds no issues or the max round limit is re
 
 | Parameter | Required | Description |
 |-----------|----------|-------------|
-| `artifact_dir` | No | Directory containing spec.md + plan.md. If omitted, scan `.prizmkit/` subdirectories for the most recently modified directory with a `plan.md` whose tasks are all completed. |
+| `artifact_dir` | No | Directory containing spec.md + plan.md. If omitted, scan `.prizmkit/` subdirectories for the most recently modified directory with a `plan.md` whose tasks are all completed. When invoked as a handoff step, reuse the caller's `artifact_dir` rather than re-detecting. |
 
 ## Phase 0: Context Loading
 
 1. **Read spec.md** from the artifact directory — extract goals and acceptance criteria.
 2. **Read plan.md** from the artifact directory — extract architecture decisions and completed tasks.
-3. **Read dev rules** (if configured): Read `.prizmkit/prizm-docs/root.prizm` and check for a `RULES:` line. If present, read all referenced `.prizmkit/rules/<layer>-rules.md` files. If a referenced file does not exist, skip it silently and continue. These define per-layer conventions that the code should follow.
+3. **Read dev rules** (if configured): If `.prizmkit/prizm-docs/root.prizm` exists, read it and check for a `RULES:` line. If present, read all referenced `.prizmkit/rules/<layer>-rules.md` files. If `root.prizm` or a referenced rules file does not exist, continue with "No custom dev rules configured — use general best practices."
 4. **Capture workspace diff**: run `git diff` (unstaged) + `git diff --cached` (staged) + `git status` to understand the full scope of changes. For new files in git status, note their paths for the Reviewer to read.
-   - If no changes are detected, output PASS and stop.
+   - If no changes are detected, skip Phase 1 and proceed to Phase 2 with verdict PASS, rounds 0, and an empty findings list. Always write `review-report.md`; downstream pipeline steps use it as the review gate.
 
 ## Phase 1: Review-Fix Loop
 
-```
-┌─── Loop (max 3 rounds) ──────────────────────────────┐
-│                                                        │
-│  Step 1: Spawn Reviewer Agent (read-only)              │
-│    → Input: git diff + spec goals + plan decisions + dev rules│
-│    → Output: structured findings or PASS               │
-│                                                        │
-│  Step 2: Check result                                  │
-│    → If PASS (no findings): exit loop                  │
-│                                                        │
-│  Step 3: Main Agent filters findings                   │
-│    → For each finding: accept (reasonable) or reject   │
-│    → If all rejected: exit loop                        │
-│                                                        │
-│  Step 4: Spawn Dev Agent (read-write)                  │
-│    → Input: accepted findings + spec/plan context      │
-│    → Output: fix report                                │
-│                                                        │
-│  Step 5: Back to Step 1                                │
-│                                                        │
-│  Hard limit: exit after 3 rounds regardless            │
-│  → On max-round exhaustion: output a summary of all    │
-│    unresolved findings to the conversation, then write  │
-│    review-report.md with NEEDS_FIXES verdict.           │
-└────────────────────────────────────────────────────────┘
+### Gate Mode Detection
+
+The loop exit conditions are enforced by a gatekeeper. Check Python availability first:
+
+```bash
+python3 --version 2>/dev/null && echo "SCRIPT_MODE" || echo "TEXT_MODE"
 ```
 
-### Step 1: Spawn Reviewer Agent
+- **Script mode** (Python available): Use `${SKILL_DIR}/scripts/check_loop.py` to enforce exit conditions with round tracking, max-rounds enforcement, and divergence detection. The script prevents accidentally exceeding the 3-round limit.
+- **Text mode** (no Python): Follow §Text Fallback Constraints — identical behavior enforced manually.
+
+### Step 0: Initialize Loop State
+
+The script is stateless — no `--reset` or runtime files. Initialize these values before starting:
 
-Include the dev rules read in Phase 0 step 3 in the `## Dev Rules` section of the prompt below. Spawn a **read-only** agent (subagent_type: `Explore`) with the following prompt:
+**Script mode** — `findings_history = []`, `max_rounds = 3`, `round = 1`.
+**Text mode** — track manually: `round = 1`, `findings_history = []`.
 
+### Loop Flow
+
+```
+1. Spawn Reviewer Agent (read-only) → findings or PASS
+2. Parse result:
+   - PASS → Call Loop Exit Gate → Phase 2
+   - NEEDS_FIXES → count findings → Step 3 (do not call gate yet)
+3. Main Agent filters findings → Call Loop Exit Gate → if endLoop: Phase 2
+4. Spawn Dev Agent (read-write) → apply fixes
+5. Increment round and return to Step 1
 ```
-You are a code reviewer. Review workspace changes against the spec goals, plan decisions, and per-layer dev rules.
 
-## Spec Goals
-{goals and acceptance criteria from spec.md}
+### Loop Exit Gate
+
+Call the gate only in these cases:
 
-## Plan Decisions
-{architecture decisions and task list from plan.md}
+1. Reviewer returned `PASS`.
+2. Main Agent has finished filtering `NEEDS_FIXES` findings.
 
-## Dev Rules (per-layer conventions)
-{rules from .prizmkit/rules/<layer>-rules.md, or "No custom dev rules configured — use general best practices."}
+Do not call the gate for `NEEDS_FIXES` before filtering, because `accepted_count` is not known yet. Only exit the loop when `endLoop` is `true` — the gate is the sole authority on exit decisions.
 
-## Review Round
-Round {N}. {round_context}
+**Script mode invocation:**
+```bash
+echo '{"reviewer_result":"NEEDS_FIXES","accepted_count":2,"findings_count":3,"round":1,"findings_history":[],"max_rounds":3,"filtering_done":true}' | python3 ${SKILL_DIR}/scripts/check_loop.py
+```
 
-## What to Review
-Run these commands to see the current workspace changes:
-- `git diff` (unstaged changes)
-- `git diff --cached` (staged changes)
-- `git status` (new/deleted files)
+| Input field | Type | Description |
+|-------------|------|-------------|
+| `reviewer_result` | `"PASS"` or `"NEEDS_FIXES"` | Reviewer's verdict |
+| `accepted_count` | int | Findings accepted by Main Agent. Use `0` for Reviewer PASS or when all findings were rejected after filtering. |
+| `findings_count` | int | Total findings returned by Reviewer this round |
+| `round` | int | Current round number (1-based, model-supplied — the script does not auto-increment) |
+| `findings_history` | `[int, ...]` | Findings count per round, used for divergence detection. Initialize as `[]`. Pass back the value from the previous gate call's output. |
+| `max_rounds` | int | Maximum review rounds before forced exit. Default `3`. |
+| `filtering_done` | bool | `true` only after Main Agent has filtered `NEEDS_FIXES` findings. For Reviewer PASS, this may be omitted. |
 
-For new files shown in git status, read their full content.
-For modified files, read enough surrounding context to understand the change.
+Output: `{"endLoop": bool, "reason": str, "verdict": "PASS"|"NEEDS_FIXES"|null, "round": int, "maxRounds": int, "divergenceWarning": bool, "findings_history": [int, ...]}`
 
-## Review Dimensions
-Evaluate the changes across these dimensions (focus on what's relevant):
+The script enforces three exit conditions in order: (1) Reviewer PASS → exit with verdict PASS, (2) filtered `NEEDS_FIXES` with zero accepted findings → exit with verdict PASS, (3) max rounds reached after filtering → exit with verdict NEEDS_FIXES. It records `findings_count` once per round by round index, so repeated gate calls cannot duplicate history entries. If `divergenceWarning` is true, warn the user the loop may not be converging.
 
-1. **Goal alignment**: Do the changes accomplish all goals from spec.md? Anything missing or off-target?
-2. **Defects**: Logic bugs, missing error handling, boundary condition issues, incorrect behavior.
-3. **Completeness**: Files that should have been changed but weren't? Missing tests, types, imports, exports?
-4. **Consistency**: Do changes follow the project's existing patterns, naming conventions, and code style?
-5. **Security**: Hardcoded secrets, injection vulnerabilities, unsafe operations.
-6. **Rules compliance**: (Skip this dimension if no dev rules were provided.) Do changes follow the per-layer dev rules? Flag violations of framework conventions, naming patterns, state management, or other rules defined for that layer.
+**Text mode** — enforce §Text Fallback Constraints manually with identical logic.
 
-## Output Format
-Respond with EXACTLY this format:
+### Text Fallback Constraints
 
-### Result: PASS | NEEDS_FIXES
+When Python is unavailable, apply these rules exactly — they match the script's logic:
 
-### Findings
-(If PASS, write "No issues found.")
+1. **PASS exit**: Reviewer returns `PASS` → exit loop, verdict PASS.
+2. **Pre-filter NEEDS_FIXES**: Count findings and continue to filtering. Do not apply all-rejected or max-round exits before filtering.
+3. **All-rejected exit**: After filtering, if all findings were rejected → exit loop, verdict PASS.
+4. **Max rounds**: After filtering, if `round >= 3` and accepted findings remain → exit loop, verdict NEEDS_FIXES. Write `review-report.md` with unresolved findings.
+5. **Divergence**: If findings count strictly increases for 3 consecutive recorded rounds, warn user the loop may not converge.
+6. **Counter**: Increment `round` after each complete cycle (Steps 1-4). Track `findings_history` by round index to detect divergence — record `findings_count` once per round.
 
-#### Finding N
-- **Severity**: high | medium | low
-- **Dimension**: goal-alignment | defect | completeness | consistency | security | rules-compliance
-- **Location**: filepath:line (or "project-level")
-- **Problem**: What is wrong and why it matters
-- **Suggestion**: Recommended fix approach
-- **Verification**: How to confirm the fix is correct
+### Step 1: Spawn Reviewer Agent
 
-### Summary
-One to two sentences about the overall state of the changes.
-```
+Include the dev rules read in Phase 0 step 3 in the `## Dev Rules` section of the prompt. Spawn a platform-supported **read-only** reviewer agent; use `subagent_type: Explore` only on platforms that support it. If no read-only agent is available, perform the review in the Main Agent without editing files. Read `${SKILL_DIR}/references/reviewer-agent-prompt.md` for the full prompt template — fill `{goals}`, `{plan decisions}`, `{dev rules}`, `{round N}`, and `{round_context}` before spawning.
 
-**Round context** varies by round:
+Round context varies by round:
 - Round 1: "This is the first review. Examine all changes comprehensively."
 - Round 2+: "Previous round found issues that were fixed. Focus on: (1) whether previous fixes are correct, (2) whether fixes introduced new problems, (3) any remaining issues. Do not re-report issues that have already been fixed."
 
-### Step 2: Check Result
+### Step 2: Check Result + Gate
 
 Parse the Reviewer Agent's output:
-- If `Result: PASS` → exit loop, proceed to Phase 2.
-- If `Result: NEEDS_FIXES` → extract findings and continue to Step 3.
+- If `Result: PASS` → call the **Loop Exit Gate** with `{"reviewer_result": "PASS", "accepted_count": 0, "findings_count": 0, "round": <current_round>, "findings_history": <current_history>, "max_rounds": 3}`. If `endLoop=true`, proceed to Phase 2.
+- If `Result: NEEDS_FIXES` → count findings, do not call the gate yet, then continue to Step 3.
 
-### Step 3: Main Agent Filters Findings
+### Step 3: Main Agent Filters Findings + Gate
 
 Review each finding and decide whether it's reasonable. This prevents unnecessary or harmful changes.
 
@@ -146,76 +136,17 @@ Review each finding and decide whether it's reasonable. This prevents unnecessar
 - **Accepted**: The finding is reasonable — include it in the Dev Agent's task.
 - **Rejected** (with reason): Brief explanation (e.g., "Out of scope", "Style preference, not a defect").
 
-If all findings are rejected → exit loop, proceed to Phase 2.
+After filtering: call the **Loop Exit Gate** with `{"reviewer_result": "NEEDS_FIXES", "accepted_count": <N>, "findings_count": <total findings this round>, "round": <current_round>, "findings_history": <current_history>, "max_rounds": 3, "filtering_done": true}`. If `endLoop=true`, proceed to Phase 2.
 
 ### Step 4: Spawn Dev Agent
 
-Spawn a **general-purpose** agent (read-write) with the following prompt:
-
-```
-You are a developer fixing code review findings. Apply each fix carefully without breaking existing functionality.
-
-## Spec Context
-{goals from spec.md for reference}
-
-## Findings to Fix
-{accepted findings list — each with Severity, Location, Problem, Suggestion, Verification}
-
-## Instructions
-1. Read each finding carefully.
-2. For each finding:
-   a. Read the relevant code and understand the context.
-   b. Implement the fix based on the suggestion.
-   c. If a suggestion is not feasible (would break other functionality, technically impossible), explain why.
-3. After all fixes, report what you did.
-
-## Output Format
-For each finding, report:
-- **Finding N**: [fixed | unable-to-fix]
-- **What was done**: Brief description
-- **Files modified**: List of changed files
-(If unable-to-fix, explain why)
-```
+Spawn a platform-supported **read-write** developer agent. If no write-capable agent is available, the Main Agent applies accepted fixes directly. Read `${SKILL_DIR}/references/dev-agent-prompt.md` for the full prompt template — fill `{spec context}` and `{accepted findings}` before spawning.
 
 After the Dev Agent returns, record results and return to Step 1 for the next round.
 
 ## Phase 2: Output
 
-Write `review-report.md` to the artifact directory:
-
-```markdown
-# Review Report
-
-## Verdict: PASS
-## Rounds: 2
-## Total findings: 3 → Fixed: 2, Rejected: 1
-
-## Round 1
-Findings: 3 | Accepted: 2, Rejected: 1
-
-### Finding 1: Missing null check in parseConfig
-- Severity: high
-- Dimension: defect
-- Location: src/config.ts:42
-- Problem: parseConfig crashes when input is undefined
-- Status: fixed (round 1)
-
-### Finding 2: Export missing from index.ts
-- Severity: medium
-- Dimension: completeness
-- Location: src/index.ts
-- Problem: New parseConfig function not exported
-- Status: fixed (round 1)
-
-### Finding 3: Consider renaming variable
-- Severity: low
-- Dimension: consistency
-- Location: src/config.ts:15
-- Problem: Variable `d` should be more descriptive
-- Status: rejected — Style preference; existing code uses short names in this module
-
-## Round 2: PASS — no new findings
-```
+Always write `review-report.md` to the artifact directory, including no-change PASS results. Read `${SKILL_DIR}/references/review-report-template.md` for the full output format.
 
 - `PASS`: Reviewer returned no findings (or all remaining findings were rejected as unreasonable)
 - `NEEDS_FIXES`: 3 rounds completed but unresolved findings remain

package/bundled/skills-windows/prizmkit-code-review/references/dev-agent-prompt.md

@@ -0,0 +1,30 @@
+# Dev Agent Prompt Template
+
+Used in Phase 1 Step 4 of `/prizmkit-code-review`. The orchestrator fills `{spec context}` and `{accepted findings}` before spawning the Dev Agent.
+
+```
+You are a developer fixing code review findings. Apply each fix carefully without breaking existing functionality.
+
+## Spec Context
+{goals from spec.md for reference}
+
+## Findings to Fix
+{accepted findings list — each with Severity, Location, Problem, Suggestion, Verification}
+
+## Instructions
+1. Read each finding carefully.
+2. For each finding:
+   a. Read the relevant code and understand the context.
+   b. Implement the fix based on the suggestion.
+   c. If a suggestion is not feasible (would break other functionality, technically impossible), explain why.
+3. After all fixes, report what you did.
+
+## Output Format
+For each finding, report:
+- **Finding N**: [fixed | unable-to-fix]
+- **What was done**: Brief description
+- **Files modified**: List of changed files
+(If unable-to-fix, explain why)
+```
+
+After the Dev Agent returns, record results and return to Step 1 for the next round.

package/bundled/skills-windows/prizmkit-code-review/references/review-report-template.md

@@ -0,0 +1,31 @@
+# Review Report Output Template
+
+Used in Phase 2 of `/prizmkit-code-review`. Always write `review-report.md` to the artifact directory using this format.
+
+```markdown
+# Review Report
+
+## Verdict: <PASS|NEEDS_FIXES>
+## Rounds: <number of review rounds completed; use 0 for no-change PASS>
+## Total findings: <total> → Fixed: <fixed>, Rejected: <rejected>, Unresolved: <unresolved>
+
+## Round <N>
+Findings: <count> | Accepted: <count>, Rejected: <count>
+
+### Finding <N>: <short title>
+- Severity: <high|medium|low>
+- Dimension: <goal-alignment|defect|completeness|consistency|security|rules-compliance>
+- Location: <filepath:line or project-level>
+- Problem: <what was wrong and why it mattered>
+- Status: <fixed (round N)|rejected — reason|unresolved — reason>
+
+## Final Summary
+<One to three sentences summarizing the review outcome, including no-change PASS when applicable.>
+```
+
+For `PASS` with no findings, write `Total findings: 0 → Fixed: 0, Rejected: 0, Unresolved: 0` and `## Round 0: PASS — no workspace changes to review` or `## Round N: PASS — no issues found`.
+
+## Verdict Rules
+
+- `PASS`: Reviewer returned no findings, no workspace changes existed, or all remaining findings were rejected as unreasonable.
+- `NEEDS_FIXES`: Max rounds completed but accepted findings remain unresolved.

package/bundled/skills-windows/prizmkit-code-review/references/reviewer-agent-prompt.md

@@ -0,0 +1,62 @@
+# Reviewer Agent Prompt Template
+
+Used in Phase 1 Step 1 of `/prizmkit-code-review`. The orchestrator fills `{goals}`, `{plan decisions}`, `{dev rules}`, `{round N}`, and `{round_context}` before spawning the Reviewer Agent.
+
+```
+You are a code reviewer. Review workspace changes against the spec goals, plan decisions, and per-layer dev rules.
+
+## Spec Goals
+{goals and acceptance criteria from spec.md}
+
+## Plan Decisions
+{architecture decisions and task list from plan.md}
+
+## Dev Rules (per-layer conventions)
+{rules from .prizmkit/rules/<layer>-rules.md, or "No custom dev rules configured — use general best practices."}
+
+## Review Round
+Round {N}. {round_context}
+
+## What to Review
+Run these commands to see the current workspace changes:
+- `git diff` (unstaged changes)
+- `git diff --cached` (staged changes)
+- `git status` (new/deleted files)
+
+For new files shown in git status, read their full content.
+For modified files, read enough surrounding context to understand the change.
+
+## Review Dimensions
+Evaluate the changes across these dimensions (focus on what's relevant):
+
+1. **Goal alignment**: Do the changes accomplish all goals from spec.md? Anything missing or off-target?
+2. **Defects**: Logic bugs, missing error handling, boundary condition issues, incorrect behavior.
+3. **Completeness**: Files that should have been changed but weren't? Missing tests, types, imports, exports?
+4. **Consistency**: Do changes follow the project's existing patterns, naming conventions, and code style?
+5. **Security**: Hardcoded secrets, injection vulnerabilities, unsafe operations.
+6. **Rules compliance**: (Skip this dimension if no dev rules were provided.) Do changes follow the per-layer dev rules? Flag violations of framework conventions, naming patterns, state management, or other rules defined for that layer.
+
+## Output Format
+Respond with EXACTLY this format:
+
+### Result: PASS | NEEDS_FIXES
+
+### Findings
+(If PASS, write "No issues found.")
+
+#### Finding N
+- **Severity**: high | medium | low
+- **Dimension**: goal-alignment | defect | completeness | consistency | security | rules-compliance
+- **Location**: filepath:line (or "project-level")
+- **Problem**: What is wrong and why it matters
+- **Suggestion**: Recommended fix approach
+- **Verification**: How to confirm the fix is correct
+
+### Summary
+One to two sentences about the overall state of the changes.
+```
+
+## Round Context
+
+- Round 1: "This is the first review. Examine all changes comprehensively."
+- Round 2+: "Previous round found issues that were fixed. Focus on: (1) whether previous fixes are correct, (2) whether fixes introduced new problems, (3) any remaining issues. Do not re-report issues that have already been fixed."

package/bundled/skills-windows/prizmkit-code-review/scripts/check_loop.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""
+Loop Exit Gatekeeper for prizmkit-code-review skill.
+
+Stateless design: all loop state is passed via stdin and returned via stdout.
+The caller (AI model) tracks `findings_history` and `max_rounds` between calls.
+No runtime files are created — the script is a pure function over JSON.
+
+The model supplies the current round in each call — the script does not auto-increment
+rounds, because the gate is called twice per loop iteration (after Reviewer returns
+and after Main Agent filters), and only the model knows when a full cycle completes.
+
+Usage:
+    echo '{"reviewer_result":"NEEDS_FIXES","accepted_count":2,"findings_count":5,"round":1,"findings_history":[],"max_rounds":3,"filtering_done":true}' | python3 check_loop.py
+
+Input JSON schema:
+    {
+        "reviewer_result": "PASS" | "NEEDS_FIXES",
+        "accepted_count": int,
+        "findings_count": int,
+        "round": int,
+        "findings_history": [int, ...],
+        "max_rounds": int,
+        "filtering_done": bool
+    }
+
+Output JSON schema:
+    {
+        "endLoop": bool,
+        "reason": str,
+        "verdict": "PASS" | "NEEDS_FIXES" | null,
+        "round": int,
+        "maxRounds": int,
+        "divergenceWarning": bool,
+        "findings_history": [int, ...]
+    }
+
+Exit conditions (checked in order):
+    1. Reviewer returned PASS          → endLoop=true, verdict=PASS
+    2. NEEDS_FIXES before filtering    → endLoop=false, wait for filtering
+    3. Filtered findings all rejected  → endLoop=true, verdict=PASS
+    4. Max rounds reached after filtering → endLoop=true, verdict=NEEDS_FIXES
+    5. Otherwise                       → endLoop=false
+
+Divergence detection:
+    If findings_count strictly increases for 3 consecutive rounds, set divergenceWarning=true.
+    This is a warning only — it does not force loop exit.
+"""
+
+import json
+import sys
+
+DEFAULT_MAX_ROUNDS = 3
+
+
+def check_divergence(findings_history):
+    """Return True if the last 3 entries in findings_history are strictly increasing."""
+    if len(findings_history) < 3:
+        return False
+    last_three = findings_history[-3:]
+    return last_three[0] < last_three[1] < last_three[2]
+
+
+def record_findings_count(findings_history, current_round, findings_count):
+    """Record findings_count once per round index, updating duplicate calls for the same round."""
+    if current_round <= 0:
+        return findings_history
+
+    target_index = current_round - 1
+    while len(findings_history) < target_index:
+        findings_history.append(0)
+
+    if len(findings_history) == target_index:
+        findings_history.append(findings_count)
+    else:
+        findings_history[target_index] = findings_count
+
+    return findings_history
+
+
+def check_exit_condition(data):
+    """Determine whether the loop should exit. Pure function — no side effects.
+
+    Round is model-supplied — the script does not auto-increment it because
+    the gate is called twice per loop iteration (after Step 2 and Step 3).
+    """
+    reviewer_result = data.get("reviewer_result")
+    accepted_count = data.get("accepted_count", 0)
+    findings_count = data.get("findings_count", 0)
+    current_round = data.get("round", 0)
+    findings_history = list(data.get("findings_history", []))
+    max_rounds = data.get("max_rounds", DEFAULT_MAX_ROUNDS)
+    filtering_done = data.get("filtering_done", reviewer_result == "PASS")
+
+    findings_history = record_findings_count(
+        findings_history, current_round, findings_count
+    )
+    divergence_warning = check_divergence(findings_history)
+
+    # Condition 1: Reviewer returned PASS
+    if reviewer_result == "PASS":
+        return {
+            "endLoop": True,
+            "reason": f"Round {current_round}: Reviewer returned PASS",
+            "verdict": "PASS",
+            "round": current_round,
+            "maxRounds": max_rounds,
+            "divergenceWarning": False,
+            "findings_history": findings_history,
+        }
+
+    # Condition 2: Reviewer returned findings, but filtering has not happened yet
+    if reviewer_result == "NEEDS_FIXES" and not filtering_done:
+        return {
+            "endLoop": False,
+            "reason": f"Round {current_round}: reviewer returned findings; filter before applying exit conditions",
+            "verdict": None,
+            "round": current_round,
+            "maxRounds": max_rounds,
+            "divergenceWarning": divergence_warning,
+            "findings_history": findings_history,
+        }
+
+    # Condition 3: All findings rejected after filtering
+    if reviewer_result == "NEEDS_FIXES" and accepted_count == 0:
+        return {
+            "endLoop": True,
+            "reason": f"Round {current_round}: all findings rejected by main agent",
+            "verdict": "PASS",
+            "round": current_round,
+            "maxRounds": max_rounds,
+            "divergenceWarning": False,
+            "findings_history": findings_history,
+        }
+
+    # Condition 4: Max rounds reached
+    if current_round >= max_rounds:
+        return {
+            "endLoop": True,
+            "reason": f"Hard limit: max {max_rounds} rounds reached",
+            "verdict": "NEEDS_FIXES",
+            "round": current_round,
+            "maxRounds": max_rounds,
+            "divergenceWarning": divergence_warning,
+            "findings_history": findings_history,
+        }
+
+    # Condition 5: Continue loop
+    next_round = current_round + 1
+    return {
+        "endLoop": False,
+        "reason": f"Round {current_round}: {accepted_count} findings accepted, continuing to round {next_round}",
+        "verdict": None,
+        "round": current_round,
+        "maxRounds": max_rounds,
+        "divergenceWarning": divergence_warning,
+        "findings_history": findings_history,
+    }
+
+
+def main():
+    # Read input from stdin
+    try:
+        data = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        print(
+            json.dumps(
+                {
+                    "endLoop": False,
+                    "reason": f"Invalid JSON input: {e}",
+                    "verdict": None,
+                    "round": 0,
+                    "maxRounds": DEFAULT_MAX_ROUNDS,
+                    "divergenceWarning": False,
+                    "findings_history": [],
+                }
+            )
+        )
+        sys.exit(1)
+
+    result = check_exit_condition(data)
+    print(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()

package/bundled/skills-windows/prizmkit-committer/SKILL.md

@@ -10,6 +10,12 @@ description: "Pure git commit workflow with safety checks. Stages files, generat
 - After `/prizmkit-retrospective` has finished architecture sync
 - The UserPromptSubmit hook will remind to use this skill when commit intent is detected
 
+### When NOT to Use
+- No uncommitted changes exist — nothing to commit
+- .prizmkit/prizm-docs/ not synced — run /prizmkit-retrospective first (full lifecycle only; the `plan → implement → committer` fast path skips this by design)
+- Code review not passed in pipeline mode — run /prizmkit-code-review first
+- Mid-merge conflict resolution — handle manually with git
+
 **PRECONDITION:**
 
 | Required State | Check | If Missing |
@@ -18,6 +24,8 @@ description: "Pure git commit workflow with safety checks. Stages files, generat
 | `.prizmkit/prizm-docs/` synced (feature/refactor) | `/prizmkit-retrospective` has run | Run `/prizmkit-retrospective` first |
 | Code review passed (pipeline mode) | `review-report.md` in artifact directory has `## Verdict: PASS` | Run `/prizmkit-code-review` first |
 
+> **Fast-path exemption**: the prizm-docs-synced and review-passed rows above gate the **full lifecycle**. Small, well-scoped changes using the `plan → implement → committer` fast path may commit without them — there is no retrospective or review-report artifact to check, so treat those rows as "satisfied when not applicable."
+
 ### Workflow
 
 Follow these steps in order — skipping or reordering can stage sensitive files or commit without proper verification: