prizmkit 1.1.127 → 1.1.129

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

@@ -2,6 +2,7 @@
 
 import json
 import os
+import re
 import shutil
 import subprocess
 import sys
@@ -811,7 +812,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_risk_routed_dual_layer_loop():
+def test_headless_review_guidance_uses_main_agent_review_loop():
     headless_guidance_files = [
         REPO_ROOT / "dev-pipeline" / "templates" / "sections" / "phase-review-full.md",
         REPO_ROOT / "dev-pipeline" / "templates" / "bootstrap-tier3.md",
@@ -827,32 +828,28 @@ def test_headless_review_guidance_uses_risk_routed_dual_layer_loop():
 
     for path in headless_guidance_files:
         text = path.read_text(encoding="utf-8")
-        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 "Main-Agent review loop" in text, path
+        assert "up to ten completed rounds" 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 "The current Main Agent is the only Code Review executor" in text, path
+        assert "Do not invoke another review skill or review workflow" in text, path
+        assert "low=0" not in text and "Reviewer 3" not in text, path
+        assert "REVIEW_BLOCKED" not in text, path
+        assert "forced-worktree changed-content fallback" not in text, path
         assert "isolation:" not in text, path
 
     skill_text = skill_path.read_text(encoding="utf-8")
     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 "ten completed review rounds" 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 "PASS | NEEDS_FIXES" in skill_text
+    assert "BLOCKED" not in skill_text
+    assert "Reviewer 2" not 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):
@@ -952,10 +949,11 @@ def test_progress_parser_normalizes_codebuddy_agent_tools_with_deduplication():
 
     assert data["cb_session_id"] == "cb-session"
     assert data["subagent_provider"] == "codebuddy"
-    assert data["subagent_spawn_count"] == 2
-    assert data["active_subagent_count"] == 2
+    assert data["subagent_spawn_count"] == 1
+    assert data["active_subagent_count"] == 1
     assert {item["status"] for item in data["subagent_states"]} == {"running"}
-    assert len(data["subagent_statistics"]["records"]) == 2
+    assert len(data["subagent_statistics"]["records"]) == 1
+    assert data["subagent_statistics"]["records"][0]["metadata"]["tool"] == "Agent"
 
 
 def test_progress_parser_normalizes_codex_collab_metadata_with_missing_fields():
@@ -1832,14 +1830,18 @@ def test_git_branch_worktree_plans_preserve_shell_invariants(tmp_path):
 
     assert create.name == "branch_create"
     assert any(command.args[:2] == ("checkout", "-b") for command in create.commands)
-    assert any(command.args[:2] == ("stash", "push") for command in merge.commands)
+    assert not any(command.args and command.args[0] == "stash" for command in merge.commands)
+    assert any(command.args[:2] == ("status", "--porcelain") for command in merge.commands)
     assert any(command.args[:2] == ("merge", "--ff-only") for command in merge.commands)
-    assert any(command.args == ("push",) for command in merge.commands)
-    assert save_wip.never_fails is True
-    assert ensure.never_fails is True
+    push_index = next(index for index, command in enumerate(merge.commands) if command.args == ("push",))
+    merge_index = next(index for index, command in enumerate(merge.commands) if command.args[:2] == ("merge", "--ff-only"))
+    assert merge_index < push_index
+    assert save_wip.never_fails is False
+    assert ensure.never_fails is False
     assert any(command.args[:2] == ("rebase", "--abort") for command in ensure.commands)
     assert any(command.args[:2] == ("add", "-A") for command in ensure.commands)
-    assert not any(command.args[:2] == ("stash", "pop") for command in ensure.commands)
+    assert not any(command.args and command.args[0] == "stash" for command in ensure.commands)
+    assert ensure.never_fails is False
     assert any(".*/worktrees/**" in " ".join(command.args) for command in save_wip.commands)
     assert worktree.commands[0].args[:2] == ("worktree", "add")
 
@@ -1867,6 +1869,205 @@ def test_git_branch_worktree_plans_preserve_shell_invariants(tmp_path):
     assert skipped_wip.results == ()
 
 
