prizmkit 1.1.124 → 1.1.126

package/bundled/dev-pipeline/tests/test_runtime_helper.py

@@ -75,6 +75,42 @@ class TestArtifactAndTextHelpers:
         missing = run_helper("text", "contains", str(target), "--pattern", "gamma")
         assert first_line(missing) == "GATE:MISSING"
 
+    def test_final_verdict_requires_last_final_result_section(self, tmp_path):
+        report = tmp_path / "review-report.md"
+        report.write_text(
+            "# Review Report\n\n## Status: IN_PROGRESS\n\n"
+            "## Main Review Round 1\n\n- Note: incidental PASS text\n",
+            encoding="utf-8",
+        )
+        incomplete = run_helper("text", "final-verdict", str(report))
+        assert incomplete.returncode != 0
+        assert first_line(incomplete) == "REVIEW_INCOMPLETE"
+
+        report.write_text(
+            report.read_text(encoding="utf-8")
+            + "\n## Final Result\n\n- Verdict: PASS\n- Summary: done\n",
+            encoding="utf-8",
+        )
+        complete = run_helper("text", "final-verdict", str(report))
+        assert complete.returncode == 0
+        assert first_line(complete) == "REVIEW_PASS"
+        assert "verdict: PASS" in complete.stdout
+
+    def test_final_verdict_uses_last_final_result_and_rejects_unknown_value(self, tmp_path):
+        report = tmp_path / "review-report.md"
+        report.write_text(
+            "## Final Result\n- Verdict: PASS\n\n"
+            "## Final Result\n- Verdict: BLOCKED\n",
+            encoding="utf-8",
+        )
+        blocked = run_helper("text", "final-verdict", str(report))
+        assert first_line(blocked) == "REVIEW_BLOCKED"
+
+        report.write_text("## Final Result\n- Verdict: UNKNOWN\n", encoding="utf-8")
+        invalid = run_helper("text", "final-verdict", str(report))
+        assert invalid.returncode != 0
+        assert first_line(invalid) == "REVIEW_INVALID"
+
 
 class TestPlatformExecutableAndPortHelpers:
     def test_platform_detection_and_skill_lookup_follow_config(self, tmp_path, monkeypatch):

package/bundled/dev-pipeline/tests/test_unified_cli.py

