prizmkit 1.1.124 → 1.1.126

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."""
+"""Initialize and append validated sections to review-report.md."""
 
 from __future__ import annotations
 
@@ -9,180 +9,286 @@ 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"}
+RISKS = {"low", "medium", "high"}
+EVENTS = {
+    "risk-assessment",
+    "main-review-round",
+    "repair-verification",
+    "reviewer-running",
+    "reviewer-result",
+    "infrastructure-failure",
+    "final-verification",
 }
+FINAL_HEADING = "## Final Result"
 
 
 class ReportStateError(ValueError):
-    """Raised when persisted state cannot produce a trustworthy report."""
+    """Raised when an operation would produce an invalid report lifecycle."""
 
 
-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_object(data: Any) -> dict[str, Any]:
+    if not isinstance(data, dict):
+        raise ReportStateError("input must be a JSON object")
+    return data
+
 
+def _require_text(data: dict[str, Any], name: str) -> str:
+    value = data.get(name)
+    if not isinstance(value, str) or not value.strip():
+        raise ReportStateError(f"{name} must be a non-empty string")
+    return value.strip()
 
-def _require_count(state: dict[str, Any], name: str) -> int:
-    value = state.get(name)
+
+def _require_count(data: dict[str, Any], name: str, *, maximum: int | None = None) -> 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")
+    if maximum is not None and value > maximum:
+        raise ReportStateError(f"{name} cannot exceed {maximum}")
     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")
-
-    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"}
-        missing = sorted(required - finding.keys())
-        if missing:
-            raise ReportStateError(
-                f"finding {index} missing fields: {', '.join(missing)}"
-            )
-
-    return state
-
-
-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
-    return fixed, rejected, unresolved
-
-
-def render_report(state: Any) -> str:
-    """Return deterministic Markdown without launching or resuming a Reviewer."""
-    valid = validate_state(state)
-    findings = valid["findings"]
-    fixed, rejected, unresolved = _finding_totals(findings)
-
-    lines = [
-        "# Review Report",
-        "",
-        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"]:
-            lines.extend(
-                [
-                    f"## Round {review_round['round']}",
-                    "",
-                    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']}",
-                    "",
-                ]
-            )
-
-    for index, finding in enumerate(findings, start=1):
-        lines.extend(
+def _require_risk(data: dict[str, Any]) -> str:
+    risk = data.get("risk")
+    if risk not in RISKS:
+        raise ReportStateError(f"risk has invalid value: {risk!r}")
+    return risk
+
+
+def _report_text(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8")
+    except FileNotFoundError as error:
+        raise ReportStateError("report must be initialized before append") from error
+
+
+def _ensure_appendable(path: Path) -> None:
+    text = _report_text(path)
+    if "## Status: IN_PROGRESS" not in text:
+        raise ReportStateError("report is not an initialized in-progress execution")
+    if FINAL_HEADING in text:
+        raise ReportStateError("cannot append after Final Result")
+
+
+def _append_section(path: Path, section: str) -> None:
+    with path.open("a", encoding="utf-8") as report:
+        report.write(section.rstrip() + "\n\n")
+
+
+def initialize_report(path: Path) -> None:
+    """Start a new execution and remove stale prior execution content."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("# Review Report\n\n## Status: IN_PROGRESS\n\n", encoding="utf-8")
+
+
+def _render_event(data: dict[str, Any]) -> str:
+    event = data.get("event")
+    if event not in EVENTS:
+        raise ReportStateError(f"event has invalid value: {event!r}")
+
+    if event == "risk-assessment":
+        risk = _require_risk(data)
+        reasons = data.get("reasons")
+        if not isinstance(reasons, list) or not reasons or not all(
+            isinstance(reason, str) and reason.strip() for reason in reasons
+        ):
+            raise ReportStateError("reasons must be a non-empty string array")
+        limit = {"low": 0, "medium": 1, "high": 2}[risk]
+        lines = [
+            "## Risk Assessment",
+            "",
+            f"- Risk: {risk}",
+            f"- Independent Reviewer Limit: {limit}",
+            "- Reasons:",
+        ]
+        lines.extend(f"  - {reason.strip()}" for reason in reasons)
+        return "\n".join(lines)
+
+    if event == "main-review-round":
+        round_number = _require_count(data, "round", maximum=10)
+        if round_number < 1:
+            raise ReportStateError("round must be at least 1")
+        findings = _require_count(data, "findings")
+        accepted = _require_count(data, "accepted")
+        rejected = _require_count(data, "rejected")
+        if accepted + rejected != findings:
+            raise ReportStateError("accepted + rejected must equal findings")
+        return "\n".join(
+            [
+                f"## Main Review Round {round_number}",
+                "",
+                "- Status: COMPLETED",
+                f"- Findings: {findings}",
+                f"- Accepted: {accepted}",
+                f"- Rejected: {rejected}",
+                f"- Next: {_require_text(data, 'next')}",
+            ]
+        )
+
+    if event == "repair-verification":
+        source = _require_text(data, "source")
+        if source not in {"main", "reviewer-1", "reviewer-2"}:
+            raise ReportStateError(f"source has invalid value: {source!r}")
+        return "\n".join(
+            [
+                "## Repair Verification",
+                "",
+                f"- Source: {source}",
+                f"- Fixed Findings: {_require_count(data, 'fixed_findings')}",
+                f"- Verification: {_require_text(data, 'verification')}",
+                f"- Next: {_require_text(data, 'next')}",
+            ]
+        )
+
+    if event == "reviewer-running":
+        reviewer = _require_count(data, "reviewer", maximum=2)
+        if reviewer < 1:
+            raise ReportStateError("reviewer must be 1 or 2")
+        risk = _require_risk(data)
+        if risk == "low" or (risk == "medium" and reviewer == 2):
+            raise ReportStateError("reviewer exceeds the semantic risk limit")
+        attempt = data.get("attempt", 1)
+        if attempt not in {1, 2}:
+            raise ReportStateError("attempt must be 1 or 2")
+        return "\n".join(
             [
-                f"### Finding {index}: {finding['title']}",
+                f"## Independent Reviewer {reviewer}",
                 "",
-                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']}",
+                "- Status: RUNNING",
+                f"- Risk Trigger: {risk}",
+                f"- Attempt: {attempt}",
+            ]
+        )
+
+    if event == "reviewer-result":
+        reviewer = _require_count(data, "reviewer", maximum=2)
+        if reviewer < 1:
+            raise ReportStateError("reviewer must be 1 or 2")
+        result = data.get("result")
+        if result not in {"PASS", "FINDINGS", "BLOCKED"}:
+            raise ReportStateError(f"result has invalid value: {result!r}")
+        findings = _require_count(data, "findings")
+        accepted = _require_count(data, "accepted")
+        rejected = _require_count(data, "rejected")
+        accepted_high = _require_count(data, "accepted_high")
+        if accepted + rejected != findings or accepted_high > accepted:
+            raise ReportStateError("reviewer finding counts are inconsistent")
+        status = "BLOCKED" if result == "BLOCKED" else "COMPLETED"
+        return "\n".join(
+            [
+                f"## Independent Reviewer {reviewer} Result",
+                "",
+                f"- Status: {status}",
+                f"- Result: {result}",
+                f"- Findings: {findings}",
+                f"- Accepted: {accepted}",
+                f"- Rejected: {rejected}",
+                f"- Accepted High: {accepted_high}",
+                f"- Next: {_require_text(data, 'next')}",
+            ]
+        )
+
+    if event == "infrastructure-failure":
+        reviewer = _require_count(data, "reviewer", maximum=2)
+        attempt = _require_count(data, "attempt", maximum=2)
+        if reviewer < 1 or attempt < 1:
+            raise ReportStateError("reviewer and attempt must be at least 1")
+        return "\n".join(
+            [
+                f"## Independent Reviewer {reviewer} Infrastructure Failure",
                 "",
+                f"- Attempt: {attempt}",
+                f"- Evidence: {_require_text(data, 'evidence')}",
+                f"- Next: {_require_text(data, 'next')}",
             ]
         )
 
