prizmkit 1.1.124 → 1.1.125

package/bundled/skills/prizmkit-code-review/assets/reviewer-role.json

@@ -1,7 +1,7 @@
 {
-  "protocol_version": 1,
+  "protocol_version": 2,
   "role_name": "prizmkit-code-reviewer",
-  "description": "Use only as the single fresh independent Reviewer launched by /prizmkit-code-review after its strict preflight gate authorizes the round.",
+  "description": "Use only as the one fresh independent read-only Reviewer for a completed /prizmkit-code-review round.",
   "observational_capabilities": [
     "read-files",
     "search-content",
@@ -15,7 +15,5 @@
     "orchestration-reentry",
     "skill-invocation"
   ],
-  "execution_mode": "foreground-single-authority",
-  "max_descendant_execution_units": 0,
-  "max_delegation_depth": 0
+  "execution_mode": "foreground-independent-review"
 }

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

@@ -1,53 +1,40 @@
 # Review Report Output Template
 
-Use this template to render `{artifact_dir}/review-report.md` from the persisted structured result. Report regeneration must not rerun Reviewer execution.
+Write the final result to `{artifact_dir}/review-report.md`. This is the only required persisted review artifact.
 
 ```markdown
 # Review Report
 
-## Verdict: <PASS|NEEDS_FIXES>
+## Verdict: <PASS|NEEDS_FIXES|BLOCKED>
 ## Rounds Completed: <number>
-## Reviewers Started: <number>
-## Review Mode: <independent-reviewer-verified-snapshot|not-run-no-changes>
-## Reviewer Strategy: <semantic strategy summary|not-applicable>
-## Execution Protocol: <COMPLIANT|BLOCKED|VIOLATION|NOT_APPLICABLE>
-## Capability Attestation: <VERIFIED|FAILED|NOT_APPLICABLE>
-## Descendant Execution Units Observed: <number>
-## Delegation Depth Observed: <number>
-## Snapshot Verification: <VERIFIED|FAILED|NOT_APPLICABLE>
-## Snapshot Identity: <identity|failure reason|not-applicable>
-## Blocker Code: <REVIEW_INFRASTRUCTURE_BLOCKED|REVIEW_ORCHESTRATION_VIOLATION|WORKSPACE_MISMATCH|REVIEW_SAFETY_LIMIT_REACHED|INVALID_REVIEW_RESULT|NONE>
 ## Total Findings: <total> → Fixed: <fixed>, Rejected: <rejected>, Unresolved: <unresolved>
 
-## Round <N>
-
-- Snapshot Identity: <identity>
-- Reviewer Execution Identity: <identity>
-- Result: <PASS|NEEDS_FIXES>
-- Findings: <count>
-- Accepted: <count>
-- Rejected: <count>
+## Findings
 
 ### Finding <N>: <short title>
 
 - Severity: <high|medium|low>
-- Dimension: <dimension>
 - Location: <filepath:line|project-level>
 - Problem: <what was wrong and why it mattered>
 - Failure Scenario: <concrete input or state>
-- Status: <fixed in round N|rejected — concrete evidence|unresolved — reason>
+- Disposition: <fixed in round N|rejected — concrete evidence|unresolved — reason>
+
+## Blocker
+
+<Include only for BLOCKED: concise infrastructure failure and required action.>
 
-## Final Summary
+## Summary
 
-<One to three sentences covering the valid review outcome and any remaining blocker. Do not expose Reviewer reasoning traces.>
+<One to three sentences covering the final outcome. Do not expose private reasoning traces.>
 ```
 
 ## Report Rules
 
-- No-change review starts no Reviewer, uses zero completed rounds, and records execution plus snapshot metadata as `NOT_APPLICABLE`.
-- Findings from a violating or mismatched Reviewer are discarded and excluded from totals.
-- A violating or mismatched round is not completed.
-- `PASS` requires no workspace changes or a usable complete Reviewer result with zero accepted findings.
-- The ten-round safety fuse with accepted findings is `NEEDS_FIXES`, never `PASS`.
-- Only `PASS` and `NEEDS_FIXES` are external verdicts. Blocker codes are diagnostic metadata.
-- Persist structured state before Markdown rendering so a report-only failure can be recovered without repeating review.
+- A no-change review uses zero completed rounds and returns `PASS`.
+- A usable Reviewer result counts as one completed round.
+- Reviewer launch failure, abnormal exit, or unusable output returns `BLOCKED` and does not add a completed round.
+- `PASS` requires no accepted or unresolved finding. This includes a Reviewer `PASS` and a findings result where the Main Agent rejects every finding with concrete evidence.
+- The tenth completed round with accepted findings returns `NEEDS_FIXES`.
+- `BLOCKED` describes review infrastructure or missing essential context, not a code defect.
+- Overwrite the same report on each execution; keep raw round output only in the session log.
+- Do not persist a separate review state file.

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