@@ -811,7 +811,7 @@ def test_session_preamble_writes_redacted_start_command_for_all_launch_profiles(
             assert str(prompt) not in "\n".join(lines[:6])
 
 
-def test_headless_review_guidance_uses_workspace_and_execution_protocols():
+def test_headless_review_guidance_uses_risk_routed_dual_layer_loop():
     headless_guidance_files = [
         REPO_ROOT / "dev-pipeline" / "templates" / "sections" / "phase-review-full.md",
         REPO_ROOT / "dev-pipeline" / "templates" / "bootstrap-tier3.md",
@@ -827,25 +827,32 @@ def test_headless_review_guidance_uses_workspace_and_execution_protocols():
 
     for path in headless_guidance_files:
         text = path.read_text(encoding="utf-8")
-        assert "platform-supported" in text, path
-        assert "snapshot" in text and "equivalent" in text, path
         assert "Main-Agent self-review" in text, path
+        assert "low=0" in text and "medium=1" in text and "high=2" in text, path
+        assert "Reviewer 3 is forbidden" in text, path
+        assert "text final-verdict" in text, path
+        assert "workspace-equivalent" not in text, path
+        assert "workspace protocol" not in text, path
         assert "current-workspace / active-checkout / no-worktree" not in text, path
         assert ".claude/worktrees/..." not in text, path
         assert ".prizmkit/state/worktrees/..." not in text, path
         assert "USE_WORKTREE" not in text, path
         assert "isolation:" not in text, path
-        assert "Read existing source files in the modules this plan touches" not in text, path
 
     skill_text = skill_path.read_text(encoding="utf-8")
-    assert "reviewer-workspace-protocol.md" in skill_text
-    assert "reviewer-execution-protocol.md" in skill_text
-    assert "staged, unstaged, untracked, deleted, and renamed" in skill_text
-    assert "content-equivalent" in skill_text
-    assert "WORKSPACE_MISMATCH" in skill_text
-    assert "REVIEW_INFRASTRUCTURE_BLOCKED" in skill_text
-    assert "do not substitute Main-Agent self-review" in skill_text
-    assert "platform-specific role" in skill_text
+    assert "staged and unstaged tracked changes" in skill_text
+    assert "untracked files" in skill_text
+    assert "accepted = 0" in skill_text
+    assert "low: 0" in skill_text and "medium: 1" in skill_text and "high: 2" in skill_text
+    assert "accepted high-severity finding" in skill_text
+    assert "Do not launch Reviewer 3" in skill_text
+    assert "## Final Result" in skill_text
+    assert "BLOCKED" in skill_text
+    assert "Do not substitute Main-Agent self-review" in skill_text
+    assert "reviewer-workspace-protocol.md" not in skill_text
+    assert "reviewer-execution-protocol.md" not in skill_text
+    assert "WORKSPACE_MISMATCH" not in skill_text
+    assert "REVIEW_INFRASTRUCTURE_BLOCKED" not in skill_text
 
 
 def test_progress_parser_adds_required_metadata(tmp_path):
@@ -2227,6 +2234,7 @@ def test_materialize_worktree_support_assets_copies_ignored_assets_without_retir
     (repo / ".prizmkit" / "dev-pipeline" / "prizmkit_runtime").mkdir(parents=True)
     (repo / ".prizmkit" / "dev-pipeline" / "prizmkit_runtime" / "__init__.py").write_text("", encoding="utf-8")
     (repo / ".prizmkit" / "dev-pipeline" / "prizmkit_runtime" / "runtime_helper.py").write_text("# helper", encoding="utf-8")
+    (repo / ".prizmkit" / "dev-pipeline" / "prizmkit_runtime" / "task_checkout.py").write_text("# checkout", encoding="utf-8")
     (repo / ".prizmkit" / "dev-pipeline" / "run-feature.sh").write_text("retired", encoding="utf-8")
 
     runtime = worktree_runtime_context(
@@ -2247,6 +2255,7 @@ def test_materialize_worktree_support_assets_copies_ignored_assets_without_retir
     assert (runtime.worktree_path / ".prizmkit" / "dev-pipeline" / "scripts" / "update-checkpoint.py").is_file()
     assert (runtime.worktree_path / ".prizmkit" / "dev-pipeline" / "prizmkit_runtime" / "__init__.py").is_file()
     assert (runtime.worktree_path / ".prizmkit" / "dev-pipeline" / "prizmkit_runtime" / "runtime_helper.py").is_file()
+    assert (runtime.worktree_path / ".prizmkit" / "dev-pipeline" / "prizmkit_runtime" / "task_checkout.py").is_file()
     assert not (runtime.worktree_path / ".prizmkit" / "dev-pipeline" / "run-feature.sh").exists()
 
     assert guarded_worktree_remove(runtime, delete_branch=False).ok

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.124",
+  "version": "1.1.126",
   "skills": {
     "prizmkit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",
@@ -30,11 +30,11 @@
       "hasScripts": false
     },
     "prizmkit-code-review": {
-      "description": "Code review with fix strategy formulation. Diagnoses issues, then produces structured Fix Instructions with root cause, impact analysis, and verification criteria.",
+      "description": "Independent read-only review with Main-Agent finding adjudication, direct repairs, bounded convergence, and a minimal final report.",
       "tier": "1",
       "category": "prizmkit-skill",
-      "hasAssets": false,
-      "hasScripts": false
+      "hasAssets": true,
+      "hasScripts": true
     },
     "prizmkit-committer": {
       "description": "Pure git commit workflow with safety checks. Does NOT modify .prizmkit/prizm-docs/.",

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

@@ -1,175 +1,202 @@
 ---
 name: "prizmkit-code-review"
-description: "Run a fail-closed, convergence-driven independent code review against the current spec, plan, complete workspace snapshot, applicable rules, contracts, and test evidence. Use after /prizmkit-implement, before commit when review is required, or whenever the user asks to review code, validate an implementation, find defects, assess regressions, or decide whether changes are ready. Each round launches exactly one fresh read-only non-delegating Reviewer, validates execution and workspace compliance, then has the Main Agent filter and directly fix accepted findings until PASS or the internal safety fuse stops review. (project)"
+description: "Run a risk-routed dual-layer code review against the current spec, plan, workspace changes, applicable rules, contracts, and test evidence. The Main Agent first self-reviews and repairs for up to ten rounds, then semantic risk determines whether zero, one, or two fresh read-only independent Reviewers are required. Findings remain Main-Agent adjudicated, Reviewer 3 is forbidden, and one append-only progress report records the execution through PASS, NEEDS_FIXES, or BLOCKED. (project)"
 ---
 
 # PrizmKit Code Review
 
-Run an independent review-fix loop until the current implementation converges. One fresh Reviewer performs each complete review; the Main Agent alone controls rounds, filters findings, and applies accepted fixes.
-
-The safety boundary is fail-closed. A Reviewer may run only when its execution environment makes workspace mutation, downstream execution creation, delegation-equivalent behavior, and orchestration re-entry unavailable. Prompt promises alone do not establish this boundary.
+Use a dual-layer review loop: the Main Agent owns iterative review and repair, while fresh independent Reviewers act only as semantic-risk gates.
 
 ## When to Use
 
 - After `/prizmkit-implement` as the Full path quality gate
-- For Fast path when scope, risk, or the user warrants review
-- When the user asks to review code, validate implementation, find defects, check regressions, or assess commit readiness
-- Before `/prizmkit-committer` when the selected lifecycle requires review
-
-## When Not to Use
-
-- Direct edit or low-risk Fast path where review is intentionally skipped
-- No task goal, specification, plan, or other review contract can be identified
-- Trivial changes the user explicitly wants committed without review
+- For Fast path when behavior, risk, or the user warrants review
+- When the user asks to validate implementation, find defects, assess regressions, or decide commit readiness
 
 ## Input
 
 | Parameter | Required | Description |
 |---|---|---|
-| `artifact_dir` | No | Directory containing `spec.md` and `plan.md`. Reuse a caller-provided directory. Otherwise locate the most recently modified completed change artifact under `.prizmkit/`. |
+| `artifact_dir` | No | Directory containing `spec.md` and `plan.md`. Reuse a caller-provided directory; otherwise locate the current completed change artifact. |
 
-## Authoritative Protocols
+## Required Assets
 
-Read these references before starting Phase 1:
+- `${SKILL_DIR}/references/reviewer-agent-prompt.md`: independent Reviewer input and output contract
+- `${SKILL_DIR}/references/review-report-template.md`: report lifecycle and append contract
+- `${SKILL_DIR}/assets/reviewer-role.json`: semantic read-only and non-delegating Reviewer boundary
 
-- `${SKILL_DIR}/references/reviewer-execution-protocol.md`: mandatory execution topology, capability attestation, fail-closed behavior, and convergence rules
-- `${SKILL_DIR}/references/reviewer-workspace-protocol.md`: deterministic complete snapshots, content identities, transport reuse, and mismatch handling
-- `${SKILL_DIR}/references/reviewer-agent-prompt.md`: complete Reviewer prompt contract; fill placeholders without summarizing or omitting normative sections
-- `${SKILL_DIR}/assets/reviewer-role.json`: canonical semantic capability manifest used by platform adapters to construct enforceable Reviewer roles
+Do not weaken or summarize the Reviewer prompt. The protocol specifies semantic capabilities rather than platform-specific tool names.
 
-The protocol describes semantic capabilities rather than a platform-specific command or tool denylist. Current platform names in references are non-normative recognition examples only.
+## Phase 0: Initialize Report and Collect Context
 
-## Phase 0: Context and Initial Snapshot
+1. Resolve `{artifact_dir}` and `{artifact_dir}/review-report.md`.
+2. replace any prior report with a new execution header using the report template. The new report begins with `## Status: IN_PROGRESS` and contains no prior Final Result.
+3. Read `spec.md`, `plan.md`, relevant `/prizmkit-test` evidence, `.prizmkit/prizm-docs/root.prizm`, applicable progressive docs, and project rules.
+4. Inspect and capture the complete current Git change:
+   - staged and unstaged tracked changes;
+   - untracked files;
+   - deleted and renamed files;
+   - relevant unchanged callers, dependents, contracts, and tests.
+5. Preserve the existing Reviewer input behavior: staged and unstaged Git diffs, full content of every untracked file, and explicit deleted/renamed states.
+6. If no changes exist, append risk `low` and exactly one final result with `PASS`, then finish without a Reviewer.
 
-1. Read `spec.md` and extract goals plus acceptance criteria.
-2. Read `plan.md` and extract architecture decisions plus completed tasks.
-3. Read scoped `/prizmkit-test` evidence when `{artifact_dir}/test-report-path.txt` exists. Preserve scope, generated or updated tests, in-scope failures, baseline failures, gaps, boundary evidence, and verdict.
-4. Read `.prizmkit/prizm-docs/root.prizm` and applicable project rules. Load only relevant progressive documentation.
-5. Capture a content-equivalent complete current logical workspace according to the workspace protocol, including staged, unstaged, untracked, deleted, and renamed states. Prefer `${SKILL_DIR}/scripts/workspace_snapshot.py` when Python is available.
-6. If no changes exist, skip Reviewer launch and write a no-change `PASS` report with execution metadata `NOT_APPLICABLE`.
+### Checkout Access
 
-## Phase 1: Convergence Loop
+Prefer direct access to the active checkout. If the platform forces an isolated worktree, provide the same staged and unstaged diffs, untracked file contents, and changed-path states; use the worktree only for baseline and surrounding-context reads. Do not require workspace-equivalence proof.
 
-### Loop State
+## Phase 1: Semantic Risk Assessment
 
-Track:
+Classify the current change from behavior and failure impact, not changed-file count or a fixed path allowlist:
 
-```yaml
-round: 1
-reviewers_started_total: 0
-completed_rounds: 0
-structured_result_state: <artifact_dir>/review-result-state.json
-```
+- `low: 0` independent Reviewers — documentation, test text, mechanical change, local low-impact configuration, or trivially verifiable behavior.
+- `medium: 1` independent Reviewer — general business behavior, internal interface changes, or non-critical data processing with user-visible regression potential.
+- `high: 2` independent Reviewers maximum — payments, financial ledgers, authentication, authorization, security, migration, concurrent transactions, irreversible data operations, or public contracts.
+
+Mixed risks use the highest applicable level. A large mechanical diff is not automatically high; a small money or authorization change is high.
 
-The internal safety fuse is fixed at ten rounds. It is not caller-configurable, is not a quality target, and never converts unresolved review into `PASS`.
+Append `## Risk Assessment` with the selected risk and concrete reasons before review begins.
 
-### Step 1: Establish the Reviewer Boundary
+## Phase 2: Main-Agent Self-Review Loop
 
-1. Select a fresh Reviewer execution mechanism that satisfies every invariant in the execution protocol.
-2. Establish launch-time capability attestation. Verify that mutation, delegation-equivalent behavior, downstream execution creation, and orchestration re-entry are unavailable.
-3. Ensure the Reviewer receives the complete authoritative prompt template and current snapshot, but no prior findings, verdicts, filtering decisions, Reviewer reasoning, or fix explanations.
-4. In script mode, authorize launch through the strict preflight gate:
+The Main Agent reviews and repairs in the current context. Track Main-Agent rounds independently from Reviewer launch attempts:
 
-```bash
-python3 ${SKILL_DIR}/scripts/check_loop.py < preflight-payload.json
+```yaml
+main_review_rounds: 0
+independent_reviewers_started: 0
+reviewer_1_accepted_high: false
 ```
 
-5. Launch exactly one foreground Reviewer only when the gate returns `launchAuthorized: true`.
+Every Reviewer Agent launch attempt increments `independent_reviewers_started`, including a retry that starts a new Agent. The total may never exceed the semantic-risk limit.
 
-A platform-specific role may be used only when its actual launch configuration proves the semantic boundary. For example, an installed project role whose capability allowlist contains only observational file-inspection capabilities can establish the boundary; a generic subagent with prompt-only restrictions cannot.
+### Main-Agent Self-Review Loop
 
-If the boundary cannot be established or attested, do not launch a weaker Reviewer and do not substitute Main-Agent self-review. Stop with `NEEDS_FIXES` and blocker `REVIEW_INFRASTRUCTURE_BLOCKED`.
+Each round examines the complete current change against goals, contracts, rules, callers, dependents, regression risks, and test evidence.
 
-### Step 2: Complete Independent Review
+1. Identify concrete candidate findings.
+2. Classify each as:
+   - `accepted`: evidence supports the failure scenario;
+   - `rejected`: code or governing evidence disproves it or its regression path.
+3. Append `## Main Review Round N` with findings, accepted, rejected, and next action.
+4. Apply these rules:
 
-The fresh Reviewer performs the complete review itself. Every round evaluates the complete current change against all applicable requirements, contracts, rules, callers, dependents, regression risks, and test evidence.
+```text
+accepted = 0                                 -> self-review converged
+accepted > 0 and round < 10                  -> Main Agent directly repairs, verifies, and continues
+accepted > 0 at ten completed Main-Agent rounds -> NEEDS_FIXES
+repair cannot be completed safely            -> NEEDS_FIXES
+unresolved new in-scope test failure          -> NEEDS_FIXES
+```
+
+When all findings are rejected, `accepted = 0` and the phase converges. Main-Agent rounds never increase the independent Reviewer counter. The fixed limit is ten completed Main-Agent rounds.
+
+After each repair batch, append `## Repair Verification` with fixed findings, verification evidence, and next phase.
 
-Later rounds are not historical fix verification. They remain complete independent reviews of current code and receive no previous-round finding context.
+## Phase 3: Independent Reviewer 1
 
-The Reviewer uses two-direction inspection inside the same execution:
+After Main-Agent self-review and required tests converge:
 
-- 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
+- low risk: skip all independent Reviewers and proceed to final verification;
+- medium or high risk: launch Reviewer 1.
 
-Prefer direct read-only inspection, existing valid evidence, and the narrowest verification that can establish or refute a concrete issue. Broad verification is allowed when a concrete cross-cutting risk requires it and narrower evidence is insufficient.
+Before launch, append:
 
-### Step 3: Validate Reviewer Output Before Consumption
+```markdown
+## Independent Reviewer 1
 
-Before reading, filtering, or acting on any finding, run the result gate with `filtering_done: false`.
+- Status: RUNNING
+- Risk Trigger: <medium|high>
+```
+
+Launch exactly one fresh foreground Reviewer using the unchanged prompt and role. Do not provide previous review findings, filtering decisions, rejection reasons, or repair explanations.
 
-The result is usable only when all of these are proven:
+### Reviewer Infrastructure Failure
 
-- exactly one fresh Reviewer started in the round;
-- capability attestation remains verified;
-- descendant execution-unit count is zero;
-- delegation depth is zero;
-- orchestration status is compliant;
-- workspace identity is matched;
-- output is complete and structurally valid.
+If the Reviewer cannot start, exits abnormally, returns unusable output, or lacks essential context:
 
-On orchestration violation or unverifiable topology:
+1. append the observable failure;
+2. count the failed launch attempt against the semantic-risk Reviewer limit;
+3. allow at most one infrastructure retry at this same Reviewer position only when the risk limit still has an unused launch;
+4. append a new RUNNING retry section before retrying and increment the Reviewer launch counter;
+5. if the retry fails or the risk limit is exhausted, append Final Result `BLOCKED` and stop;
+6. do not convert infrastructure failure into a code finding;
+7. Do not substitute Main-Agent self-review for a required independent result.
 
-1. Stop the Reviewer and identifiable descendants on a best-effort basis.
-2. Discard all Reviewer output without consuming findings.
-3. Do not count the round as completed, retry it, or launch another Reviewer.
-4. Stop Code Review with `NEEDS_FIXES` and `REVIEW_ORCHESTRATION_VIOLATION`.
+### Finding Adjudication
 
-On post-launch workspace mismatch, discard the output and stop with `NEEDS_FIXES` and `WORKSPACE_MISMATCH`. Do not launch a replacement Reviewer in that round.
+For a usable Reviewer result, append `## Independent Reviewer 1 Result`, then classify every finding as accepted or rejected with evidence.
 
-### Step 4: Main Agent Filters Findings
+```text
+accepted = 0 -> Reviewer 1 converged
+accepted > 0 -> Main Agent repairs, verifies, and reruns its self-review loop
+```
 
-Only after the pre-filter result gate authorizes consumption, classify every finding:
+Accepted findings do not automatically trigger another independent Reviewer.
 
-- `accepted`: a concrete issue that cannot be refuted with current evidence;
-- `rejected`: not a defect, out of scope under the governing contract, or disproven with concrete evidence.
+## Phase 4: Reviewer 2 Eligibility
 
-Do not reject a finding because it is inconvenient, uncertain, or low confidence. If a potentially valid defect cannot be concretely refuted, accept it for repair or leave it unresolved with `NEEDS_FIXES` when repair is unsafe.
+Reviewer 2 is allowed only when every condition is true:
 
-Call the result gate again with `filtering_done: true`, `accepted_count`, and `rejected_count`. Its internal action controls the loop:
+- risk is `high`;
+- Reviewer 1 contained at least one accepted high-severity finding;
+- all accepted high findings were repaired;
+- targeted verification passed;
+- Main-Agent self-review reconverged.
 
-- `PASS`: no accepted findings remain;
-- `CONTINUE`: accepted findings remain before the safety limit;
-- `STOP`: a blocker exists or round ten remains non-converged.
+Accepted medium or low findings alone never trigger Reviewer 2. Medium risk never starts Reviewer 2.
 
-`CONTINUE` and `STOP` are orchestration actions, not external verdicts.
+When eligible, append a RUNNING section and launch one fresh Reviewer 2 with the unchanged complete-review prompt and current change input.
 
-### Step 5: Main Agent Applies Accepted Fixes
+After Reviewer 2:
 
-When the gate returns `CONTINUE`:
+- accepted = 0: proceed to final verification;
+- accepted > 0: Main Agent repairs, verifies, and runs its final self-review loop;
+- unresolved repair: `NEEDS_FIXES`;
+- Do not launch Reviewer 3 under any condition.
 
-1. The Main Agent directly applies the accepted batch in the current workspace. Do not launch a separate Fixer or Dev Agent.
-2. If a repair cannot be completed safely within scope, stop with `NEEDS_FIXES` and record the unresolved finding.
-3. Capture a fresh complete snapshot after fixes.
-4. Increment `round`, create a new execution identity, and return to Step 1.
+## Phase 5: Append-Only Reporting
 
-Do not send the next Reviewer any prior finding, filtering, or repair history.
+`{artifact_dir}/review-report.md` is the only required persisted review artifact.
 
-### Text Fallback
+Within one execution, append new sections only. Do not rewrite an earlier progress section. Append after:
 
-When Python is unavailable, manually enforce the same protocol and state transitions. Text fallback removes only script automation; it does not weaken capability attestation, one-Reviewer topology, result validation, output-discard rules, workspace matching, convergence, or the ten-round safety fuse.
+- risk assessment;
+- every Main-Agent review round;
+- every repair and verification batch;
+- every Reviewer launch;
+- every Reviewer result and adjudication;
+- every infrastructure retry;
+- final verification.
 
-If exact validation cannot be performed manually, fail closed with `REVIEW_INFRASTRUCTURE_BLOCKED` rather than guessing compliance.
+A RUNNING section is not edited after completion; append a separate result section. An interrupted execution remains `IN_PROGRESS` and shows its latest running or completed phase.
 
-## Phase 2: Persist and Report
+## Phase 6: Final Result
 
-Persist the minimum structured result needed to regenerate the report before rendering Markdown. Include final verdict, blocker code, completed rounds, Reviewers started, execution metadata, snapshot identities, and accepted, rejected, fixed, or unresolved findings.
+Append exactly one final result:
 
-Write `{artifact_dir}/review-report.md` using `${SKILL_DIR}/references/review-report-template.md`. Prefer deterministic rendering:
+```markdown
+## Final Result
 
-```bash
-python3 ${SKILL_DIR}/scripts/render_review_report.py \
-  {artifact_dir}/review-result-state.json \
-  {artifact_dir}/review-report.md
+- Verdict: PASS | NEEDS_FIXES | BLOCKED
+- Risk: low | medium | high
+- Main Review Rounds: <count>
+- Independent Reviewers Started: <count>
+- Accepted Findings: <count>
+- Fixed Findings: <count>
+- Rejected Findings: <count>
+- Unresolved Findings: <count>
+- Summary: <concise conclusion>
 ```
 
-If report rendering or path verification fails after review completed, regenerate the report from `review-result-state.json`. Do not rerun Code Review.
+Final outcomes:
 
-External verdicts are limited to:
+- `PASS`: Main-Agent review converged, every required independent review completed, and no accepted finding remains unresolved.
+- `NEEDS_FIXES`: Main-Agent round ten still has accepted findings, a repair is unsafe, or verification remains unresolved.
+- `BLOCKED`: a required independent Reviewer position failed and either its one permitted retry failed or the semantic-risk launch limit left no retry capacity; essential independent-review context is unavailable.
 
-- `PASS`: a usable completed round leaves zero accepted findings, or no workspace changes existed;
-- `NEEDS_FIXES`: code findings remain unresolved or any review infrastructure, execution, workspace, result, or safety blocker prevents valid completion.
+Exactly one final result is allowed. Do not append progress after Final Result.
 
 Completion handoff:
 
 - `PASS`: run `/prizmkit-retrospective` when structural docs or durable knowledge changed; otherwise proceed to `/prizmkit-committer`.
-- `NEEDS_FIXES`: report unresolved findings or the diagnostic blocker and stop.
+- `NEEDS_FIXES`: report unresolved findings and stop.
+- `BLOCKED`: report infrastructure evidence and permit recovery.

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,104 @@
-# Review Report Output Template
+# Review Report Lifecycle Template
 
-Use this template to render `{artifact_dir}/review-report.md` from the persisted structured result. Report regeneration must not rerun Reviewer execution.
+`{artifact_dir}/review-report.md` is the only required persisted review artifact.
+
+## Execution Start
+
+Every `/prizmkit-code-review` execution replaces any prior report with:
 
 ```markdown
 # Review Report
 
-## Verdict: <PASS|NEEDS_FIXES>
-## 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>
+## Status: IN_PROGRESS
+```
+
+Within that execution, append sections only. Never edit or replace an earlier progress section.
+
+## Progress Sections
+
+### Risk Assessment
+
+```markdown
+## Risk Assessment
+
+- Risk: <low|medium|high>
+- Independent Reviewer Limit: <0|1|2>
+- Reasons:
+  - <concrete behavioral reason>
+```
+
+### Main-Agent Review Round
+
+```markdown
+## Main Review Round <N>
+
+- Status: COMPLETED
+- Findings: <count>
+- Accepted: <count>
+- Rejected: <count>
+- Next: <next action>
+```
+
+### Repair Verification
+
+```markdown
+## Repair Verification
+
+- Source: <main|reviewer-1|reviewer-2>
+- Fixed Findings: <count>
+- Verification: <evidence summary>
+- Next: <next action>
+```
+
+### Independent Reviewer Running
+
+```markdown
+## Independent Reviewer <N>
+
+- Status: RUNNING
+- Risk Trigger: <medium|high>
+- Attempt: <1|2>
+```
+
+### Independent Reviewer Result
+
+```markdown
+## Independent Reviewer <N> Result
+
+- Status: <COMPLETED|BLOCKED>
+- Result: <PASS|FINDINGS|BLOCKED>
 - Findings: <count>
 - Accepted: <count>
 - Rejected: <count>
+- Accepted High: <count>
+- Next: <next action>
+```
 
-### Finding <N>: <short title>
+## Final Result
 
-- 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>
+Exactly one Final Result terminates a completed execution:
 
-## Final Summary
+```markdown
+## Final Result
 
-<One to three sentences covering the valid review outcome and any remaining blocker. Do not expose Reviewer reasoning traces.>
+- Verdict: <PASS|NEEDS_FIXES|BLOCKED>
+- Risk: <low|medium|high>
+- Main Review Rounds: <count>
+- Independent Reviewers Started: <count>
+- Accepted Findings: <count>
+- Fixed Findings: <count>
+- Rejected Findings: <count>
+- Unresolved Findings: <count>
+- Summary: <concise conclusion>
 ```
 
-## Report Rules
+## 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.
+- Start of a new execution removes stale progress and terminal results from prior executions.
+- A phase appends its result before the next phase starts.
+- Append RUNNING before each independent Reviewer launch or retry.
+- Do not modify a RUNNING section after completion; append its Result section.
+- An IN_PROGRESS report without Final Result is incomplete.
+- Generic or incidental verdict text outside the last Final Result does not prove completion.
+- Do not append any section after Final Result.
+- Do not persist a separate review-state JSON file.