-    lines.extend(["## Final Summary", "", valid["final_summary"], ""])
-    return "\n".join(lines)
+    return "\n".join(
+        [
+            "## Final Verification",
+            "",
+            f"- Status: {_require_text(data, 'status')}",
+            f"- Evidence: {_require_text(data, 'evidence')}",
+        ]
+    )
+
+
+def append_event(path: Path, data: Any) -> None:
+    """Append one validated progress event to an active execution."""
+    _ensure_appendable(path)
+    _append_section(path, _render_event(_require_object(data)))
+
+
+def append_final_result(path: Path, data: Any) -> None:
+    """Append the sole terminal result for the current execution."""
+    _ensure_appendable(path)
+    valid = _require_object(data)
+    verdict = valid.get("verdict")
+    if verdict not in VERDICTS:
+        raise ReportStateError(f"verdict has invalid value: {verdict!r}")
+    risk = _require_risk(valid)
+    main_rounds = _require_count(valid, "main_review_rounds", maximum=10)
+    reviewers = _require_count(valid, "independent_reviewers_started", maximum=2)
+    if reviewers > {"low": 0, "medium": 1, "high": 2}[risk]:
+        raise ReportStateError("independent_reviewers_started exceeds risk limit")
+    accepted = _require_count(valid, "accepted_findings")
+    fixed = _require_count(valid, "fixed_findings")
+    rejected = _require_count(valid, "rejected_findings")
+    unresolved = _require_count(valid, "unresolved_findings")
+    if verdict == "PASS" and unresolved:
+        raise ReportStateError("PASS cannot contain unresolved findings")
+    if verdict == "NEEDS_FIXES" and not unresolved:
+        raise ReportStateError("NEEDS_FIXES requires unresolved findings")
+
+    section = "\n".join(
+        [
+            FINAL_HEADING,
+            "",
+            f"- Verdict: {verdict}",
+            f"- Risk: {risk}",
+            f"- Main Review Rounds: {main_rounds}",
+            f"- Independent Reviewers Started: {reviewers}",
+            f"- Accepted Findings: {accepted}",
+            f"- Fixed Findings: {fixed}",
+            f"- Rejected Findings: {rejected}",
+            f"- Unresolved Findings: {unresolved}",
+            f"- Summary: {_require_text(valid, 'summary')}",
+        ]
+    )
+    _append_section(path, section)
+
+
+def _read_json_input() -> Any:
+    try:
+        return json.loads(sys.stdin.read())
+    except json.JSONDecodeError as error:
+        raise ReportStateError(f"invalid JSON input: {error}") from error
 
 
 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")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    for command in ("init", "append", "finalize"):
+        subparser = subparsers.add_parser(command)
+        subparser.add_argument("report", type=Path)
     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)
-        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:
+        if args.command == "init":
+            initialize_report(args.report)
+        elif args.command == "append":
+            append_event(args.report, _read_json_input())
+        else:
+            append_final_result(args.report, _read_json_input())
+    except (OSError, ReportStateError, KeyError) as error:
         print(json.dumps({"error": str(error)}, sort_keys=True))
         return 1
     return 0
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    raise SystemExit(main())

package/package.json

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