@@ -1,6 +1,6 @@
 # Reviewer Prompt Contract
 
-Use this complete template for every Reviewer execution in Phase 1. Fill documented placeholders only. Do not summarize, shorten, or omit the execution boundary, complete-review scope, independence boundary, workspace guard, or output contract.
+Use this complete template for every Reviewer execution. Fill the documented placeholders with current-round context. Do not include previous-round findings, verdicts, filtering decisions, rejection reasons, or repair explanations.
 
 ```text
 You are the sole independent read-only Reviewer for this round of `/prizmkit-code-review`.
@@ -9,61 +9,60 @@ You are the sole independent read-only Reviewer for this round of `/prizmkit-cod
 
 Perform the complete review yourself.
 
-Do not create, schedule, resume, continue, request, or coordinate any separate downstream execution unit. Do not re-enter orchestration, delegation, another review workflow, or an equivalent process directly or indirectly. Do not ask the Main Agent to create a helper on your behalf.
+Do not create, schedule, resume, continue, request, or coordinate any separate downstream execution unit. Do not re-enter orchestration, invoke a skill, delegate review work, or ask the Main Agent to create a helper.
 
-Do not modify, create, delete, rename, stage, or commit workspace files. Do not run a command or tool that changes the review view.
+Do not modify, create, delete, rename, stage, or commit workspace files. Use only read-only inspection capabilities.
 
-If you cannot complete the review within this execution context, stop and return `REVIEW_INFRASTRUCTURE_BLOCKED`. Do not delegate or provide a partial PASS.
+If you cannot complete the review in this execution context, return `BLOCKED` with the missing capability or context. Do not delegate and do not return a partial `PASS`.
 
 ## Independent Input Boundary
 
-Review only the current state supplied below. No prior Reviewer findings, verdicts, filtering decisions, repair descriptions, or Reviewer reasoning are part of your input. Do not infer that an earlier Reviewer found every defect, and do not attempt historical reconciliation.
+Review only the current state supplied below. No previous-round findings, verdicts, filtering decisions, rejection reasons, repair descriptions, or Reviewer reasoning are part of your input.
 
-## Spec Goals
+## Goals and Acceptance Criteria
 
-{goals and acceptance criteria from spec.md}
+{goals and acceptance criteria from spec.md, or "No spec artifact found; infer the requested behavior from the user goal and current change."}
 
-## Plan Decisions
+## Plan and Intended Change
 
-{architecture decisions and task list from plan.md}
+{relevant architecture decisions and completed tasks from plan.md, or a concise current task description}
 
 ## Applicable Rules and Contracts
 
 {relevant Prizm docs, project rules, public and internal contracts, or "No additional project rules identified."}
 
-## Scoped Test Evidence
+## Test Evidence
 
-{current test report summary and identities. If absent, write "No scoped /prizmkit-test report found." Treat absence as informational unless the lifecycle contract required prior test evidence.}
+{current scoped test evidence, or "No scoped test report found."}
 
-## Workspace Manifest
+## Current Change
 
-{repository identity, baseline identity, snapshot identity, path inventory, change states, staged and unstaged composition, rename/delete state, content identities, and supporting-context identities}
+- Repository and Reviewer-visible checkout: {path or platform-visible location}
+- Base revision: {base revision when known}
+- Changed paths and states: {staged, unstaged, untracked, deleted, and renamed inventory}
+- Review access: {active checkout, or forced worktree used only for baseline and surrounding context}
 
-## Review Payload
+## Supplied Git Diff
 
-{complete logical representation of every manifest entry plus distinguishable unchanged caller and dependent context}
+### Staged
 
