prizmkit 1.1.131 → 1.1.135

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

@@ -3,6 +3,7 @@
 import json
 import os
 import shutil
+import signal
 import subprocess
 import sys
 from pathlib import Path
@@ -1959,26 +1960,29 @@ def test_completed_checkout_blocks_rerun_until_explicit_reset(monkeypatch, tmp_p
         runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
 
 
-def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_path):
+def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_path, capsys):
     from prizmkit_runtime import runners
+    from prizmkit_runtime.gitops import current_branch as real_current_branch
+    from prizmkit_runtime.gitops import run_git_command as real_run_git_command
     from prizmkit_runtime.runner_models import family_for, parse_invocation
     from prizmkit_runtime.task_checkout import load_task_checkout
 
     monkeypatch.setenv("DEV_BRANCH", "dev/F-001-interrupt")
     paths = _make_paths(tmp_path)
+    _init_bookkeeping_repo(paths.project_root)
     family = family_for("feature", paths)
     invocation = parse_invocation(family, "run", ())
     invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
     _install_runner_session_fakes(monkeypatch, runners)
-    ensure_calls = []
-    monkeypatch.setattr(runners, "run_git_plan", lambda project_root, plan: SimpleNamespace(ok=True, plan=plan, results=()))
-    monkeypatch.setattr(runners, "branch_ensure_return", lambda project_root, base, branch: ensure_calls.append((base, branch)))
+    monkeypatch.setattr(runners, "current_branch", real_current_branch)
+    monkeypatch.setattr(runners, "run_git_command", real_run_git_command)
 
     class InterruptingLauncher:
         def __init__(self, config):
             self.config = config
 
         def run(self):
+            (self.config.cwd / "interrupted.txt").write_text("preserved\n", encoding="utf-8")
             raise KeyboardInterrupt
 
     monkeypatch.setattr(runners, "AISessionLauncher", InterruptingLauncher)
