prizmkit 1.1.124 → 1.1.125

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.124",
-  "bundledAt": "2026-07-12T05:54:30.044Z",
-  "bundledFrom": "f15301f"
+  "frameworkVersion": "1.1.125",
+  "bundledAt": "2026-07-12T10:06:26.471Z",
+  "bundledFrom": "ae3f6a3"
 }

package/bundled/adapters/claude/command-adapter.js

@@ -46,10 +46,8 @@ function buildReviewerRoleDefinition(roleManifest) {
       throw new Error(`Reviewer role must make ${capability} unavailable`);
     }
   }
-  if (roleManifest.execution_mode !== 'foreground-single-authority'
-    || roleManifest.max_descendant_execution_units !== 0
-    || roleManifest.max_delegation_depth !== 0) {
-    throw new Error('Reviewer role violates the single-authority execution topology');
+  if (roleManifest.execution_mode !== 'foreground-independent-review') {
+    throw new Error('Reviewer role must use foreground independent review');
   }
 
   const tools = (roleManifest.observational_capabilities || []).map(capability => {
@@ -64,14 +62,14 @@ name: ${roleManifest.role_name}
 description: ${roleManifest.description}
 tools: ${tools.join(', ')}
 permissionMode: dontAsk
-maxTurns: 200
+maxTurns: 80
 ---
 
 You are a capability-restricted read-only Reviewer execution role.
 
 Read and follow the complete prompt supplied by the Main Agent. Perform the complete review yourself. Your tool allowlist intentionally excludes workspace mutation, shell execution, skill invocation, downstream execution creation, delegation-equivalent behavior, and orchestration re-entry.
 
-If the supplied review cannot be completed with the available observational capabilities and current execution context, return \`REVIEW_INFRASTRUCTURE_BLOCKED\`. Do not delegate, request a helper, mutate the workspace, or claim \`PASS\` from incomplete work.
+If the supplied review cannot be completed with the available read-only capabilities and current context, return \`BLOCKED\` with the missing capability or context. Do not delegate, request a helper, mutate the workspace, or claim \`PASS\` from incomplete work.
 `;
 }
 

package/bundled/dev-pipeline/scripts/generate-recovery-prompt.py

@@ -96,10 +96,9 @@ Implement the minimal fix (red → green):
         "Review",
         """\
 Verify fix quality:
-1. Self-review: does the fix address root cause (not just symptom)?
-   Edge cases covered? Follows project conventions?
-2. Run full test suite one final time
-3. If any issues found, fix and re-review (max 3 rounds)""",
+1. Run `/prizmkit-code-review` with the current bugfix artifact directory.
+2. The skill launches one fresh read-only Reviewer per completed round; the Main Agent filters and directly fixes accepted findings.
+3. Continue until no accepted finding remains or the ten-round safety fuse returns `NEEDS_FIXES`; stop and retry later if review returns `BLOCKED`.""",
     ),
     6: (
         "User Verification",

package/bundled/dev-pipeline/templates/bootstrap-prompt.md

@@ -30,7 +30,7 @@ Infer what needs to be done from the feature context above and follow the standa
 
 3. **Implement**: Run `/prizmkit-implement` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` to execute the plan using TDD (write tests first, then implement).
 
-4. **Review**: Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` to review and auto-fix changes against the spec (internal review-fix loop, max 3 rounds).
+4. **Review**: Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill uses one fresh read-only Reviewer per completed round, lets the Main Agent filter and directly fix accepted findings, and stops after at most ten completed rounds.
 
 5. **Test**: Run `/prizmkit-test scope=this-change artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` to generate and verify tests only for this feature's changed scope after review. Do not use bugfix/refactor artifact directories for this gate.
 

package/bundled/dev-pipeline/templates/bootstrap-tier3.md

@@ -240,9 +240,9 @@ For each Verification Gate from the Task Contract, write one evidence line to Im
 
 Review the completed implementation before the scoped feature test gate runs. Use `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` so the code-review skill can read spec, plan, context snapshot, implementation log, and current diff artifacts. Do not require or read a prior `/prizmkit-test` report here; test generation and test-fix looping happen in the next phase.
 
-Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill chooses a platform-supported independent Reviewer strategy and verifies that the Reviewer's snapshot is equivalent to the current workspace under its skill-owned workspace protocol. Do not prescribe Agent launch parameters from this bootstrap prompt.
+Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill chooses a platform-supported fresh read-only Reviewer, prefers direct access to the active checkout, and supplies changed content that a platform-forced worktree cannot see. Do not prescribe Agent launch parameters from this bootstrap prompt.
 
-The skill runs an internal review-fix loop (Reviewer Agent → filter → orchestrator fix, max 3 rounds) and writes `review-report.md` to the artifact directory.
+The skill runs an internal review-fix loop (fresh Reviewer → Main-Agent filter → Main-Agent fix, up to ten completed rounds) and writes `review-report.md` to the artifact directory.
 
 **Gate Check — Review Report**:
 After `/prizmkit-code-review` returns, verify the review report:
@@ -257,7 +257,8 @@ If GATE:MISSING:
 
 Read `review-report.md` and check the Verdict:
 - `PASS` → proceed to next phase
-- `NEEDS_FIXES` → the skill exhausted its max rounds; log the remaining findings and proceed (do not retry externally)
+- `NEEDS_FIXES` → log the unresolved accepted findings and proceed according to the task failure policy (do not retry externally)
+- `BLOCKED` → log the infrastructure reason and stop so the review can be retried
 
 **CP-3**: Review complete, report written.
 

package/bundled/dev-pipeline/templates/bugfix-bootstrap-prompt.md

@@ -180,8 +180,8 @@ After implement completes, verify:
 If `FAST_PATH=true` (≤ 2 tasks, obvious root cause), skip this phase entirely and mark checkpoint step `prizmkit-code-review` as `skipped` before continuing.
 
 Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/bugfix/{{BUG_ID}}/`:
-- The skill chooses a platform-supported independent Reviewer strategy and verifies a workspace-equivalent snapshot under its skill-owned protocol
-- The skill runs an internal review-fix loop (Reviewer → filter → orchestrator fix, max 3 rounds) and writes `review-report.md`
+- The skill chooses a platform-supported fresh read-only Reviewer, prefers direct access to the active checkout, and supplies changed content that a platform-forced worktree cannot see
+- The skill runs an internal review-fix loop (Reviewer → Main-Agent filter → Main-Agent fix, up to ten completed rounds) and writes `review-report.md`
 - `review-report.md` must contain `## Verdict`
 
 **Gate Check — Review Report**:
@@ -196,7 +196,8 @@ If GATE:MISSING:
 
 Read `review-report.md` and check the Verdict:
 - `PASS` → proceed
-- `NEEDS_FIXES` → the skill exhausted its max rounds; log remaining findings and proceed
+- `NEEDS_FIXES` → the skill reached the ten-round safety fuse or left an accepted finding unresolved; log remaining findings and proceed according to the task failure policy
+- `BLOCKED` → log the infrastructure reason and stop so the review can be retried
 
 {{IF_BROWSER_INTERACTION}}
 

package/bundled/dev-pipeline/templates/refactor-bootstrap-prompt.md

@@ -139,7 +139,7 @@ Apply the browser behavior preservation protocol where UI behavior can be affect
 
 ### Phase 4: Review — Code Review & Behavior Verification
 
-Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/` directly from the main orchestrator. The skill loads its skill-owned `references/reviewer-agent-prompt.md` and `references/reviewer-workspace-protocol.md`, chooses a platform-supported independent Reviewer strategy, and verifies a workspace-equivalent snapshot.
+Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/` directly from the main orchestrator. The skill loads its skill-owned `references/reviewer-agent-prompt.md`, chooses a platform-supported fresh read-only Reviewer, prefers direct access to the active checkout, and supplies changed content that a platform-forced worktree cannot see.
 
 Review requirements:
 - verify refactor quality against spec.md and plan.md;
@@ -149,7 +149,12 @@ Review requirements:
 
 If the report is missing after one bounded status check, write `failure-log.md` and stop with a clear recovery failure. Do not replace the independent Reviewer with Main-Agent self-review.
 
-**Checkpoint update**: set step `prizmkit-code-review` to `completed` in `{{CHECKPOINT_PATH}}`.
+Read `review-report.md` and check the Verdict:
+- `PASS` → proceed.
+- `NEEDS_FIXES` → log unresolved accepted findings and proceed only when they do not block behavior preservation.
+- `BLOCKED` → log the infrastructure reason and stop so the review can be retried.
+
+**Checkpoint update**: set step `prizmkit-code-review` to `completed` only after `PASS`, or after an explicitly accepted non-blocking `NEEDS_FIXES` result. Do not complete the checkpoint for `BLOCKED`.
 
 ---
 

package/bundled/dev-pipeline/templates/sections/bugfix-phase-review.md

@@ -12,9 +12,9 @@ If `FAST_PATH=true`, skip this phase intentionally:
 
 Then continue to the next checkpoint step.
 
-Otherwise, run `/prizmkit-code-review` with `artifact_dir=.prizmkit/bugfix/{{BUG_ID}}/`. The skill loads its skill-owned Reviewer prompt and workspace protocol, chooses a platform-supported subagent strategy, and verifies that the Reviewer's snapshot is equivalent to the current workspace before review.
+Otherwise, run `/prizmkit-code-review` with `artifact_dir=.prizmkit/bugfix/{{BUG_ID}}/`. The skill chooses a platform-supported fresh read-only Reviewer, prefers direct access to the active checkout, and supplies changed content that a platform-forced worktree cannot see.
 
-The skill runs its internal Reviewer Agent → filter → orchestrator fix loop and writes `review-report.md`. Do not prescribe Agent launch parameters from this pipeline template; the review skill owns strategy selection and workspace-equivalence verification.
+The skill runs its internal fresh Reviewer → Main-Agent filter → Main-Agent fix loop for up to ten completed rounds and writes `review-report.md`. Do not prescribe Agent launch parameters from this pipeline template.
 
 **Gate Check — Review Report**:
 
@@ -23,7 +23,8 @@ The skill runs its internal Reviewer Agent → filter → orchestrator fix loop
 ```
 
 - `PASS` → proceed.
-- `NEEDS_FIXES` → the skill exhausted its internal rounds; log remaining findings and proceed only when they do not block acceptance criteria.
-- Missing report → one bounded retry, then write `failure-log.md` and stop if the independent review protocol remains blocked; do not replace it with Main-Agent self-review.
+- `NEEDS_FIXES` → log unresolved accepted findings and proceed only when they do not block acceptance criteria.
+- `BLOCKED` → log the infrastructure reason and stop so the review can be retried.
+- Missing report → one bounded retry, then write `failure-log.md` and stop if independent review remains blocked; do not replace it with Main-Agent self-review.
 
 **Checkpoint update**: Set step `prizmkit-code-review` to `completed` when review is complete, or `skipped` for FAST_PATH.

package/bundled/dev-pipeline/templates/sections/phase-review-agent.md

@@ -2,9 +2,9 @@
 
 Review the completed implementation before the scoped feature test gate runs. Use `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` so the code-review skill can read spec, plan, context snapshot, implementation log, and current diff artifacts. Do not require or read a prior `/prizmkit-test` report here; test generation and test-fix looping happen in the next phase.
 
-Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill loads its skill-owned Reviewer prompt and workspace protocol, chooses a platform-supported subagent strategy, and verifies that the Reviewer's snapshot is equivalent to the current workspace before review.
+Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill chooses a platform-supported fresh read-only Reviewer, prefers direct access to the active checkout, and supplies changed content that a platform-forced worktree cannot see. Do not prescribe Agent launch parameters from this pipeline template.
 
-The skill runs an internal review-fix loop (Reviewer Agent → filter → orchestrator fix, max 3 rounds) and writes `review-report.md` to the artifact directory. Do not prescribe Agent launch parameters from this pipeline template; the review skill owns strategy selection and workspace-equivalence verification.
+The skill runs an internal review-fix loop (fresh Reviewer → Main-Agent filter → Main-Agent fix, up to ten completed rounds) and writes `review-report.md` to the artifact directory.
 
 **Gate Check — Review Report**:
 After `/prizmkit-code-review` returns, verify the review report:
@@ -19,8 +19,8 @@ If GATE:MISSING:
 
 Read `review-report.md` and check the Verdict:
 - `PASS` → proceed to next phase
-- `NEEDS_FIXES` → the skill exhausted its max rounds; log the remaining findings and proceed (do not retry externally)
+- `NEEDS_FIXES` → log the unresolved accepted findings and proceed according to the task failure policy (do not retry externally)
+- `BLOCKED` → log the infrastructure reason and stop so the review can be retried
 
 **CP-3**: Review complete, report written.
 
-

package/bundled/dev-pipeline/templates/sections/phase-review-full.md

@@ -2,11 +2,11 @@
 
 Review the completed implementation before the scoped feature test gate runs. Use `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` so the code-review skill can read spec, plan, context snapshot, implementation log, and current diff artifacts. Do not require or read a prior `/prizmkit-test` report here; test generation and test-fix looping happen in the next phase.
 
-Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill loads its skill-owned Reviewer prompt and workspace protocol, chooses a platform-supported subagent strategy, and verifies that the Reviewer's snapshot is equivalent to the current workspace before review.
+Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill chooses a platform-supported fresh read-only Reviewer, prefers direct access to the active checkout, and supplies changed content that a platform-forced worktree cannot see. Do not prescribe Agent launch parameters from this bootstrap prompt.
 
-If the independent Reviewer cannot start or verify the snapshot because of a transient platform error, retry at most once. If the second attempt fails, do not keep spawning variants or enter report-polling loops; write `failure-log.md` with the observable error and let the skill report the unresolved verification blocker. Do not replace the independent Reviewer with Main-Agent self-review.
+If the independent Reviewer cannot start or return usable output because of a transient platform error, retry at most once. If the second attempt fails, do not keep spawning variants or enter report-polling loops; write `failure-log.md` with the observable error and let the skill report `BLOCKED`. Do not replace the independent Reviewer with Main-Agent self-review.
 
-The skill runs an internal review-fix loop (Reviewer Agent → filter → orchestrator fix, max 3 rounds) and writes `review-report.md` to the artifact directory. Do not prescribe Agent launch parameters from this pipeline template; the review skill owns strategy selection and workspace-equivalence verification.
+The skill runs an internal review-fix loop (fresh Reviewer → Main-Agent filter → Main-Agent fix, up to ten completed rounds) and writes `review-report.md` to the artifact directory. The review skill owns strategy selection and forced-worktree content fallback.
 
 **Gate Check — Review Report**:
 After `/prizmkit-code-review` returns, verify the review report:
@@ -21,7 +21,8 @@ If GATE:MISSING:
 
 Read `review-report.md` and check the Verdict:
 - `PASS` → proceed to next phase
-- `NEEDS_FIXES` → the skill exhausted its max rounds; log the remaining findings and proceed (do not retry externally)
+- `NEEDS_FIXES` → log the unresolved accepted findings and proceed according to the task failure policy (do not retry externally)
+- `BLOCKED` → log the infrastructure reason and stop so the review can be retried
 
 **CP-3**: Review complete, report written.
 

package/bundled/dev-pipeline/templates/sections/refactor-phase-review.md

@@ -1,8 +1,8 @@
 ### Phase 3: Review — Code Review & Behavior Verification
 
-Run `/prizmkit-code-review` directly with `artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/`. The skill loads its skill-owned `references/reviewer-agent-prompt.md` and `references/reviewer-workspace-protocol.md`, chooses a platform-supported subagent strategy, and verifies that the Reviewer's snapshot is equivalent to the current workspace before review.
+Run `/prizmkit-code-review` directly with `artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/`. The skill loads its skill-owned `references/reviewer-agent-prompt.md`, chooses a platform-supported fresh read-only Reviewer, prefers direct access to the active checkout, and supplies changed content that a platform-forced worktree cannot see.
 
-Do not spawn a top-level Reviewer subagent. The code-review skill owns its internal Reviewer Agent → filter → orchestrator fix loop. Do not prescribe Agent launch parameters from this pipeline template; the review skill owns strategy selection and workspace-equivalence verification.
+Do not spawn a top-level Reviewer subagent. The code-review skill owns its internal fresh Reviewer → Main-Agent filter → Main-Agent fix loop for up to ten completed rounds. Do not prescribe Agent launch parameters from this pipeline template.
 
 **Gate Check — Review Report**:
 
@@ -11,9 +11,10 @@ Do not spawn a top-level Reviewer subagent. The code-review skill owns its inter
 ```
 
 - `PASS` → proceed.
-- `NEEDS_FIXES` → the skill exhausted its internal rounds; log remaining findings and proceed only when they do not block behavior preservation.
-- Missing report → one bounded retry, then write `failure-log.md` and stop if the independent review protocol remains blocked; do not replace it with Main-Agent self-review.
+- `NEEDS_FIXES` → log unresolved accepted findings and proceed only when they do not block behavior preservation.
+- `BLOCKED` → log the infrastructure reason and stop so the review can be retried.
+- Missing report → one bounded retry, then write `failure-log.md` and stop if independent review remains blocked; do not replace it with Main-Agent self-review.
 
 Verify the review explicitly checks behavior preservation, public API compatibility, imports, tests, and rollback assumptions.
 
-**Checkpoint update**: Set step `prizmkit-code-review` to `completed` when review is complete.
+**Checkpoint update**: Set step `prizmkit-code-review` to `completed` only after `PASS`, or after an explicitly accepted non-blocking `NEEDS_FIXES` result. Do not complete the checkpoint for `BLOCKED`.

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

@@ -882,7 +882,8 @@ class TestDirectOrchestratorImplementationPrompts:
             assert FORBIDDEN_TEST_CMD_PLACEHOLDER not in rendered
             assert FORBIDDEN_THREE_STRIKE not in rendered
             assert FORBIDDEN_TWENTY_STEP not in rendered
-            assert "Reviewer Agent → filter → orchestrator fix" in rendered
+            assert "fresh Reviewer → Main-Agent filter → Main-Agent fix" in rendered
+            assert "up to ten completed rounds" in rendered
 
     def test_retained_tier3_fallback_template_uses_direct_orchestrator_implementation(self):
         rendered = Path("dev-pipeline/templates/bootstrap-tier3.md").read_text(encoding="utf-8")

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_minimal_reviewer_loop():
     headless_guidance_files = [
         REPO_ROOT / "dev-pipeline" / "templates" / "sections" / "phase-review-full.md",
         REPO_ROOT / "dev-pipeline" / "templates" / "bootstrap-tier3.md",
@@ -828,8 +828,11 @@ 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 "active checkout" in text, path
+        assert "platform-forced worktree" in text, path
         assert "Main-Agent self-review" 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
@@ -838,14 +841,17 @@ def test_headless_review_guidance_uses_workspace_and_execution_protocols():
         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 "all findings are rejected" in skill_text
+    assert "BLOCKED" in skill_text
+    assert "Do not substitute Main-Agent self-review" in skill_text
+    assert "platform forces an isolated worktree" 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):

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.124",
+  "version": "1.1.125",
   "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,13 +1,11 @@
 ---
 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 practical convergence-driven independent code review against the current spec, plan, workspace changes, 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 completed round launches one fresh read-only non-delegating Reviewer; the Main Agent filters findings, directly repairs accepted issues, and repeats until no accepted finding remains or the ten-round safety fuse stops review. (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.
+Run an independent review-fix loop over the complete current change. A fresh Reviewer discovers candidate defects; the Main Agent adjudicates every finding, directly repairs accepted issues, and owns the final verdict.
 
 ## When to Use
 
@@ -28,148 +26,144 @@ The safety boundary is fail-closed. A Reviewer may run only when its execution e
 |---|---|---|
 | `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/`. |
 
-## Authoritative Protocols
+## Required Assets
 
-Read these references before starting Phase 1:
+Read before starting the loop:
 
-- `${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
+- `${SKILL_DIR}/references/reviewer-agent-prompt.md`: complete Reviewer input and output contract
+- `${SKILL_DIR}/references/review-report-template.md`: final report contract
+- `${SKILL_DIR}/assets/reviewer-role.json`: semantic read-only and non-delegating Reviewer boundary used by platform adapters
 
-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.
+The contract defines semantic capabilities rather than depending on a platform-specific tool or Agent name.
 
-## Phase 0: Context and Initial Snapshot
+## Phase 0: Collect Review Context
 
-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`.
+1. Read `spec.md` and extract goals plus acceptance criteria when it exists.
+2. Read `plan.md` and extract architecture decisions plus completed tasks when it exists.
+3. Read scoped `/prizmkit-test` evidence when `{artifact_dir}/test-report-path.txt` exists. Preserve its verdict, in-scope failures, baseline failures, gaps, and boundary evidence.
+4. Read `.prizmkit/prizm-docs/root.prizm`, applicable progressive docs, and project rules.
+5. Inspect and capture the complete current Git change:
+   - staged and unstaged tracked changes;
+   - untracked files;
+   - deleted and renamed files;
+   - the base revision and relevant unchanged callers, dependents, contracts, and tests.
+6. Prepare the Reviewer input with staged and unstaged Git diffs plus the full content of every untracked file. Include deleted and renamed states explicitly. The Reviewer role may have file-reading capabilities without shell or Git execution, so a changed-path inventory alone is insufficient.
+7. If no changes exist, skip Reviewer launch, write a zero-round `PASS` report, and finish.
 
-## Phase 1: Convergence Loop
+### Checkout Access
 
-### Loop State
+Prefer a Reviewer that can read the active checkout directly. Give it the repository path, staged and unstaged Git diffs, the full content of every untracked file, and the changed-path inventory. Direct checkout access lets the Reviewer perform targeted surrounding-context reads without requiring shell or Git execution.
 
-Track:
+If the platform forces an isolated worktree:
 
-```yaml
-round: 1
-reviewers_started_total: 0
-completed_rounds: 0
-structured_result_state: <artifact_dir>/review-result-state.json
-```
+1. provide the same staged and unstaged diffs, untracked file contents, and changed-path states used for active-checkout review;
+2. tell the Reviewer to use the worktree only for baseline and surrounding-context reads;
+3. clearly label supplied changed content separately from unchanged context;
+4. do not require the Reviewer to prove that the two physical checkouts are identical.
 
-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`.
+If required changed content is missing, supply it before consuming the review. If essential context cannot be made available, return `BLOCKED` with a concise infrastructure reason.
 
-### Step 1: Establish the Reviewer Boundary
+## Phase 1: Convergence 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:
+Track only:
 
-```bash
-python3 ${SKILL_DIR}/scripts/check_loop.py < preflight-payload.json
+```yaml
+round: 1
+completed_rounds: 0
+final_verdict: null
+findings: []
 ```
 
-5. Launch exactly one foreground Reviewer only when the gate returns `launchAuthorized: true`.
-
-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.
-
-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`.
-
-### Step 2: Complete Independent Review
-
-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.
-
-Later rounds are not historical fix verification. They remain complete independent reviews of current code and receive no previous-round finding context.
+The safety fuse is fixed at ten completed rounds. It is not caller-configurable and never converts unresolved defects into `PASS`.
 
-The Reviewer uses two-direction inspection inside the same execution:
+### Step 1: Launch One Fresh Reviewer
 
-- 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
+1. Select an execution mechanism that actually limits the Reviewer to read-only inspection and prevents workspace mutation, downstream execution creation, delegation, orchestration re-entry, and skill invocation.
+2. Launch exactly one fresh foreground Reviewer for this round.
+3. Provide the complete current review input using `${SKILL_DIR}/references/reviewer-agent-prompt.md`.
+4. Do not provide previous-round findings, verdicts, filtering decisions, rejection reasons, or repair explanations.
 
-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.
+Do not substitute Main-Agent self-review. If the Reviewer cannot start or exits abnormally, return `BLOCKED`. This does not consume a completed round.
 
-### Step 3: Validate Reviewer Output Before Consumption
+### Step 2: Complete Independent Review
 
-Before reading, filtering, or acting on any finding, run the result gate with `filtering_done: false`.
+The Reviewer evaluates the complete current change, not only the latest repair. It checks requirements, implementation completeness, concrete failure scenarios, error handling, security, data integrity, concurrency, contracts, compatibility, tests, and project rules.
 
-The result is usable only when all of these are proven:
+It may inspect unchanged callers, dependents, shared patterns, and tests when needed to establish a concrete issue. Prefer targeted read-only inspection over broad repository scans or redundant verification.
 
-- 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.
+A usable result is either:
 
-On orchestration violation or unverifiable topology:
+- `PASS`: no concrete finding;
+- `FINDINGS`: one or more structured candidate defects.
 
-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`.
+If output is partial, malformed, or cannot be understood safely, return `BLOCKED`. This does not consume a completed round.
 
-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.
+### Step 3: Main Agent Filters Findings
 
-### Step 4: Main Agent Filters Findings
+A usable Reviewer result completes the current round. Increment `completed_rounds` before adjudication.
 
-Only after the pre-filter result gate authorizes consumption, classify every finding:
+For every finding, classify it as:
 
-- `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.
+- `accepted`: current code and governing evidence support the concrete failure scenario;
+- `rejected`: code, requirements, contracts, or tests concretely disprove it, or show that it is outside scope with no regression path.
 
-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.
+Record a concise evidence-based reason for every rejected finding. Do not reject a finding because it is inconvenient, uncertain, low severity, or expensive to repair. When a potentially real defect cannot be refuted, accept it or leave it unresolved.
 
-Call the result gate again with `filtering_done: true`, `accepted_count`, and `rejected_count`. Its internal action controls the loop:
+Apply these rules exactly:
 
-- `PASS`: no accepted findings remain;
-- `CONTINUE`: accepted findings remain before the safety limit;
-- `STOP`: a blocker exists or round ten remains non-converged.
+```text
+Reviewer returns PASS                         -> PASS
+Reviewer returns findings and accepted = 0  -> PASS
+Reviewer returns findings and accepted > 0  -> repair or stop
+```
 
-`CONTINUE` and `STOP` are orchestration actions, not external verdicts.
+When all findings are rejected, `accepted = 0`; the review is `PASS` because the Reviewer found no valid defect. Do not launch another Reviewer merely because the raw Reviewer result contained findings.
 
-### Step 5: Main Agent Applies Accepted Fixes
+### Step 4: Repair or Stop
 
-When the gate returns `CONTINUE`:
+When `accepted > 0`:
 
-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.
+1. If `completed_rounds` is ten, return `NEEDS_FIXES` and record the accepted findings as unresolved.
+2. Otherwise the Main Agent directly repairs every accepted finding that can be fixed safely within scope. Do not launch a Fixer or implementation subagent.
+3. Run the narrowest meaningful verification for the repair.
+4. If a finding cannot be repaired safely, return `NEEDS_FIXES` and record why it remains unresolved.
+5. Recollect the complete current change, increment `round`, and launch a fresh Reviewer with no previous-round findings or repair history.
 
-Do not send the next Reviewer any prior finding, filtering, or repair history.
+## Phase 2: Persist Final Report
 
-### Text Fallback
+Write exactly one required review artifact:
 
-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.
+```text
+{artifact_dir}/review-report.md
+```
 
-If exact validation cannot be performed manually, fail closed with `REVIEW_INFRASTRUCTURE_BLOCKED` rather than guessing compliance.
+Use `${SKILL_DIR}/references/review-report-template.md`. The report records:
 
-## Phase 2: Persist and Report
+- `PASS`, `NEEDS_FIXES`, or `BLOCKED`;
+- completed round count;
+- findings and their `fixed`, `rejected`, or `unresolved` disposition;
+- a concise final summary;
+- an infrastructure reason when blocked.
 
-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.
+Do not create a separate persisted review state file. Raw Reviewer output remains in the session log.
 
-Write `{artifact_dir}/review-report.md` using `${SKILL_DIR}/references/review-report-template.md`. Prefer deterministic rendering:
+The report may be rendered directly or with the optional helper by sending minimal JSON on standard input:
 
 ```bash
 python3 ${SKILL_DIR}/scripts/render_review_report.py \
-  {artifact_dir}/review-result-state.json \
-  {artifact_dir}/review-report.md
+  {artifact_dir}/review-report.md < review-report-input.json
 ```
 
-If report rendering or path verification fails after review completed, regenerate the report from `review-result-state.json`. Do not rerun Code Review.
+The input may be transient; it is not a required artifact.
 
-External verdicts are limited to:
+## Final Outcomes
 
-- `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.
+- `PASS`: no changes existed, the Reviewer returned `PASS`, or a completed round left `accepted = 0`, including when all findings are rejected.
+- `NEEDS_FIXES`: accepted findings remain unresolved or the tenth completed round still has accepted findings.
+- `BLOCKED`: Reviewer execution or essential review input failed before a usable result was obtained.
 
 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 code findings and stop.
+- `BLOCKED`: report the infrastructure reason and allow retry without consuming the code-convergence budget.