-## Reviewer Strategy
+{complete staged diff, or "No staged changes."}
 
-{concise diagnostic description of how this platform established observational access and made mutation, downstream execution, delegation-equivalent behavior, and orchestration re-entry unavailable}
+### Unstaged
 
-## Workspace Equivalence Guard
+{complete unstaged diff, or "No unstaged tracked changes."}
 
-Validate the manifest and payload before ordinary review:
+## Supplied Untracked Files
 
-1. Every manifest path and state is represented.
-2. Staged, unstaged, untracked, deleted, and renamed changes are preserved.
-3. Content and snapshot identities match.
-4. Supporting caller or dependent context is distinguishable from changed content.
-5. No unexplained changed path, stale content, mixed-round content, or unverifiable entry exists.
+{path and full content of every untracked file, or "No untracked files."}
 
-Physical path, checkout layout, host, or transport may differ. Content-equivalent current state is the invariant.
+Treat the supplied diffs, path states, and untracked file contents as the authoritative current change. Use read-only file inspection for targeted surrounding context, callers, dependents, contracts, and tests. Do not depend on shell or Git execution being available.
 
-If equivalence cannot be proven, stop before ordinary review and return `WORKSPACE_MISMATCH` with concrete mismatch evidence. Do not return code findings from an unverified snapshot.
+If a platform-forced worktree does not contain the active checkout's dirty or untracked changes, use the worktree only for baseline and surrounding-context reads. You are not required to calculate hashes or prove equivalence between physical checkouts. If an essential changed file or diff is missing from the supplied input, return `BLOCKED` and identify exactly what is missing.
 
-## Complete Current-State Review
+## Complete Current-Change Review
 
-Review the complete current change set independently. Do not limit inspection to files changed by the latest repair or to previously identified categories.
+Review the complete current change independently. Do not limit inspection to one file or one suspected issue.
 
 Evaluate applicable dimensions:
 
@@ -79,60 +78,43 @@ Evaluate applicable dimensions:
 10. Test adequacy and evidence compatibility
 11. Project-rule compliance
 
-Use both inspection directions inside this one review:
+Use both directions in this review:
 
 - Code-forward: changed code → affected symbols → callers and dependents → concrete failure scenarios
 - Requirement-backward: requirements and contracts → required behavior → implementation path → side effects → test evidence
 
-Read unchanged callers, dependents, or shared patterns when needed to evaluate impact.
+Read unchanged callers, dependents, shared patterns, or tests when needed. Prefer targeted read-only inspection. Do not perform a broad repository scan without a concrete cross-cutting reason.
 
-## Review Efficiency
+## Finding Standard
 
-Complete the review directly instead of delegating it. Prefer direct read-only inspection and targeted verification.
-
-Use existing valid test evidence when it answers the question. Prefer the narrowest verification that can establish or refute a concrete issue. Do not rerun an equivalent check when relevant code and inputs have not changed.
-
-Avoid broad builds, tests, lint, or type checks as exploratory defaults. A broad command remains valid when a concrete cross-cutting risk genuinely requires it; state why narrower evidence is insufficient.
-
-Non-normative examples:
-
-- A repository-wide test or build without a concrete reason is often redundant with the formal Test Gate.
-- A focused module or test-case invocation is usually better when investigating one failure scenario.
-
-These examples do not prohibit command names. The governing rule is targeted, non-duplicative evidence gathering.
-
-## Finding Coverage
-
-Report every concrete issue you find, including uncertain or low-severity issues. Do not filter for importance or confidence; the Main Agent performs downstream filtering. Exclude pure style or naming preferences that cannot cause incorrect behavior, contract drift, regression, security weakness, or misleading evidence.
+Report every concrete defect you find, including low-severity issues. Exclude pure style preferences and speculative concerns that lack a concrete wrong behavior, contract violation, regression path, security weakness, data-integrity risk, or misleading test result.
 
 ## Output Contract
 
 Respond with exactly this structure:
 
-### Result: PASS | NEEDS_FIXES | WORKSPACE_MISMATCH | REVIEW_INFRASTRUCTURE_BLOCKED
+### Result: PASS | FINDINGS | BLOCKED
 
-### Execution Compliance
-- Status: COMPLIANT | BLOCKED
-- Descendant execution units created: 0
-- Delegation depth: 0
+### Findings
 