+def test_runtime_source_constructs_no_git_stash_commands():
+    runtime = Path("dev-pipeline/prizmkit_runtime")
+    matches = []
+    for path in runtime.glob("*.py"):
+        text = path.read_text(encoding="utf-8")
+        if re.search(r'["\']stash["\']', text):
+            matches.append(path.as_posix())
+
+    assert matches == []
+
+
+def _init_merge_repo(project_root):
+    subprocess.run(["git", "init", "-b", "main"], cwd=project_root, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=project_root, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=project_root, check=True)
+    manifest = project_root / ".prizmkit" / "manifest.json"
+    manifest.parent.mkdir(parents=True)
+    manifest.write_text('{"version":"current"}\n', encoding="utf-8")
+    (project_root / "app.txt").write_text("base\n", encoding="utf-8")
+    subprocess.run(["git", "add", "."], cwd=project_root, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=project_root, check=True, stdout=subprocess.DEVNULL)
+
+
+def _stash_oids(project_root):
+    output = subprocess.run(
+        ["git", "stash", "list", "--format=%H"],
+        cwd=project_root,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout
+    return tuple(line for line in output.splitlines() if line)
+
+
+def test_branch_merge_preserves_preexisting_stash_when_workspace_is_clean(tmp_path):
+    from prizmkit_runtime.gitops import BranchContext, branch_merge_plan, run_git_plan
+
+    _init_merge_repo(tmp_path)
+    manifest = tmp_path / ".prizmkit" / "manifest.json"
+    manifest.write_text('{"version":"stale"}\n', encoding="utf-8")
+    subprocess.run(["git", "stash", "push", "-m", "stale-install", "--", ".prizmkit/manifest.json"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    stale_stashes = _stash_oids(tmp_path)
+    subprocess.run(["git", "checkout", "-b", "dev/example"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "feature.txt").write_text("done\n", encoding="utf-8")
+    subprocess.run(["git", "add", "feature.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "feature"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+
+    result = run_git_plan(
+        tmp_path,
+        branch_merge_plan(BranchContext("main", "dev/example", tmp_path)),
+    )
+
+    assert result.ok is True
+    assert _stash_oids(tmp_path) == stale_stashes
+    assert json.loads(manifest.read_text(encoding="utf-8"))["version"] == "current"
+    assert (tmp_path / "feature.txt").read_text(encoding="utf-8") == "done\n"
+
+
+def test_branch_merge_rejects_dirty_task_checkout_without_touching_stashes(tmp_path):
+    from prizmkit_runtime.gitops import BranchContext, branch_merge_plan, run_git_plan
+
+    _init_merge_repo(tmp_path)
+    manifest = tmp_path / ".prizmkit" / "manifest.json"
+    manifest.write_text('{"version":"stale"}\n', encoding="utf-8")
+    subprocess.run(["git", "stash", "push", "-m", "user-stash", "--", ".prizmkit/manifest.json"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    stale_stashes = _stash_oids(tmp_path)
+    subprocess.run(["git", "checkout", "-b", "dev/example"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "feature.txt").write_text("done\n", encoding="utf-8")
+    subprocess.run(["git", "add", "feature.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "feature"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "app.txt").write_text("local visible change\n", encoding="utf-8")
+
+    result = run_git_plan(
+        tmp_path,
+        branch_merge_plan(BranchContext("main", "dev/example", tmp_path)),
+    )
+
+    assert result.ok is False
+    assert _stash_oids(tmp_path) == stale_stashes
+    assert (tmp_path / "app.txt").read_text(encoding="utf-8") == "local visible change\n"
+    assert json.loads(manifest.read_text(encoding="utf-8"))["version"] == "current"
+    assert subprocess.run(
+        ["git", "branch", "--show-current"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip() == "dev/example"
+
+
+def test_branch_merge_rebases_committed_task_without_stash_restore_conflict(tmp_path):
+    from prizmkit_runtime.gitops import BranchContext, branch_merge_plan, run_git_plan
+
+    _init_merge_repo(tmp_path)
+    subprocess.run(["git", "checkout", "-b", "dev/example"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "feature.txt").write_text("done\n", encoding="utf-8")
+    subprocess.run(["git", "add", "feature.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "feature"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "checkout", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "app.txt").write_text("main changed\n", encoding="utf-8")
+    subprocess.run(["git", "commit", "-am", "advance main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "checkout", "dev/example"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+
+    result = run_git_plan(
+        tmp_path,
+        branch_merge_plan(BranchContext("main", "dev/example", tmp_path)),
+    )
+
+    assert result.ok is True
+    assert _stash_oids(tmp_path) == ()
+    assert (tmp_path / "app.txt").read_text(encoding="utf-8") == "main changed\n"
+    assert subprocess.run(
+        ["git", "branch", "--show-current"],
+        cwd=tmp_path,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout.strip() == "main"
+
+
+def test_branch_return_commits_wip_without_touching_user_stashes(tmp_path):
+    from prizmkit_runtime.gitops import branch_ensure_return
+
+    _init_merge_repo(tmp_path)
+    manifest = tmp_path / ".prizmkit" / "manifest.json"
+    manifest.write_text('{"version":"stale"}\n', encoding="utf-8")
+    subprocess.run(["git", "stash", "push", "-m", "user-stash", "--", ".prizmkit/manifest.json"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    user_stashes = _stash_oids(tmp_path)
+    subprocess.run(["git", "checkout", "-b", "dev/interrupted"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "app.txt").write_text("interrupted work\n", encoding="utf-8")
+
+    result = branch_ensure_return(tmp_path, "main", "dev/interrupted")
+
+    assert result.ok is True
+    assert _stash_oids(tmp_path) == user_stashes
+    assert subprocess.run(
+        ["git", "branch", "--show-current"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True,
+    ).stdout.strip() == "main"
+    assert subprocess.run(
+        ["git", "show", "dev/interrupted:app.txt"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True,
+    ).stdout == "interrupted work\n"
+
+
+def test_branch_return_commit_failure_does_not_checkout_base(monkeypatch, tmp_path):
+    from prizmkit_runtime import gitops
+
+    calls = []
+
+    def fake_run(_root, args):
+        args = tuple(args)
+        calls.append(args)
+        if args[:3] == ("rev-parse", "--abbrev-ref", "HEAD"):
+            return gitops.GitCommandResult(args, 0, "dev/interrupted\n", "")
+        if args and args[0] == "commit":
+            return gitops.GitCommandResult(args, 1, "", "commit failed")
+        if args[:2] == ("status", "--porcelain"):
+            return gitops.GitCommandResult(args, 0, " M app.txt\n", "")
+        return gitops.GitCommandResult(args, 0, "", "")
+
+    monkeypatch.setattr(gitops, "run_git_command", fake_run)
+
+    result = gitops.branch_ensure_return(tmp_path, "main", "dev/interrupted")
+
+    assert result.ok is False
+    assert not any(args[:2] == ("checkout", "main") for args in calls)
+    assert not any(args and args[0] == "stash" for args in calls)
+
+
+def test_non_current_reset_preserves_dirty_workspace_and_user_stashes(tmp_path):
+    from prizmkit_runtime.gitops import reset_cleanup_branch
+
+    _init_merge_repo(tmp_path)
+    subprocess.run(["git", "branch", "dev/other"], cwd=tmp_path, check=True)
+    manifest = tmp_path / ".prizmkit" / "manifest.json"
+    manifest.write_text('{"version":"stale"}\n', encoding="utf-8")
+    subprocess.run(["git", "stash", "push", "-m", "user-stash", "--", ".prizmkit/manifest.json"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    user_stashes = _stash_oids(tmp_path)
+    (tmp_path / "app.txt").write_text("unstaged\n", encoding="utf-8")
+    (tmp_path / "staged.txt").write_text("staged\n", encoding="utf-8")
+    subprocess.run(["git", "add", "staged.txt"], cwd=tmp_path, check=True)
+    (tmp_path / "untracked.txt").write_text("untracked\n", encoding="utf-8")
+    before = subprocess.run(["git", "status", "--porcelain"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout
+
+    reset_result = reset_cleanup_branch(tmp_path, "dev/other", return_branch="main", delete=False)
+
+    assert reset_result.branch_preserved is True
+    assert reset_result.checkout_discarded is False
+    assert subprocess.run(["git", "branch", "--show-current"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout.strip() == "main"
+    assert subprocess.run(["git", "status", "--porcelain"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout == before
+    assert _stash_oids(tmp_path) == user_stashes
+    assert subprocess.run(["git", "show-ref", "--verify", "refs/heads/dev/other"], cwd=tmp_path, check=False).returncode == 0
+
+    clean_result = reset_cleanup_branch(tmp_path, "dev/other", return_branch="main", delete=True)
+
+    assert clean_result.deleted is True
+    assert subprocess.run(["git", "status", "--porcelain"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout == before
+    assert _stash_oids(tmp_path) == user_stashes
+
+
 def test_worktree_runtime_context_uses_safe_deterministic_path(tmp_path):
     from prizmkit_runtime.gitops import BranchContext, WorktreePolicy, worktree_runtime_context
 

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.127",
+  "version": "1.1.129",
   "skills": {
     "prizmkit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",
@@ -30,10 +30,10 @@
       "hasScripts": false
     },
     "prizmkit-code-review": {
-      "description": "Independent read-only review with Main-Agent finding adjudication, direct repairs, bounded convergence, and a minimal final report.",
+      "description": "Bounded Main-Agent code review with evidence-based finding adjudication, direct repairs, verification, and append-only progress reporting.",
       "tier": "1",
       "category": "prizmkit-skill",
-      "hasAssets": true,
+      "hasAssets": false,
       "hasScripts": true
     },
     "prizmkit-committer": {

package/bundled/skills/feature-planner/SKILL.md

@@ -361,8 +361,8 @@ Key requirements:
 - descriptions: minimum 15 words (error), recommended minimum 30/50/80/100+ for low/medium/high/critical (warning). No upper limit — more detail prevents AI guessing
 - `estimated_complexity` determines pipeline execution tier:
   - `low` / `medium` → **lite** (single agent, no subagents)
-  - `high` → **standard** (orchestrator + reviewer guardrails, 3-agent metadata)
-  - `critical` → **full** (strongest orchestrator/reviewer guardrails). Use for: architectural changes touching 10+ files, cross-module refactoring with API surface changes, or safety/security/data-loss risk
+  - `high` → **standard** (Main-Agent review guardrails, 3-agent compatibility metadata)
+  - `critical` → **full** (strongest Main-Agent review guardrails). Use for: architectural changes touching 10+ files, cross-module refactoring with API surface changes, or safety/security/data-loss risk
 
 **IMPORTANT: Do NOT hand-write the final JSON file.** Instead:
 1. Write a draft JSON to a temporary path (e.g., `.prizmkit/plans/feature-list.draft.json`)

package/bundled/skills/prizmkit/SKILL.md

@@ -110,7 +110,7 @@ PrizmKit supports any development scenario through the same skill chain. `/prizm
 | `/prizmkit-plan` | First implementation planning step: run ahead of `/prizmkit-implement` to turn natural language into `spec.md` + `plan.md` with executable tasks. | "specify", "plan", "new task", "architect", "break it down" |
 | `/prizmkit-implement` | Implementation step: use after `/prizmkit-plan` to execute `plan.md` tasks with TDD where applicable, task order, and checkpoints. | "implement", "build", "code it", "start coding" |
 | `/prizmkit-test` | Risk-triggered quality gate: run after implementation when behavior, interfaces, data, security, or deploy risk requires tests and boundary coverage. | "test", "run tests", "verify", "quality check", "boundary tests" |
-| `/prizmkit-code-review` | Full path quality gate: run after implementation; requires the dedicated reviewer agent in the active checkout and stops if that launch mode is unavailable. | "review", "check code", "code review", "is it ready to commit" |
+| `/prizmkit-code-review` | Full path quality gate: the current Main Agent reviews and repairs the complete change in the active checkout without direct or indirect review delegation. | "review", "check code", "code review", "is it ready to commit" |
 | `/prizmkit-retrospective` | Docs maintenance step: run after review/implementation when structure, interfaces, dependencies, behavior, or durable knowledge changed. | "retrospective", "retro", "update docs", "sync docs", "wrap up" |
 | `/prizmkit-committer` | Final lifecycle commit step: use after required gates are satisfied; safely stages and creates a Conventional Commit without changing changelog by default. | "commit", "submit", "finish", "done" |
 | `/prizmkit-prizm-docs` | Documentation system entry point: use for init/status/rebuild/validate/migrate or out-of-band repair, not normal development sync. | "initialize docs", "check docs", "rebuild docs", "validate docs", "docs drifted" |

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

@@ -1,16 +1,25 @@
 ---
 name: "prizmkit-code-review"
-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)"
+description: "Review the complete current change in a bounded Main-Agent loop. Adjudicate findings with evidence, directly repair accepted findings, verify repairs, and append progress until the review converges to PASS or stops with unresolved findings as NEEDS_FIXES. (project)"
 ---
 
 # PrizmKit Code Review
 
-Use a dual-layer review loop: the Main Agent owns iterative review and repair, while fresh independent Reviewers act only as semantic-risk gates.
+Use one Main-Agent review loop. The current Main Agent is the only Code Review executor: it performs the complete review, filters candidate findings, repairs accepted findings, verifies the repairs, and decides the final result.
+
+## Execution Boundary
+
+- Do not delegate any part of Code Review directly or indirectly.
+- Do not invoke another review skill or review workflow from inside this skill.
+- Do not launch review work through a general-purpose execution unit or relabel it as a finder, verifier, audit, compatibility review, verification, or gap sweep.
+- These restrictions apply for the entire review phase, including candidate discovery, evidence checks, repair verification, and final gap analysis.
+- The Main Agent may directly use non-delegating read, search, edit, and test capabilities in the active workspace.
+- `{artifact_dir}/review-report.md` is the only persisted review artifact. Do not append separate Review Notes to `context-snapshot.md`.
 
 ## When to Use
 
 - After `/prizmkit-implement` as the Full path quality gate
-- For Fast path when behavior, risk, or the user warrants review
+- For Fast path when behavior, impact, or the user warrants review
 - When the user asks to validate implementation, find defects, assess regressions, or decide commit readiness
 
 ## Input
@@ -19,167 +28,101 @@ Use a dual-layer review loop: the Main Agent owns iterative review and repair, w
 |---|---|---|
 | `artifact_dir` | No | Directory containing `spec.md` and `plan.md`. Reuse a caller-provided directory; otherwise locate the current completed change artifact. |
 
-## Required Assets
+## Required Asset
 
-- `${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
-
-Do not weaken or summarize the Reviewer prompt. The protocol specifies semantic capabilities rather than platform-specific tool names.
 
 ## Phase 0: Initialize Report and Collect Context
 
 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.
+2. At the start of every execution, 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:
+4. Inspect 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.
-
-### Checkout Access
-
-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.
-
-## Phase 1: Semantic Risk Assessment
-
-Classify the current change from behavior and failure impact, not changed-file count or a fixed path allowlist:
-
-- `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.
+5. Review in the active workspace so dirty and untracked content is authoritative.
+6. If no changes exist, append final verification and exactly one final result with `PASS`, then finish.
 
-Append `## Risk Assessment` with the selected risk and concrete reasons before review begins.
+## Phase 1: Main-Agent Review Loop
 
-## Phase 2: Main-Agent Self-Review Loop
+The Main Agent reviews and repairs in the current context. The fixed limit is ten completed review rounds.
 
-The Main Agent reviews and repairs in the current context. Track Main-Agent rounds independently from Reviewer launch attempts:
+Track cumulative counts:
 
 ```yaml
 main_review_rounds: 0
-independent_reviewers_started: 0
-reviewer_1_accepted_high: false
+accepted_findings: 0
+fixed_findings: 0
+rejected_findings: 0
+unresolved_findings: 0
 ```
 
-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.
-
-### Main-Agent Self-Review Loop
+### Review One Round
 
 Each round examines the complete current change against goals, contracts, rules, callers, dependents, regression risks, and test evidence.
 
-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:
+1. Identify concrete candidate findings. A finding must describe a reproducible failure scenario, affected behavior, and supporting evidence.
+2. Classify each candidate as exactly one of:
+   - `accepted`: concrete evidence supports the failure scenario and an in-scope repair is required;
+   - `rejected`: code, tests, contracts, or governing evidence disproves the failure scenario;
+   - `unresolved`: correctness cannot be established or repaired safely with the available evidence or environment.
+3. Treat Missing tools, permissions, environment, or required evidence as an unresolved finding when they prevent required verification. Do not treat missing evidence as success.
+4. Append `## Main Review Round N` with findings, accepted, rejected, unresolved, and the next action.
+5. Apply these rules:
 
 ```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
+accepted = 0 and unresolved = 0                     -> review converged
+accepted > 0 and round < 10                         -> Main Agent directly repairs, verifies, and continues
+accepted > 0 at ten completed review rounds         -> NEEDS_FIXES
+unresolved > 0                                      -> NEEDS_FIXES
+repair cannot be completed safely                   -> unresolved finding -> NEEDS_FIXES
+required verification fails or cannot be performed -> unresolved finding -> 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.
-
-## Phase 3: Independent Reviewer 1
-
-After Main-Agent self-review and required tests converge:
+When all candidate findings are rejected, `accepted = 0` and `unresolved = 0`, so the review converges. Rejected findings do not cause another round.
 
-- low risk: skip all independent Reviewers and proceed to final verification;
-- medium or high risk: launch Reviewer 1.
+## Phase 2: Repair and Verification
 
-Before launch, append:
-
-```markdown
-## Independent Reviewer 1
-
-- Status: RUNNING
-- Risk Trigger: <medium|high>
-```
+When a round has accepted findings and fewer than ten rounds have completed:
 
-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.
+1. Main Agent directly repairs every accepted in-scope finding in the active workspace.
+2. Run targeted tests, static checks, or other verification appropriate to each repaired behavior.
+3. Inspect resulting changes and ensure the repair did not introduce a new regression.
+4. Append `## Repair Verification` with fixed findings, verification evidence, and the next round.
+5. Start the next complete review round.
 
-### Reviewer Infrastructure Failure
+If a repair is unsafe, incomplete, or cannot receive required verification, record the affected finding as unresolved and finish with `NEEDS_FIXES`.
 
-If the Reviewer cannot start, exits abnormally, returns unusable output, or lacks essential context:
-
-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.
-
-### Finding Adjudication
-
-For a usable Reviewer result, append `## Independent Reviewer 1 Result`, then classify every finding as accepted or rejected with evidence.
-
-```text
-accepted = 0 -> Reviewer 1 converged
-accepted > 0 -> Main Agent repairs, verifies, and reruns its self-review loop
-```
-
-Accepted findings do not automatically trigger another independent Reviewer.
-
-## Phase 4: Reviewer 2 Eligibility
-
-Reviewer 2 is allowed only when every condition is true:
-
-- 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.
-
-Accepted medium or low findings alone never trigger Reviewer 2. Medium risk never starts Reviewer 2.
-
-When eligible, append a RUNNING section and launch one fresh Reviewer 2 with the unchanged complete-review prompt and current change input.
-
-After Reviewer 2:
-
-- 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.
-
-## Phase 5: Append-Only Reporting
+## Phase 3: Append-Only Reporting
 
 `{artifact_dir}/review-report.md` is the only required persisted review artifact.
 
 Within one execution, append new sections only. Do not rewrite an earlier progress section. Append after:
 
-- 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.
+- final verification;
+- the final result.
+
+An interrupted execution remains `IN_PROGRESS` and shows its latest completed phase. It has no terminal verdict.
 
-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 4: Final Verification and Result
 
-## Phase 6: Final Result
+Before completing:
 
-Append exactly one final result:
+1. Confirm the final workspace still represents the complete reviewed change.
+2. Confirm required tests and checks have credible evidence.
+3. Confirm no accepted or unresolved finding remains for `PASS`.
+4. Append `## Final Verification`.
+5. Append exactly one final result:
 
 ```markdown
 ## Final Result
 
-- Verdict: PASS | NEEDS_FIXES | BLOCKED
-- Risk: low | medium | high
+- Verdict: PASS | NEEDS_FIXES
 - Main Review Rounds: <count>
-- Independent Reviewers Started: <count>
 - Accepted Findings: <count>
 - Fixed Findings: <count>
 - Rejected Findings: <count>
@@ -189,9 +132,8 @@ Append exactly one final result:
 
 Final outcomes:
 
-- `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`: review converged with `accepted = 0`, `unresolved = 0`, and required verification evidence is complete.
+- `NEEDS_FIXES`: round ten still has accepted findings, any finding remains unresolved, a repair cannot be completed safely, or required verification is unavailable or failed.
 
 Exactly one final result is allowed. Do not append progress after Final Result.
 
@@ -199,4 +141,3 @@ Completion handoff:
 
 - `PASS`: run `/prizmkit-retrospective` when structural docs or durable knowledge changed; otherwise proceed to `/prizmkit-committer`.
 - `NEEDS_FIXES`: report unresolved findings and stop.
-- `BLOCKED`: report infrastructure evidence and permit recovery.