prizmkit 1.1.78 → 1.1.80

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

@@ -0,0 +1,87 @@
+---
+name: "prizmkit-committer"
+description: "Pure git commit workflow with safety checks. Stages files, generates Conventional Commits message, and commits. Does NOT modify .prizmkit/prizm-docs/ — run /prizmkit-retrospective first. Trigger on: 'commit', 'submit', 'finish', 'done', 'ship it'. (project)"
+---
+
+# PrizmKit Committer
+
+### When to Use
+- User says "commit", "submit", "finish", "done with this task", "ship it"
+- 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
+- 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 |
+|---|---|---|
+| Uncommitted changes exist | `git status` shows modified/added/untracked files | Inform user "nothing to commit" and stop |
+| `.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 |
+
+### Workflow
+
+Follow these steps in order — skipping or reordering can stage sensitive files or commit without proper verification:
+
+#### Step 1: Status Check
+```powershell
+git status
+```
+- If "nothing to commit, working tree clean": inform user and stop
+- If there are changes: proceed
+
+#### Step 2: Generate Commit Message
+Analyze the staged diff and context (spec title, plan summary) to generate a concise Conventional Commits message. The message should capture the *what* and *why* of the change.
+
+#### Step 3: Update CHANGELOG.md
+If CHANGELOG.md exists in the project root, append an entry following Keep a Changelog format under the `[Unreleased]` section. Match the existing style in the file.
+
+#### Step 4: Git Commit
+
+Stage changes using a safe strategy — **never use `git add .` or `git add -A`** as they may stage sensitive files (.env, credentials, secrets) or unintended changes:
+
+1. Review untracked files with `git status`. Warn the user if any files match sensitive patterns (`.env*`, `*credential*`, `*secret*`, `*.pem`, `*.key`).
+2. Stage tracked modified files: `git add -u`
+3. For new files: stage explicitly by name after confirming they should be included.
+4. Verify staged content with `git diff --cached --stat` before committing.
+
+```powershell
+git commit -m "<type>(<scope>): <description>"
+```
+Follow Conventional Commits format.
+
+#### Step 5: Verification
+```powershell
+git log -1 --stat
+```
+Confirm the commit was recorded.
+
+Then verify working tree is clean:
+```powershell
+git status
+```
+- If "nothing to commit, working tree clean": commit verified successfully, proceed
+
+#### Step 6: Optional Push
+Ask user: "Push to remote?"
+- Yes: `git push`
+- No: Stop
+
+**Headless mode**: If the skill was invoked with `--headless` in the args (e.g., `/prizmkit-committer --headless feat(F-001): ...`), **SKIP this step entirely**. Do NOT ask the question. Do NOT push. Stop after Step 5 verification. Headless mode is used by autonomous pipeline sessions where there is no human to answer interactive prompts.
+
+## Example
+
+**Feature commit:**
+```
+git commit -m "feat(avatar): add user avatar upload with S3 storage"
+```
+
+**Bug fix commit:**
+```
+git commit -m "fix(auth): handle null token in refresh flow"
+```