@@ -1987,11 +1991,158 @@ def test_no_worktree_interrupt_saves_wip_and_returns_to_base(monkeypatch, tmp_pa
         runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
 
     checkout = load_task_checkout(family.state_dir, family.task_type, "F-001")
+    captured = capsys.readouterr()
     assert checkout is not None
     assert checkout.is_active
     assert checkout.active_dev_branch == "dev/F-001-interrupt"
     assert checkout.base_branch == "main"
-    assert ensure_calls == [("main", "dev/F-001-interrupt")]
+    assert real_current_branch(paths.project_root) == "main"
+    assert subprocess.run(
+        ["git", "show", "dev/F-001-interrupt:interrupted.txt"],
+        cwd=paths.project_root,
+        check=True,
+        stdout=subprocess.PIPE,
+        text=True,
+    ).stdout == "preserved\n"
+    assert "Interrupted task F-001: work preserved and returned to main" in captured.err
+
+
+def test_interrupt_return_failure_is_reported_without_forcing_checkout(monkeypatch, tmp_path, capsys):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-interrupt")
+    paths = _make_paths(tmp_path)
+    family = family_for("feature", paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    _install_runner_session_fakes(monkeypatch, runners)
+    monkeypatch.setattr(runners, "run_git_plan", lambda project_root, plan: SimpleNamespace(ok=True, plan=plan, results=()))
+    failure = SimpleNamespace(
+        ok=False,
+        plan=SimpleNamespace(
+            commands=(
+                SimpleNamespace(allow_failure=True),
+                SimpleNamespace(allow_failure=False),
+            )
+        ),
+        results=(
+            SimpleNamespace(
+                args=("commit", "--no-verify", "-m", "wip"),
+                return_code=1,
+                stdout="nothing to commit",
+                stderr="",
+            ),
+            SimpleNamespace(
+                args=("checkout", "main"),
+                return_code=1,
+                stdout="",
+                stderr="untracked files would be overwritten",
+            ),
+        ),
+    )
+    monkeypatch.setattr(runners, "branch_ensure_return", lambda project_root, base, branch: failure)
+
+    class InterruptingLauncher:
+        def __init__(self, config):
+            self.config = config
+
+        def run(self):
+            raise KeyboardInterrupt
+
+    monkeypatch.setattr(runners, "AISessionLauncher", InterruptingLauncher)
+
+    with pytest.raises(KeyboardInterrupt):
+        runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+
+    captured = capsys.readouterr()
+    assert "Could not safely return to main; leaving dev/F-001-interrupt active" in captured.err
+    assert "git checkout main failed: untracked files would be overwritten" in captured.err
+    assert "After resolving the Git blocker, run: git checkout main" in captured.err
+
+
+def test_worktree_interrupt_preserves_task_worktree_without_returning_caller_checkout(monkeypatch, tmp_path, capsys):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("USE_WORKTREE", "1")
+    monkeypatch.setenv("DEV_BRANCH", "dev/F-001-interrupt")
+    paths = _make_paths(tmp_path)
+    family = family_for("feature", paths)
+    invocation = parse_invocation(family, "run", ())
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
+    observed = _install_runner_session_fakes(monkeypatch, runners)
+    monkeypatch.setattr(
+        runners,
+        "ensure_linked_worktree",
+        lambda runtime: SimpleNamespace(ok=True, runtime=runtime, reason=""),
+    )
+    return_calls = []
+    monkeypatch.setattr(
+        runners,
+        "branch_ensure_return",
+        lambda *args: return_calls.append(args),
+    )
+
+    class InterruptingLauncher:
+        def __init__(self, config):
+            self.config = config
+
+        def run(self):
+            raise KeyboardInterrupt
+
+    monkeypatch.setattr(runners, "AISessionLauncher", InterruptingLauncher)
+
+    with pytest.raises(KeyboardInterrupt):
+        runners._process_item(family, invocation, "F-001", paths, initial_metadata={})
+
+    captured = capsys.readouterr()
+    assert observed.wip_calls
+    assert return_calls == []
+    assert "Interrupted task F-001: work preserved in" in captured.err
+    assert "task worktree remains active" in captured.err
+
+
+def test_run_pipeline_command_bridges_sigterm_and_restores_handler(monkeypatch, tmp_path):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import PipelineRunResult
+
+    paths = _make_paths(tmp_path)
+    paths.feature_plan.write_text("{}", encoding="utf-8")
+    previous = signal.getsignal(signal.SIGTERM)
+    observed = []
+
+    def interrupted_pipeline(*args, **kwargs):
+        installed = signal.getsignal(signal.SIGTERM)
+        observed.append(installed)
+        try:
+            installed(signal.SIGTERM, None)
+        except KeyboardInterrupt:
+            return PipelineRunResult(False, 1, "interrupted", "interrupted")
+        raise AssertionError("SIGTERM handler did not interrupt the pipeline")
+
+    monkeypatch.setattr(runners, "_run_pipeline", interrupted_pipeline)
+
+    result = runners.run_pipeline_command("feature", "run", (), paths)
+
+    assert result.exit_code == 1
+    assert result.message == "processed=1 completed=False stopped_reason=interrupted"
+    assert observed and observed[0] not in {previous, signal.SIG_DFL, signal.SIG_IGN}
+    assert signal.getsignal(signal.SIGTERM) is previous
+
+
+def test_interruption_cleanup_shield_ignores_and_restores_signals():
+    from prizmkit_runtime.processes import shield_interruption_signals
+
+    previous_sigint = signal.getsignal(signal.SIGINT)
+    previous_sigterm = signal.getsignal(signal.SIGTERM)
+
+    with shield_interruption_signals():
+        assert signal.getsignal(signal.SIGINT) is signal.SIG_IGN
+        assert signal.getsignal(signal.SIGTERM) is signal.SIG_IGN
+
+    assert signal.getsignal(signal.SIGINT) is previous_sigint
+    assert signal.getsignal(signal.SIGTERM) is previous_sigterm
 
 
 @pytest.mark.parametrize(

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

@@ -828,13 +828,12 @@ def test_headless_review_guidance_uses_main_agent_review_loop():
 
     for path in headless_guidance_files:
         text = path.read_text(encoding="utf-8")
-        assert "Main-Agent review loop" in text, path
+        assert "mandatory Main-Agent review" in text, path
         assert "up to ten completed rounds" in text, path
         assert "text final-verdict" 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 "strict structural capability gate" in text, path
+        assert "skill-owned independent Reviewer" 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
 
@@ -843,9 +842,11 @@ def test_headless_review_guidance_uses_main_agent_review_loop():
     assert "untracked, deleted, and renamed files" in skill_text
     assert "accepted = 0" in skill_text
     assert "ten completed review rounds" in skill_text
+    assert "## Phase 3: Independent Code Review" in skill_text
+    assert "maximum five Reviewer responses" in skill_text
     assert "## Final Result" in skill_text
     assert "PASS | NEEDS_FIXES" in skill_text
-    assert "BLOCKED" not in skill_text
+    assert "Verdict: <PASS | NEEDS_FIXES | 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
@@ -2012,6 +2013,32 @@ def test_branch_return_commits_wip_without_touching_user_stashes(tmp_path):
     ).stdout == "interrupted work\n"
 
 
+def test_branch_return_ignores_installed_runtime_paths_without_blocking_wip_commit(tmp_path):
+    from prizmkit_runtime.gitops import branch_ensure_return
+
+    _init_merge_repo(tmp_path)
+    (tmp_path / ".gitignore").write_text(".prizmkit/*\n.claude/\n", encoding="utf-8")
+    subprocess.run(["git", "add", ".gitignore"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "ignore installed runtime"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    runtime_file = tmp_path / ".prizmkit" / "dev-pipeline" / "cli.py"
+    runtime_file.parent.mkdir(parents=True)
+    runtime_file.write_text("# installed runtime\n", encoding="utf-8")
+    manifest = tmp_path / ".prizmkit" / "manifest.json"
+    manifest.write_text('{}\n', encoding="utf-8")
+    subprocess.run(["git", "checkout", "-b", "dev/interrupted"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    (tmp_path / "interrupted.txt").write_text("preserved\n", encoding="utf-8")
+
+    result = branch_ensure_return(tmp_path, "main", "dev/interrupted")
+
+    assert result.ok is True
+    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:interrupted.txt"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True,
+    ).stdout == "preserved\n"
+
+
 def test_branch_return_commit_failure_does_not_checkout_base(monkeypatch, tmp_path):
     from prizmkit_runtime import gitops
 
@@ -2200,8 +2227,8 @@ def test_git_status_safe_ignores_worktree_support_assets(monkeypatch, tmp_path):
     joined = " ".join(status_args)
     assert ":(top,exclude).prizmkit-worktree" in status_args
     assert ":(top,exclude).claude" in status_args
-    assert ":(top,exclude).prizmkit/dev-pipeline" in status_args
-    assert ":(top,exclude,glob).prizmkit/dev-pipeline/**" in status_args
+    assert ":(top,exclude).prizmkit" in status_args
+    assert ":(top,exclude,glob).prizmkit/**" in status_args
     assert all(exclude in status_args for exclude in HIDDEN_TOOL_WORKTREE_EXCLUDES)
     assert ".prizmkit-worktree" in joined
 

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.131",
+  "version": "1.1.135",
   "skills": {
     "prizmkit": {
       "description": "Framework introduction and navigation for the formal single-requirement lifecycle, project initialization, Prizm docs, and independent deployment.",
@@ -23,7 +23,7 @@
       "hasScripts": false
     },
     "prizmkit-plan": {
-      "description": "Formal requirement lifecycle entry: natural language → reviewed spec.md and plan.md with stable artifact identity and workflow-state handoff.",
+      "description": "Formal requirement lifecycle entry: natural language → spec.md and plan.md with mandatory Main-Agent planning review, optional capability-gated independent correctness review, stable artifact identity, and workflow-state handoff.",
       "tier": "1",
       "category": "prizmkit-skill",
       "hasAssets": true,
@@ -37,7 +37,7 @@
       "hasScripts": false
     },
     "prizmkit-code-review": {
-      "description": "Bounded Main-Agent code review with evidence-based finding adjudication, direct repairs, verification, and append-only progress reporting.",
+      "description": "Mandatory bounded Main-Agent code review plus optional capability-gated independent correctness review, with evidence-based adjudication, direct repairs, verification, and append-only progress reporting.",
       "tier": "1",
       "category": "prizmkit-skill",
       "hasAssets": false,

package/bundled/skills/prizmkit/references/workflow-state-protocol.md

@@ -157,12 +157,12 @@ Trusted headless execution:
 ```text
 a trusted host explicitly authorizes the current local task commit
 → host injects mode=<host-defined-headless-mode>, owner=<trusted-host-identifier>,
-  local_commit_authorized=true, push_authorized=false
+  local_commit_authorized=true
 → committer verifies gates and commits automatically
-→ no question, wait, or push is permitted
+→ no question or wait is permitted
 ```
 
-A self-declared or otherwise untrusted headless context does not authorize a commit. Push is never implied by either mode.
+A self-declared or otherwise untrusted headless context does not authorize a commit. Remote publication remains a separate host-runtime decision.
 
 ## Recovery
 

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

@@ -1,24 +1,26 @@
 ---
 name: "prizmkit-code-review"
-description: "Review the complete current change for a formal PrizmKit requirement in a bounded Main-Agent loop. Directly repair accepted findings, verify repairs, converge to PASS or stop with NEEDS_FIXES, and hand off to prizmkit-test. (project)"
+description: "Review the complete current change for a formal PrizmKit requirement with a mandatory bounded Main-Agent loop and optional capability-gated independent correctness review. Directly repair accepted corrections, verify repairs, converge to PASS or stop with NEEDS_FIXES, and hand off to prizmkit-test. (project)"
 ---
 
 # PrizmKit Code Review
 
-`/prizmkit-code-review` is the mandatory review stage after implementation and before the full test stage. The current Main Agent is the only Code Review executor. It owns the complete review loop: it discovers findings, adjudicates them, directly repairs accepted findings, verifies repairs, and continues until the review converges or stops safely.
+`/prizmkit-code-review` is the mandatory review stage after implementation and before the full test stage. The current Main Agent owns the complete baseline review loop: it discovers findings, adjudicates them, directly repairs accepted findings, verifies repairs, and continues until the review converges or stops safely. After convergence, one strictly capability-gated independent Reviewer may objectively check the complete current implementation without taking mutation or final-decision authority.
 
 ## Execution Boundary
 
-- Do not delegate any part of Code Review directly or indirectly.
+- Main-Agent review remains mandatory and must not be delegated directly or indirectly.
+- After Main-Agent convergence only, this skill may create the single independent Reviewer defined by `${SKILL_DIR}/references/independent-code-review.md` when every structural capability in that reference is proven.
 - 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.
+- Do not launch any additional review work through a general-purpose execution unit or relabel it as a finder, verifier, audit, compatibility review, verification, or gap sweep.
+- The independent Reviewer cannot mutate, execute arbitrary commands, or create downstream execution units; prompt instructions never substitute for these structural guarantees.
 - The Main Agent may directly read, search, edit, and run targeted verification in the active workspace.
 - Review repairs occur before the full `/prizmkit-test` stage so final test evidence represents the final reviewed workspace.
 - `{artifact_dir}/review-report.md` is the only persisted review artifact for this execution.
 
 ## Atomic Stage Boundary
 
-`prizmkit-code-review` owns only the complete Main-Agent review, accepted-finding repairs, and review verification. It writes its truthful terminal result and `next_stage`, then returns control. It must not invoke `prizmkit-test` or `prizmkit-implement` itself; the active orchestrator owns outer repair routing and the next-stage invocation.
+`prizmkit-code-review` owns the complete mandatory Main-Agent review, the optional independent correctness review, accepted-correction repairs, and review verification. It writes its truthful terminal result and `next_stage`, then returns control. It must not invoke `prizmkit-test` or `prizmkit-implement` itself; the active orchestrator owns outer repair routing and the next-stage invocation.
 
 ## When to Use
 
@@ -111,7 +113,21 @@ Do not run the full auditable testing protocol as a substitute for this review s
 
 If a repair is unsafe, incomplete, or unverifiable, record an unresolved finding and finish with `NEEDS_FIXES`.
 
-## Phase 3: Final Result
+## Phase 3: Independent Code Review
+
+Run only after the Main-Agent review and repair loop converges with no unresolved finding. Main-Agent review remains mandatory on every host; this optional check never replaces or weakens it.
+
+1. Read `${SKILL_DIR}/references/independent-code-review.md` and follow its complete contract.
+2. Apply its all-or-nothing semantic Host Capability Gate. If any required structural capability is unavailable or unproven, create no Reviewer, append `independent-review-downgrade`, and preserve the valid completed Main-Agent review.
+3. When the gate passes, capture bounded immutable input for the complete current change and create exactly one Code Reviewer with the reference's Initial Reviewer Prompt.
+4. Use maximum five Reviewer responses. Append `independent-review-round` and `independent-adjudication` events. The Main Agent adjudicates every correction as `accepted`, `rejected`, or `unresolved` and retains all mutation authority.
+5. For accepted corrections, repair directly in the active checkout, run targeted verification, and inspect the complete resulting change.
+6. When responses remain, capture the complete fresh state and natively resume the exact same Reviewer. Never create a replacement Reviewer or simulate continuation with a fresh Reviewer plus summary.
+7. If native resume fails after repair, append downgrade and rerun the Main-Agent review over that repair within the existing ten-round safety fuse.
+8. If the fifth response causes a repair, run targeted verification, inspect the complete final change, record `Final State Independently Rechecked: no`, and do not send a sixth response.
+9. `NO_CORRECTION_NEEDED` or all corrections rejected with evidence converges independent review. Any unresolved correction produces `NEEDS_FIXES`.
+
+## Phase 4: Final Result
 
 Before completing:
 

package/bundled/skills/prizmkit-code-review/references/independent-code-review.md

@@ -0,0 +1,243 @@
+# Independent Code Review
+
+## Purpose
+
+Run one optional independent correctness review after the mandatory Main-Agent review and repair loop has converged. The Reviewer determines whether the complete current implementation correctly satisfies the requirement and plan. It is not required to disagree and must return `NO_CORRECTION_NEEDED` when no correction is justified.
+
+This reference is complete within `prizmkit-code-review`. Do not depend on another skill's prompt or a platform-generated Reviewer role.
+
+## Required Ordering and Budget
+
+```text
+Implementation complete
+→ mandatory Main-Agent review and repair loop: maximum ten rounds
+→ optional independent Code Reviewer: maximum five responses
+→ PASS or NEEDS_FIXES
+```
+
+The independent budget does not replace, reduce, or extend the Main-Agent loop. Create at most one Reviewer for this Code Review stage. Never reuse it in another stage.
+
+## Host Capability Gate
+
+The gate is all-or-nothing. Before creating a Reviewer, the host must prove this semantic execution contract:
+
+```yaml
+execution_unit:
+  count: 1
+  access: read-only
+  mutation: unavailable
+  arbitrary_command_execution: unavailable
+  downstream_execution: structurally-unavailable
+  context_continuation: same-unit-native-resume
+  workspace_observation: bounded-active-checkout-input
+  model_configuration: inherit-current-session
+```
+
+Rules:
+
+- Prompt instructions cannot satisfy a missing structural capability.
+- The decision must not branch on platform identity, tool name, execution-unit type name, adapter output, or a platform allowlist.
+- If any capability is missing or cannot be proven, do not create a Reviewer. Use Strict Downgrade.
+- A general execution unit with a prompt saying "do not mutate or delegate" is not eligible when those capabilities remain available.
+- The Reviewer inherits the current session's model configuration. Do not add a separate model-selection contract.
+
+## Review Input
+
+Before each response, the Main Agent captures one bounded review input that is immutable for one response:
+
+```text
+review-input
+├── manifest: input identity, response number, exact changed paths, states, and consistency markers
+├── context: requirement, plan decisions, applicable rules, and prior adjudication on resume
+└── payload: complete captured current change plus targeted supporting material
+```
+
+The Code payload contains a logical representation of:
+
+- staged tracked changes;
+- unstaged tracked changes;
+- untracked files;
+- deleted and renamed files;
+- the exact changed-file manifest;
+- requirement goals and acceptance criteria;
+- relevant plan decisions;
+- applicable project rules and Prizm traps;
+- targeted unchanged callers, dependents, contracts, schemas, or tests implicated by changed interfaces.
+
+The Main Agent captures authoritative workspace state. The Reviewer does not run Git commands. Do not provide broad repository access as a substitute for complete current-change capture. The representation may use host-native immutable content or a read-only temporary payload outside the project change set; the protocol does not require a particular temporary path or command.
+
+Before ordinary review, the Reviewer verifies that manifest, context, and payload agree. Missing paths, unexplained changed files, stale content, or mixed-round input produces `REVIEW_BLOCKED`, never partial success.
+
+## Initial Reviewer Prompt
+
+Instantiate the bracketed fields and retain every boundary below.
+
+```text
+You are the sole independent Code Reviewer for this PrizmKit Code Review stage.
+
+Purpose:
+Objectively determine whether the Main Agent's complete current implementation correctly satisfies the confirmed requirement and plan. You are not an adversary and are not required to disagree. Return NO_CORRECTION_NEEDED when the current implementation is correct.
+
+Response:
+This is response [RESPONSE_NUMBER] of a maximum five responses.
+Review-input identity: [INPUT_ID]
+Manifest: [MANIFEST]
+Context: [CONTEXT]
+Payload: [PAYLOAD]
+Permitted targeted paths, if represented separately: [TARGETED_PATHS_OR_NONE]
+
+Execution boundaries:
+- Complete this review personally.
+- Do not create, schedule, resume, continue, request, or coordinate another execution unit.
+- Do not ask the Main Agent to create a helper.
+- Do not re-enter orchestration, delegation, another review workflow, or an equivalent process.
+- Do not modify, create, delete, rename, stage, commit, or otherwise mutate files.
+- Do not execute commands, tests, builds, network calls, or any operation that can change state.
+- Read only the bounded review input and explicitly permitted targeted paths.
+- Do not perform broad repository discovery or a full repository scan.
+- Report only corrections supported by a concrete target and evidence.
+- Do not invent an issue merely to return feedback.
+- Return REVIEW_BLOCKED rather than delegate or provide an incomplete success result.
+- Do not expose private reasoning traces. Return only the required output.
+
+First validate input consistency. Then review requirement and acceptance-criteria alignment, implementation completeness, concrete failure scenarios, error handling, security, authorization, data integrity, transaction/concurrency/state-transition behavior, public and internal contracts, compatibility and regression risk, test-boundary or evidence defects that can conceal incorrect behavior, and applicable project-rule compliance.
+
+Do not rewrite the plan, modify code, execute tests, or perform broad exploratory repository discovery.
+
+Return exactly one result using the Reviewer Output Protocol.
+```
+
+## Resume Prompt
+
+Resume the exact same Reviewer; do not create a new Reviewer with this text. Instantiate the bracketed fields.
+
+```text
+Continue as the same independent Code Reviewer.
+
+Response:
+This is response [RESPONSE_NUMBER] of a maximum five responses.
+New review-input identity: [INPUT_ID]
+New manifest: [MANIFEST]
+Current context: [CONTEXT]
+Current payload: [PAYLOAD]
+Previously accepted corrections: [ACCEPTED_CORRECTIONS_OR_NONE]
+Repairs actually made: [REPAIRS_OR_NONE]
+Main-Agent targeted verification: [VERIFICATION]
+Previously rejected corrections and rejection evidence: [REJECTIONS_OR_NONE]
+Unresolved items: [UNRESOLVED_OR_NONE]
+
+All initial execution boundaries and the Reviewer Output Protocol remain mandatory. Review the complete current state, not only the repair and not the superseded payload. Do not repeat a rejected correction unless the new state invalidates the recorded rejection evidence. Validate the new input before ordinary review and return exactly one result.
+```
+
+## Reviewer Output Protocol
+
+Return exactly one of these forms. Do not add severity, confidence, dimension, workflow impact, or acceptance fields.
+
+### No Correction Needed
+
+```markdown
+### Result: NO_CORRECTION_NEEDED
+
+### Corrections
+None.
+
+### Summary
+<one or two sentences confirming what was reviewed>
+```
+
+### Correction Needed
+
+```markdown
+### Result: CORRECTION_NEEDED
+
+### Corrections
+
+#### Correction 1
+- Target: <file and location, contract, or behavior>
+- Problem: <what is currently incorrect>
+- Evidence: <concrete basis or reproducible scenario>
+- Correction: <recommended correction>
+
+### Summary
+<one or two sentences describing the current state>
+```
+
+Every correction contains only `Target`, `Problem`, `Evidence`, and `Correction`.
+
+### Review Blocked
+
+```markdown
+### Result: REVIEW_BLOCKED
+
+### Blocker
+- Target: <missing or inconsistent review input>
+- Problem: <why a complete review cannot be performed>
+- Evidence: <concrete mismatch or capability failure>
+- Correction: <what input or host condition would unblock review>
+
+### Summary
+No review verdict was produced.
+```
+
+`REVIEW_BLOCKED` is an internal independent-review result, not a lifecycle verdict.
+
+## Main-Agent Adjudication
+
+The Main Agent verifies each proposed correction and records exactly one decision:
+
+| Decision | Meaning | Action |
+|---|---|---|
+| `accepted` | Evidence proves an in-scope implementation correction is needed. | Main Agent repairs the current implementation and performs targeted verification. |
+| `rejected` | Current code, contracts, tests, artifacts, or rules disprove the proposed problem. | Record concrete rejection evidence and make no change for it. |
+| `unresolved` | Correctness or a safe repair cannot be established. | Record the item and return `NEEDS_FIXES`. |
+
+The Reviewer never modifies files and cannot overrule adjudication.
+
+Independent review converges normally when:
+
+1. the Reviewer returns `NO_CORRECTION_NEEDED`; or
+2. every correction in the current response is rejected with concrete evidence and no unresolved item remains.
+
+## Response Algorithm
+
+1. Run only after the Main-Agent review and repair loop converges with no unresolved finding.
+2. Apply the Host Capability Gate.
+3. If eligible, capture response 1 input and create exactly one Reviewer with the Initial Reviewer Prompt.
+4. Validate the result against the Reviewer Output Protocol and append an independent-review round event.
+5. Adjudicate every correction and append independent-adjudication events. Any unresolved item returns `NEEDS_FIXES`.
+6. For accepted corrections, the Main Agent repairs the active checkout, runs targeted verification, and inspects the complete resulting change.
+7. If one or more responses remain, capture the complete fresh current change and resume the exact same Reviewer with the Resume Prompt. Do not restart the complete ten-round Main-Agent loop after every ordinary independent correction.
+8. If the fifth response causes a repair, no sixth response is allowed. Run targeted verification, inspect the complete final change, record final-budget handling and `Final State Independently Rechecked: no`, and do not exceed the response budget.
+9. End the Reviewer when review converges, reaches the response limit, fails irrecoverably, or the stage becomes blocked. Explicitly terminate it when the host safely supports that operation; otherwise stop sending messages.
+10. Complete the existing final verification and append exactly one `## Final Result` with `PASS` or `NEEDS_FIXES`.
+
+## Strict Downgrade
+
+Use strict downgrade in any of these cases:
+
+- a required capability is unavailable or unproven before creation;
+- Reviewer creation fails;
+- the exact same Reviewer cannot be resumed or resume fails;
+- execution-unit integrity becomes uncertain.
+
+Behavior:
+
+1. Never create a weaker or replacement Reviewer.
+2. Never create a fresh Reviewer with a summary of the prior conversation; a summary is context, not native continuation.
+3. When no Reviewer is created, record the downgrade and continue from the completed Main-Agent review if it remains valid.
+4. When creation fails before any response, record the failure and preserve the completed Main-Agent review.
+5. When resume fails after an accepted repair, Never create a replacement Reviewer; rerun the Main-Agent review over the repair, within the existing ten-round safety fuse, record the downgrade and fallback, and return `NEEDS_FIXES` if review cannot establish convergence.
+6. Reviewer input problems may be corrected and sent to the same Reviewer only while response budget and native continuation remain available. Otherwise downgrade.
+7. Report temporary input-cleanup failures honestly; cleanup failure does not change an otherwise verified review result.
+
+Strict downgrade is visible reduced assurance, not a new lifecycle verdict and not permission to weaken the gate.
+
+## Report Recording
+
+Use the existing append-only `review-report.md` lifecycle and renderer events:
+
+- `independent-review-round`: response number `1..5`, result, correction count, adjudication counts, and next action;
+- `independent-adjudication`: correction summary, `accepted | rejected | unresolved`, evidence, and actual modification;
+- `independent-review-downgrade`: reason, Main-Agent fallback, and whether the final state was independently rechecked.
+
+The report remains the only persisted Code Review artifact. It ends with exactly one `## Final Result`; valid final verdicts remain `PASS | NEEDS_FIXES`.