prizmkit 1.1.99 → 1.1.101

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

@@ -1,161 +0,0 @@
----
-name: "prizmkit-code-review"
-description: "Iterative review-fix loop against spec and plan. Spawns a read-only Reviewer agent, filters findings, then a Dev agent applies fixes. Loops until PASS (max 3 rounds). Use after /prizmkit-implement as quality gate. Trigger on: 'review', 'check code', 'code review', 'is it ready to commit'. (project)"
----
-
-# PrizmKit Code Review
-
-An iterative review-fix loop that reviews code changes against the spec and plan, then automatically fixes issues. Uses three separated roles:
-
-- **Reviewer Agent** (read-only): analyzes git diff against spec goals and plan decisions, produces structured findings
-- **Main Agent** (orchestrator): filters Reviewer findings for reasonableness, coordinates the loop
-- **Dev Agent** (read-write): applies fixes for accepted findings
-
-The loop repeats until the Reviewer finds no issues or the max round limit is reached.
-
-### When to Use
-- After `/prizmkit-implement` to verify code quality before commit
-- User says "review", "check code", "review my implementation"
-- As a quality gate before `/prizmkit-committer`
-
-### When NOT to Use
-- Trivial changes (typo, single-line config) → commit directly
-- No spec.md or plan.md exists → nothing to review against
-
-## Input
-
-| 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. 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 scoped test report when present**:
-   - If `{artifact_dir}/test-report-path.txt` exists, read the path, then read that `/prizmkit-test` report.
-   - Extract `Scope`, `Generated / Updated Tests`, `In-Scope Failures`, `Baseline Failures`, `Out of Scope Gaps`, `Boundary Matrix` / `Boundary Completion Gate` when present, and `Verdict`.
-   - If `context-snapshot.md` contains `## PrizmKit Test Gate`, read that summary too.
-   - If this is a feature artifact under `.prizmkit/specs/` and no test report pointer or summary exists, pass `No scoped /prizmkit-test report found` into the Reviewer context so the reviewer can flag the missing gate.
-4. **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."
-5. **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, 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
-
-### 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"
-```
-
-- **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:
-
-**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
-```
-
-### Loop Exit Gate
-
-Call the gate only in these cases:
-
-1. Reviewer returned `PASS`.
-2. Main Agent has finished filtering `NEEDS_FIXES` findings.
-
-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.
-
-**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
-```
-
-| 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. |
-
-Output: `{"endLoop": bool, "reason": str, "verdict": "PASS"|"NEEDS_FIXES"|null, "round": int, "maxRounds": int, "divergenceWarning": bool, "findings_history": [int, ...]}`
-
-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.
-
-**Text mode** — enforce §Text Fallback Constraints manually with identical logic.
-
-### Text Fallback Constraints
-
-When Python is unavailable, apply these rules exactly — they match the script's logic:
-
-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.
-
-### Step 1: Spawn Reviewer Agent
-
-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 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 + Gate
-
-Parse the Reviewer Agent's output:
-- 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 + Gate
-
-Review each finding and decide whether it's reasonable. This prevents unnecessary or harmful changes.
-
-**For each finding, evaluate:**
-- Is this relevant to the current changes? (Reject findings about unmodified, unrelated code.)
-- Is this a real problem or a subjective style preference? (Reject pure style preferences unless they violate clear project conventions.)
-- Would fixing this improve the code without introducing risk? (Reject fixes that require large refactors outside scope.)
-
-**Output per finding:**
-- **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").
-
-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 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
-
-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
-
-Also output a completion summary to conversation.
-
-**HANDOFF:** `/prizmkit-retrospective` (if PASS) or inform the caller of remaining issues (if NEEDS_FIXES after max rounds)

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

@@ -1,30 +0,0 @@
-# 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

@@ -1,31 +0,0 @@
-# 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

@@ -1,66 +0,0 @@
-# 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}
-
-## Scoped Test Report
-{summary from artifact_dir/test-report-path.txt and test-report.md, including Scope, Generated / Updated Tests, In-Scope Failures, Baseline Failures, Out of Scope Gaps, Boundary Matrix / Boundary Completion Gate if present, and Verdict. If no scoped report exists for a feature artifact, write "No scoped /prizmkit-test report found."}
-
-## 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. **Test quality**: If a scoped `/prizmkit-test` report is present, verify the report scope is `this-change`, the artifact dir matches the feature, generated/updated tests assert real behavior rather than mock success or empty assertions, in-scope failures are not mislabeled as baseline failures, baseline failures are genuinely unrelated or pre-existing, out-of-scope gaps were not turned into unrelated test changes, and the report verdict is compatible with proceeding.
-7. **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 | test-quality | 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

@@ -1,186 +0,0 @@
-#!/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

@@ -1,89 +0,0 @@
----
-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 (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 |
-|---|---|---|
-| 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 |
-
-> **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:
-
-#### 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"
-```