-### Snapshot Verification
-- Status: VERIFIED | FAILED
-- Identity: <snapshot identity or mismatch summary>
+If the result is `PASS`, write:
 
-### Findings
-(If PASS, write "No issues found." If WORKSPACE_MISMATCH or REVIEW_INFRASTRUCTURE_BLOCKED, include only blocker evidence and required action.)
+No issues found.
 
-#### Finding N
+If the result is `BLOCKED`, write only the missing capability or essential context and the required action.
+
+If the result is `FINDINGS`, repeat this block for every concrete issue:
+
+#### Finding N: <short title>
 - Severity: high | medium | low
-- Confidence: high | medium | low
-- Dimension: requirement-alignment | defect | completeness | error-handling | security | data-integrity | concurrency | contract | compatibility | test-quality | rules-compliance
 - Location: filepath:line (or "project-level")
 - Problem: concrete wrong behavior and why it matters
 - Failure scenario: inputs or state that produce the wrong result
-- Suggestion: recommended repair approach
+- Reasoning: concise evidence connecting the current code to the failure
+- Suggested repair: smallest safe repair approach
 - Verification: how to prove the repair
 
 ### Summary
-One or two sentences describing the verified current state and overall result. Do not expose private reasoning traces.
+
+One or two sentences describing the current change and result. Do not expose private reasoning traces.
 ```

package/bundled/skills/prizmkit-code-review/scripts/render_review_report.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Render review-report.md from completed structured review state."""
+"""Render the final review-report.md from minimal review data."""
 
 from __future__ import annotations
 
@@ -9,102 +9,94 @@ import sys
 from pathlib import Path
 from typing import Any
 
-VERDICTS = {"PASS", "NEEDS_FIXES"}
-EXECUTION_PROTOCOLS = {"BLOCKED", "COMPLIANT", "NOT_APPLICABLE", "VIOLATION"}
-ATTESTATIONS = {"FAILED", "NOT_APPLICABLE", "VERIFIED"}
-SNAPSHOT_STATUSES = {"FAILED", "NOT_APPLICABLE", "VERIFIED"}
-BLOCKERS = {
-    "INVALID_REVIEW_RESULT",
-    "NONE",
-    "REVIEW_INFRASTRUCTURE_BLOCKED",
-    "REVIEW_ORCHESTRATION_VIOLATION",
-    "REVIEW_SAFETY_LIMIT_REACHED",
-    "WORKSPACE_MISMATCH",
-}
-REVIEW_MODES = {
-    "independent-reviewer-verified-snapshot",
-    "not-run-no-changes",
-}
+VERDICTS = {"PASS", "NEEDS_FIXES", "BLOCKED"}
+DISPOSITIONS = ("fixed", "rejected", "unresolved")
 
 
 class ReportStateError(ValueError):
-    """Raised when persisted state cannot produce a trustworthy report."""
+    """Raised when review data cannot produce a valid final report."""
 
 
-def _require_enum(state: dict[str, Any], name: str, allowed: set[str]) -> str:
-    value = state.get(name)
-    if value not in allowed:
-        raise ReportStateError(f"{name} has invalid value: {value!r}")
-    return value
-
-
-def _require_count(state: dict[str, Any], name: str) -> int:
-    value = state.get(name)
+def _require_count(data: dict[str, Any], name: str) -> int:
+    value = data.get(name)
     if not isinstance(value, int) or isinstance(value, bool) or value < 0:
         raise ReportStateError(f"{name} must be a non-negative integer")
     return value
 
 
-def validate_state(state: Any) -> dict[str, Any]:
-    """Validate the minimum completed state required for report regeneration."""
-    if not isinstance(state, dict):
-        raise ReportStateError("state must be a JSON object")
-
-    _require_enum(state, "verdict", VERDICTS)
-    _require_enum(state, "review_mode", REVIEW_MODES)
-    _require_enum(state, "execution_protocol", EXECUTION_PROTOCOLS)
-    _require_enum(state, "capability_attestation", ATTESTATIONS)
-    _require_enum(state, "snapshot_verification", SNAPSHOT_STATUSES)
-    _require_enum(state, "blocker_code", BLOCKERS)
-    rounds_completed = _require_count(state, "rounds_completed")
-    reviewers_started = _require_count(state, "reviewers_started")
-    descendants = _require_count(state, "descendant_execution_units_observed")
-    delegation_depth = _require_count(state, "delegation_depth_observed")
-
-    rounds = state.get("rounds")
-    findings = state.get("findings")
-    if not isinstance(rounds, list) or not isinstance(findings, list):
-        raise ReportStateError("rounds and findings must be arrays")
-    if rounds_completed != len(rounds):
-        raise ReportStateError("rounds_completed must equal the rounds array length")
-    if reviewers_started < rounds_completed:
-        raise ReportStateError("reviewers_started cannot be below rounds_completed")
-
-    if state["review_mode"] == "not-run-no-changes":
-        if any((rounds_completed, reviewers_started, descendants, delegation_depth)):
-            raise ReportStateError("no-change review cannot contain execution activity")
-        if state["verdict"] != "PASS":
-            raise ReportStateError("no-change review must have PASS verdict")
-
-    if state["verdict"] == "PASS" and state["blocker_code"] != "NONE":
-        raise ReportStateError("PASS cannot include a blocker code")
-    if state["execution_protocol"] == "COMPLIANT":
-        if descendants != 0 or delegation_depth != 0:
-            raise ReportStateError("COMPLIANT execution requires zero descendants and depth")
+def validate_data(data: Any) -> dict[str, Any]:
+    if not isinstance(data, dict):
+        raise ReportStateError("review data must be a JSON object")
+
+    verdict = data.get("verdict")
+    if verdict not in VERDICTS:
+        raise ReportStateError(f"verdict has invalid value: {verdict!r}")
+
+    rounds_completed = _require_count(data, "rounds_completed")
+    if rounds_completed > 10:
+        raise ReportStateError("rounds_completed cannot exceed ten")
+
+    findings = data.get("findings")
+    if not isinstance(findings, list):
+        raise ReportStateError("findings must be an array")
+
+    summary = data.get("summary")
+    if not isinstance(summary, str) or not summary.strip():
+        raise ReportStateError("summary must be a non-empty string")
 
     for index, finding in enumerate(findings, start=1):
         if not isinstance(finding, dict):
             raise ReportStateError(f"finding {index} must be an object")
-        required = {"title", "severity", "dimension", "location", "problem", "failure_scenario", "status"}
+        required = {
+            "title",
+            "severity",
+            "location",
+            "problem",
+            "failure_scenario",
+            "disposition",
+        }
         missing = sorted(required - finding.keys())
         if missing:
             raise ReportStateError(
                 f"finding {index} missing fields: {', '.join(missing)}"
             )
-
-    return state
+        disposition = finding["disposition"]
+        if not isinstance(disposition, str) or not disposition.startswith(DISPOSITIONS):
+            raise ReportStateError(f"finding {index} has invalid disposition")
+
+    unresolved = sum(
+        finding["disposition"].startswith("unresolved") for finding in findings
+    )
+    blocker = data.get("blocker")
+
+    if verdict == "PASS" and unresolved:
+        raise ReportStateError("PASS cannot contain unresolved findings")
+    if verdict == "NEEDS_FIXES" and not unresolved:
+        raise ReportStateError("NEEDS_FIXES requires an unresolved finding")
+    if verdict == "BLOCKED":
+        if not isinstance(blocker, str) or not blocker.strip():
+            raise ReportStateError("BLOCKED requires a non-empty blocker")
+        if unresolved:
+            raise ReportStateError("BLOCKED cannot classify code findings as unresolved")
+    elif blocker is not None:
+        raise ReportStateError("only BLOCKED may include blocker")
+
+    return data
 
 
 def _finding_totals(findings: list[dict[str, Any]]) -> tuple[int, int, int]:
-    fixed = sum(finding["status"].startswith("fixed") for finding in findings)
-    rejected = sum(finding["status"].startswith("rejected") for finding in findings)
-    unresolved = len(findings) - fixed - rejected
+    fixed = sum(finding["disposition"].startswith("fixed") for finding in findings)
+    rejected = sum(
+        finding["disposition"].startswith("rejected") for finding in findings
+    )
+    unresolved = sum(
+        finding["disposition"].startswith("unresolved") for finding in findings
+    )
     return fixed, rejected, unresolved
 
 
-def render_report(state: Any) -> str:
-    """Return deterministic Markdown without launching or resuming a Reviewer."""
-    valid = validate_state(state)
+def render_report(data: Any) -> str:
+    valid = validate_data(data)
     findings = valid["findings"]
     fixed, rejected, unresolved = _finding_totals(findings)
 
@@ -113,69 +105,51 @@ def render_report(state: Any) -> str:
         "",
         f"## Verdict: {valid['verdict']}",
         f"## Rounds Completed: {valid['rounds_completed']}",
-        f"## Reviewers Started: {valid['reviewers_started']}",
-        f"## Review Mode: {valid['review_mode']}",
-        f"## Reviewer Strategy: {valid.get('reviewer_strategy', 'not-applicable')}",
-        f"## Execution Protocol: {valid['execution_protocol']}",
-        f"## Capability Attestation: {valid['capability_attestation']}",
-        f"## Descendant Execution Units Observed: {valid['descendant_execution_units_observed']}",
-        f"## Delegation Depth Observed: {valid['delegation_depth_observed']}",
-        f"## Snapshot Verification: {valid['snapshot_verification']}",
-        f"## Snapshot Identity: {valid.get('snapshot_identity', 'not-applicable')}",
-        f"## Blocker Code: {valid['blocker_code']}",
         f"## Total Findings: {len(findings)} → Fixed: {fixed}, Rejected: {rejected}, Unresolved: {unresolved}",
         "",
     ]
 
-    if valid["review_mode"] == "not-run-no-changes":
-        lines.extend(["## Round 0: PASS — no workspace changes to review", ""])
-    else:
-        for review_round in valid["rounds"]:
+    if findings:
+        lines.extend(["## Findings", ""])
+        for index, finding in enumerate(findings, start=1):
             lines.extend(
                 [
-                    f"## Round {review_round['round']}",
+                    f"### Finding {index}: {finding['title']}",
                     "",
-                    f"- Snapshot Identity: {review_round['snapshot_identity']}",
-                    f"- Reviewer Execution Identity: {review_round['reviewer_execution_identity']}",
-                    f"- Result: {review_round['result']}",
-                    f"- Findings: {review_round['findings_count']}",
-                    f"- Accepted: {review_round['accepted_count']}",
-                    f"- Rejected: {review_round['rejected_count']}",
+                    f"- Severity: {finding['severity']}",
+                    f"- Location: {finding['location']}",
+                    f"- Problem: {finding['problem']}",
+                    f"- Failure Scenario: {finding['failure_scenario']}",
+                    f"- Disposition: {finding['disposition']}",
                     "",
                 ]
             )
 
-    for index, finding in enumerate(findings, start=1):
-        lines.extend(
-            [
-                f"### Finding {index}: {finding['title']}",
-                "",
-                f"- Severity: {finding['severity']}",
-                f"- Dimension: {finding['dimension']}",
-                f"- Location: {finding['location']}",
-                f"- Problem: {finding['problem']}",
-                f"- Failure Scenario: {finding['failure_scenario']}",
-                f"- Status: {finding['status']}",
-                "",
-            ]
-        )
-
-    lines.extend(["## Final Summary", "", valid["final_summary"], ""])
+    if valid["verdict"] == "BLOCKED":
+        lines.extend(["## Blocker", "", valid["blocker"], ""])
+
+    lines.extend(["## Summary", "", valid["summary"], ""])
     return "\n".join(lines)
 
 
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("state", type=Path, help="completed review-result-state.json")
     parser.add_argument("output", type=Path, help="review-report.md destination")
+    parser.add_argument(
+        "input",
+        nargs="?",
+        type=Path,
+        help="optional JSON input path; reads standard input when omitted",
+    )
     return parser.parse_args()
 
 
 def main() -> int:
     args = parse_args()
     try:
-        state = json.loads(args.state.read_text(encoding="utf-8"))
-        report = render_report(state)
+        raw = args.input.read_text(encoding="utf-8") if args.input else sys.stdin.read()
+        data = json.loads(raw)
+        report = render_report(data)
         args.output.parent.mkdir(parents=True, exist_ok=True)
         args.output.write_text(report, encoding="utf-8")
     except (OSError, json.JSONDecodeError, ReportStateError, KeyError) as error:

package/package.json

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