prizmkit 1.1.125 → 1.1.127

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_minimal_reviewer_loop():
+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,10 +827,10 @@ def test_headless_review_guidance_uses_minimal_reviewer_loop():
 
     for path in headless_guidance_files:
         text = path.read_text(encoding="utf-8")
-        assert "platform-supported" 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 "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
@@ -838,16 +838,17 @@ def test_headless_review_guidance_uses_minimal_reviewer_loop():
         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 "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 "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 "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
@@ -2233,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(
@@ -2253,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.125",
+  "version": "1.1.127",
   "skills": {
     "prizmkit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",

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

@@ -1,169 +1,202 @@
 ---
 name: "prizmkit-code-review"
-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)"
+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 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.
+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. |
 
 ## Required Assets
 
-Read before starting the loop:
-
-- `${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
+- `${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
 
-The contract defines semantic capabilities rather than depending on a platform-specific tool or Agent name.
+Do not weaken or summarize the Reviewer prompt. The protocol specifies semantic capabilities rather than platform-specific tool names.
 
-## Phase 0: Collect Review Context
+## Phase 0: Initialize Report and Collect Context
 
-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:
+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;
-   - 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.
+   - 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 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.
+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:
 
-If the platform forces an isolated worktree:
+- `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.
 
-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.
+Mixed risks use the highest applicable level. A large mechanical diff is not automatically high; a small money or authorization change is high.
 
-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.
+Append `## Risk Assessment` with the selected risk and concrete reasons before review begins.
 
-## Phase 1: Convergence Loop
+## Phase 2: Main-Agent Self-Review Loop
 
-Track only:
+The Main Agent reviews and repairs in the current context. Track Main-Agent rounds independently from Reviewer launch attempts:
 
 ```yaml
-round: 1
-completed_rounds: 0
-final_verdict: null
-findings: []
+main_review_rounds: 0
+independent_reviewers_started: 0
+reviewer_1_accepted_high: false
 ```
 
-The safety fuse is fixed at ten completed rounds. It is not caller-configurable and never converts unresolved defects into `PASS`.
+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.
 
-### Step 1: Launch One Fresh Reviewer
+### Main-Agent Self-Review Loop
+
+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:
+
+```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
+```
 
-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.
+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.
 
-Do not substitute Main-Agent self-review. If the Reviewer cannot start or exits abnormally, return `BLOCKED`. This does not consume a completed round.
+After each repair batch, append `## Repair Verification` with fixed findings, verification evidence, and next phase.
 
-### Step 2: Complete Independent Review
+## Phase 3: Independent Reviewer 1
 
-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.
+After Main-Agent self-review and required tests converge:
 
-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.
+- low risk: skip all independent Reviewers and proceed to final verification;
+- medium or high risk: launch Reviewer 1.
 
-A usable result is either:
+Before launch, append:
 
-- `PASS`: no concrete finding;
-- `FINDINGS`: one or more structured candidate defects.
+```markdown
+## Independent Reviewer 1
 
-If output is partial, malformed, or cannot be understood safely, return `BLOCKED`. This does not consume a completed round.
+- Status: RUNNING
+- Risk Trigger: <medium|high>
+```
 
-### Step 3: Main Agent Filters Findings
+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.
 
-A usable Reviewer result completes the current round. Increment `completed_rounds` before adjudication.
+### Reviewer Infrastructure Failure
 
-For every finding, classify it as:
+If the Reviewer cannot start, exits abnormally, returns unusable output, or lacks essential context:
 
-- `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.
+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.
 
-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.
+### Finding Adjudication
 
-Apply these rules exactly:
+For a usable Reviewer result, append `## Independent Reviewer 1 Result`, then classify every finding as accepted or rejected with evidence.
 
 ```text
-Reviewer returns PASS                         -> PASS
-Reviewer returns findings and accepted = 0  -> PASS
-Reviewer returns findings and accepted > 0  -> repair or stop
+accepted = 0 -> Reviewer 1 converged
+accepted > 0 -> Main Agent repairs, verifies, and reruns its self-review loop
 ```
 
-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.
+Accepted findings do not automatically trigger another independent Reviewer.
 
-### Step 4: Repair or Stop
+## Phase 4: Reviewer 2 Eligibility
 
-When `accepted > 0`:
+Reviewer 2 is allowed only when every condition is true:
 
-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.
+- 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.
 
-## Phase 2: Persist Final Report
+Accepted medium or low findings alone never trigger Reviewer 2. Medium risk never starts Reviewer 2.
 
-Write exactly one required review artifact:
+When eligible, append a RUNNING section and launch one fresh Reviewer 2 with the unchanged complete-review prompt and current change input.
 
-```text
-{artifact_dir}/review-report.md
-```
+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
+
+`{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.
 
-Use `${SKILL_DIR}/references/review-report-template.md`. The report records:
+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.
 
-- `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.
+## Phase 6: Final Result
 
-Do not create a separate persisted review state file. Raw Reviewer output remains in the session log.
+Append exactly one final result:
 
-The report may be rendered directly or with the optional helper by sending minimal JSON on standard input:
+```markdown
+## Final Result
 
-```bash
-python3 ${SKILL_DIR}/scripts/render_review_report.py \
-  {artifact_dir}/review-report.md < review-report-input.json
+- 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>
 ```
 
-The input may be transient; it is not a required artifact.
+Final outcomes:
 
-## 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`: 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.
+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 code findings and stop.
-- `BLOCKED`: report the infrastructure reason and allow retry without consuming the code-convergence budget.
+- `NEEDS_FIXES`: report unresolved findings and stop.
+- `BLOCKED`: report infrastructure evidence and permit recovery.

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

@@ -1,40 +1,104 @@
-# Review Report Output Template
+# Review Report Lifecycle Template
 
-Write the final result to `{artifact_dir}/review-report.md`. This is the only required persisted review artifact.
+`{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|BLOCKED>
-## Rounds Completed: <number>
-## Total Findings: <total> → Fixed: <fixed>, Rejected: <rejected>, Unresolved: <unresolved>
+## 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
 
-## Findings
+```markdown
+## Independent Reviewer <N>
 
-### Finding <N>: <short title>
+- Status: RUNNING
+- Risk Trigger: <medium|high>
+- Attempt: <1|2>
+```
 
-- Severity: <high|medium|low>
-- Location: <filepath:line|project-level>
-- Problem: <what was wrong and why it mattered>
-- Failure Scenario: <concrete input or state>
-- Disposition: <fixed in round N|rejected — concrete evidence|unresolved — reason>
+### Independent Reviewer Result
 
-## Blocker
+```markdown
+## Independent Reviewer <N> Result
 
-<Include only for BLOCKED: concise infrastructure failure and required action.>
+- Status: <COMPLETED|BLOCKED>
+- Result: <PASS|FINDINGS|BLOCKED>
+- Findings: <count>
+- Accepted: <count>
+- Rejected: <count>
+- Accepted High: <count>
+- Next: <next action>
+```
 
-## Summary
+## Final Result
+
+Exactly one Final Result terminates a completed execution:
+
+```markdown
+## Final Result
 
-<One to three sentences covering the final outcome. Do not expose private 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
 
-- A no-change review uses zero completed rounds and returns `PASS`.
-- A usable Reviewer result counts as one completed round.
-- Reviewer launch failure, abnormal exit, or unusable output returns `BLOCKED` and does not add a completed round.
-- `PASS` requires no accepted or unresolved finding. This includes a Reviewer `PASS` and a findings result where the Main Agent rejects every finding with concrete evidence.
-- The tenth completed round with accepted findings returns `NEEDS_FIXES`.
-- `BLOCKED` describes review infrastructure or missing essential context, not a code defect.
-- Overwrite the same report on each execution; keep raw round output only in the session log.
-- Do not persist a separate review state file.
+- 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.