prizmkit 1.1.131 → 1.1.134

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

@@ -39,6 +39,44 @@ Within that execution, append sections only. Never edit or replace an earlier pr
 - Next: <next action>
 ```
 
+### Independent Review Round
+
+```markdown
+## Independent Review Round <N>
+
+- Result: <NO_CORRECTION_NEEDED | CORRECTION_NEEDED | REVIEW_BLOCKED>
+- Corrections: <count>
+- Accepted: <count>
+- Rejected: <count>
+- Unresolved: <count>
+- Next: <next action>
+```
+
+### Independent Adjudication
+
+```markdown
+## Independent Adjudication
+
+- Correction: <summary>
+- Decision: <accepted | rejected | unresolved>
+- Evidence: <evidence>
+- Modification: <actual change or none>
+```
+
+Repeat this section once per proposed correction.
+
+### Independent Review Downgrade
+
+```markdown
+## Independent Review Downgrade
+
+- Reason: <missing capability, creation failure, or native-resume failure>
+- Fallback: <completed Main-Agent review or Main-Agent re-review of repair>
+- Final State Independently Rechecked: <yes | no | not applicable>
+```
+
+Use this section for strict downgrade, including final-budget handling when the final allowed response causes a repair that cannot receive another independent response.
+
 ### Final Verification
 
 ```markdown
@@ -68,6 +106,9 @@ Exactly one Final Result terminates a completed execution:
 
 - Start of a new execution removes stale progress and terminal results from prior executions.
 - A phase appends its result before the next phase starts.
+- Main-Agent round numbers are from `1` through `10`; independent Reviewer response numbers are from `1` through `5`.
+- Independent Reviewer results are `NO_CORRECTION_NEEDED`, `CORRECTION_NEEDED`, or `REVIEW_BLOCKED`; they never replace the terminal lifecycle verdict.
+- For an independent round, `accepted + rejected + unresolved = corrections`; `NO_CORRECTION_NEEDED` requires zero corrections.
 - Finding counts satisfy `accepted + rejected + unresolved = findings`.
 - `PASS` requires every accepted finding fixed and zero unresolved findings.
 - `NEEDS_FIXES` requires at least one unfixed accepted or unresolved finding.

package/bundled/skills/prizmkit-code-review/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/scripts/render_review_report.py

@@ -13,8 +13,18 @@ VERDICTS = {"PASS", "NEEDS_FIXES"}
 EVENTS = {
     "main-review-round",
     "repair-verification",
+    "independent-review-round",
+    "independent-adjudication",
+    "independent-review-downgrade",
     "final-verification",
 }
+REVIEWER_RESULTS = {
+    "NO_CORRECTION_NEEDED",
+    "CORRECTION_NEEDED",
+    "REVIEW_BLOCKED",
+}
+ADJUDICATION_DECISIONS = {"accepted", "rejected", "unresolved"}
+RECHECK_STATES = {"yes", "no", "not applicable"}
 FINAL_HEADING = "## Final Result"
 
 
@@ -59,6 +69,12 @@ def _ensure_appendable(path: Path) -> None:
         raise ReportStateError("cannot append after Final Result")
 
 
+def _ensure_unique_independent_response(path: Path, response: int) -> None:
+    heading = f"## Independent Review Round {response}"
+    if heading in _report_text(path):
+        raise ReportStateError(f"independent response {response} was already recorded")
+
+
 def _append_section(path: Path, section: str) -> None:
     with path.open("a", encoding="utf-8") as report:
         report.write(section.rstrip() + "\n\n")
@@ -111,6 +127,76 @@ def _render_event(data: dict[str, Any]) -> str:
             ]
         )
 
+    if event == "independent-review-round":
+        response = _require_count(data, "response", maximum=5)
+        if response < 1:
+            raise ReportStateError("response must be at least 1")
+        result = _require_text(data, "result")
+        if result not in REVIEWER_RESULTS:
+            raise ReportStateError(f"result has invalid value: {result!r}")
+        corrections = _require_count(data, "corrections")
+        accepted = _require_count(data, "accepted")
+        rejected = _require_count(data, "rejected")
+        unresolved = _require_count(data, "unresolved")
+        if accepted + rejected + unresolved != corrections:
+            raise ReportStateError(
+                "accepted + rejected + unresolved must equal corrections"
+            )
+        if result == "NO_CORRECTION_NEEDED" and corrections:
+            raise ReportStateError(
+                "NO_CORRECTION_NEEDED requires zero corrections"
+            )
+        if result == "CORRECTION_NEEDED" and not corrections:
+            raise ReportStateError(
+                "CORRECTION_NEEDED requires at least one correction"
+            )
+        if result == "REVIEW_BLOCKED" and not unresolved:
+            raise ReportStateError("REVIEW_BLOCKED requires an unresolved correction")
+        return "\n".join(
+            [
+                f"## Independent Review Round {response}",
+                "",
+                f"- Result: {result}",
+                f"- Corrections: {corrections}",
+                f"- Accepted: {accepted}",
+                f"- Rejected: {rejected}",
+                f"- Unresolved: {unresolved}",
+                f"- Next: {_require_text(data, 'next')}",
+            ]
+        )
+
+    if event == "independent-adjudication":
+        decision = _require_text(data, "decision")
+        if decision not in ADJUDICATION_DECISIONS:
+            raise ReportStateError(f"decision has invalid value: {decision!r}")
+        return "\n".join(
+            [
+                "## Independent Adjudication",
+                "",
+                f"- Correction: {_require_text(data, 'correction')}",
+                f"- Decision: {decision}",
+                f"- Evidence: {_require_text(data, 'evidence')}",
+                f"- Modification: {_require_text(data, 'modification')}",
+            ]
+        )
+
+    if event == "independent-review-downgrade":
+        rechecked = _require_text(data, "final_state_independently_rechecked")
+        if rechecked not in RECHECK_STATES:
+            raise ReportStateError(
+                "final_state_independently_rechecked has invalid value: "
+                f"{rechecked!r}"
+            )
+        return "\n".join(
+            [
+                "## Independent Review Downgrade",
+                "",
+                f"- Reason: {_require_text(data, 'reason')}",
+                f"- Fallback: {_require_text(data, 'fallback')}",
+                f"- Final State Independently Rechecked: {rechecked}",
+            ]
+        )
+
     status = _require_text(data, "status")
     if status not in {"COMPLETED", "FAILED"}:
         raise ReportStateError(f"status has invalid value: {status!r}")
@@ -127,7 +213,13 @@ def _render_event(data: dict[str, Any]) -> str:
 def append_event(path: Path, data: Any) -> None:
     """Append one validated progress event to an active execution."""
     _ensure_appendable(path)
-    _append_section(path, _render_event(_require_object(data)))
+    valid = _require_object(data)
+    if valid.get("event") == "independent-review-round":
+        response = _require_count(valid, "response", maximum=5)
+        if response < 1:
+            raise ReportStateError("response must be at least 1")
+        _ensure_unique_independent_response(path, response)
+    _append_section(path, _render_event(valid))
 
 
 def append_final_result(path: Path, data: Any) -> None:

package/bundled/skills/prizmkit-committer/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: "prizmkit-committer"
-description: "Final commit stage for a formal PrizmKit requirement. Verifies plan, implementation, Main-Agent review, testing, and retrospective evidence; previews and confirms interactive commits; automatically creates authorized local commits in trusted headless sessions; verifies the result; and never pushes without separate authorization. (project)"
+description: "Final commit stage for a formal PrizmKit requirement. Verifies plan, implementation, Main-Agent review, testing, and retrospective evidence; previews and confirms interactive commits; automatically creates authorized local commits in trusted headless sessions; verifies the result; and leaves remote publication to the host runtime. (project)"
 ---
 
 # PrizmKit Committer
@@ -99,11 +99,11 @@ Ask the current user to confirm creation of this local commit. Do not treat a pr
 Trusted headless mode:
 
 - Do not ask a question, wait for input, or render an interactive confirmation request.
-- Require a host-defined non-interactive `mode`, a non-empty trusted `owner` identifier, `local_commit_authorized=true`, and `push_authorized=false` from the execution context.
+- Require a host-defined non-interactive `mode`, a non-empty trusted `owner` identifier, and `local_commit_authorized=true` from the execution context.
 - Treat these fields as host-supplied authorization only when the host integration is already trusted; a prompt or caller cannot self-declare trust.
 - Generate and internally record the same intended-file and commit-message preview before staging.
 - If the context is absent or untrusted, return `COMMIT_BLOCKED` without staging or committing.
-- This mode never asks, waits, or pushes.
+- This mode never asks or waits. Remote publication is controlled by the host runtime, not by this stage.
 
 ### Step 4: Stage Safely After Authorization
 
@@ -132,15 +132,9 @@ git status
 
 Report the commit hash and whether the working tree is clean or contains intentionally uncommitted changes.
 
-### Step 6: Optional Push
+### Step 6: Remote Publication
 
-Pushing is separate from committing and is never part of trusted headless execution. In interactive mode ask explicitly:
-
-```text
-Push this commit to the remote?
-```
-
-A refusal or lack of permission means stop after the local commit. Never push automatically.
+Remote publication is outside this atomic commit stage. The host runtime may perform it only when its own explicit configuration authorizes the operation; this skill does not ask the user or decide whether to publish.
 
 ## Workflow State
 
@@ -165,8 +159,7 @@ For trusted headless execution, the validated execution context additionally con
 {
   "mode": "<host-defined-headless-mode>",
   "owner": "<trusted-host-identifier>",
-  "local_commit_authorized": true,
-  "push_authorized": false
+  "local_commit_authorized": true
 }
 ```
 

package/bundled/skills/prizmkit-committer/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-implement/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-plan/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: "prizmkit-plan"
-description: "Start the formal PrizmKit requirement lifecycle by turning a natural-language change into reviewed spec.md and plan.md artifacts, initializing workflow state, and handing off to prizmkit-implement. Works for features, bug fixes, refactors, migrations, tests, and other formal requirements. (project)"
+description: "Start the formal PrizmKit requirement lifecycle by turning a natural-language change into spec.md and plan.md artifacts, running mandatory Main-Agent planning review plus optional capability-gated independent correctness review, initializing workflow state, and handing off to prizmkit-implement. Works for features, bug fixes, refactors, migrations, tests, and other formal requirements. (project)"
 ---
 
 # PrizmKit Plan
@@ -103,7 +103,7 @@ Precondition: `spec.md` exists with no unresolved blocker.
 
 ## Phase 4: Plan/Spec Review Loop
 
-Run every time `spec.md` or `plan.md` is created or changed.
+Run every time `spec.md` or `plan.md` is created or changed. This is the mandatory Main-Agent baseline on every host.
 
 1. Read `${SKILL_DIR}/references/review-plan-spec-loop.md`.
 2. Review the current artifacts against the requirement and project context.
@@ -115,7 +115,21 @@ Run every time `spec.md` or `plan.md` is created or changed.
 
 The planning review must not implement code, run the full test stage, or launch external orchestration.
 
-## Phase 5: Workflow State and Handoff
+## Phase 5: Independent Plan Review
+
+Run only after the Main-Agent Plan/Spec review converges. This optional check never replaces or weakens the completed local review.
+
+1. Read `${SKILL_DIR}/references/independent-plan-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 and record strict downgrade in `plan.md`.
+3. When the gate passes, capture bounded immutable current-state input and create exactly one Plan Reviewer with the reference's Initial Reviewer Prompt.
+4. Use maximum two Reviewer responses. Adjudicate every correction as `accepted`, `rejected`, or `unresolved`; the Main Agent alone modifies artifacts.
+5. After an accepted correction, perform targeted Plan/Spec verification and, when one response remains, natively resume the exact same Reviewer. Never create a replacement Reviewer or simulate continuation with a fresh Reviewer plus summary.
+6. If native resume fails after modification, record downgrade and rerun the Main-Agent local Plan/Spec review over that modification as specified by the reference.
+7. If the final allowed response causes a modification, run targeted verification, record that the final state was not independently rechecked, and do not exceed the response budget.
+8. Append the terminal `## Independent Plan Review` record. Appending that audit record does not trigger another response.
+9. Any unresolved correction produces `PLAN_BLOCKED`; otherwise independent convergence or strict downgrade may continue to handoff from the valid completed Main-Agent review.
+
+## Phase 6: Workflow State and Handoff
 
 Read `${SKILL_DIR}/references/workflow-state-protocol.md` and create or update:
 

package/bundled/skills/prizmkit-plan/assets/plan-template.md

@@ -113,3 +113,21 @@
 - [ ] [CP-1] After Setup: project builds and tests pass
 - [ ] [CP-2] After Foundation: base changes verified
 - [ ] [CP-3] After each Core group: acceptance criteria pass
+
+## Independent Plan Review
+<!-- Append this terminal audit record after the Main-Agent review and the optional independent-review attempt. -->
+<!-- Appending this terminal record does not trigger another Reviewer response and does not add an implementation task. -->
+
+- Capability Gate: <ENABLED | DOWNGRADED>
+- Downgrade Reason: <reason or none>
+- Reviewer Responses: <0..2>
+- Convergence: <no correction | all rejected | final-budget verification | local-review fallback | strict downgrade>
+- Final State Independently Rechecked: <yes | no | not applicable>
+- Unresolved Corrections: <none for PLAN_READY>
+
+### Adjudication
+<!-- Repeat for every proposed correction. Use `None.` when there were no corrections. -->
+- Correction: <summary>
+- Decision: <accepted | rejected | unresolved>
+- Evidence: <evidence>
+- Modification: <actual change or none>

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

@@ -0,0 +1,242 @@
+# Independent Plan Review
+
+## Purpose
+
+Run one optional independent correctness review after the mandatory Main-Agent Plan/Spec review has converged. The Reviewer checks whether the current `spec.md` and `plan.md` correctly express the requirement and are ready for implementation. It is not required to disagree and must return `NO_CORRECTION_NEEDED` when no correction is justified.
+
+This reference is complete within `prizmkit-plan`. Do not depend on another skill's prompt or a platform-generated Reviewer role.
+
+## Required Ordering and Budget
+
+```text
+Draft spec.md and plan.md
+→ mandatory Main-Agent Plan/Spec review: maximum two rounds
+→ optional independent Plan Reviewer: maximum two responses
+→ PLAN_READY or PLAN_BLOCKED
+```
+
+The independent budget does not replace, reduce, or extend the local review budget. Create at most one Reviewer for the Plan 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, project-relative paths, states, and consistency markers
+├── context: requirement, confirmed clarifications, relevant rules, and prior adjudication on resume
+└── payload: current spec.md, current plan.md, and only targeted supporting material
+```
+
+The Plan payload contains:
+
+- current `spec.md`;
+- current `plan.md`, including tasks;
+- original requirement and confirmed clarification decisions;
+- relevant project rules and Prizm documentation;
+- only the source or contract paths needed to verify concrete planning assumptions.
+
+Do not provide broad repository access as a substitute for capturing input. 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 content, unexplained entries, 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 Plan Reviewer for this PrizmKit Plan stage.
+
+Purpose:
+Objectively determine whether the Main Agent's current specification and implementation plan correctly represent the confirmed requirement and are ready for implementation. You are not an adversary and are not required to disagree. Return NO_CORRECTION_NEEDED when the current artifacts are correct.
+
+Response:
+This is response [RESPONSE_NUMBER] of a maximum two 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 scope correctness, terminology and non-goals, acceptance criteria, goal-to-plan coverage, relevant data/interface/security/compatibility/performance/deployment/migration constraints, dependency evidence, task prerequisites and safe parallel markers, task actionability/testability/resumability, and unjustified scope expansion or overengineering.
+
+Do not review implementation code, execute tests, or redesign the requirement beyond a necessary correction.
+
+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 Plan Reviewer.
+
+Response:
+This is response [RESPONSE_NUMBER] of a maximum two responses.
+New review-input identity: [INPUT_ID]
+New manifest: [MANIFEST]
+Current context: [CONTEXT]
+Current payload: [PAYLOAD]
+Previously accepted corrections: [ACCEPTED_CORRECTIONS_OR_NONE]
+Modifications actually made: [MODIFICATIONS_OR_NONE]
+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 current state, 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: <spec.md or plan.md location, section, or task>
+- Problem: <what is currently incorrect>
+- Evidence: <concrete basis>
+- 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 result.
+
+## Main-Agent Adjudication
+
+The Main Agent verifies each proposed correction and records exactly one decision:
+
+| Decision | Meaning | Action |
+|---|---|---|
+| `accepted` | Evidence proves an in-scope planning correction is needed. | Main Agent modifies `spec.md` and/or `plan.md` and performs targeted verification. |
+| `rejected` | Current artifacts, source, contracts, or rules disprove the proposed problem. | Record concrete rejection evidence and make no change for it. |
+| `unresolved` | Correctness or a safe correction cannot be established. | Record the item and return `PLAN_BLOCKED`. |
+
+The Reviewer never modifies artifacts 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 Plan/Spec review converges with no unresolved `BLOCKER`.
+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.
+5. Adjudicate every correction. Any unresolved item returns `PLAN_BLOCKED`.
+6. For accepted corrections, the Main Agent modifies `spec.md` and/or `plan.md` and applies the relevant part of the existing verification checklist.
+7. If one response remains, capture fresh input and resume the exact same Reviewer with the Resume Prompt.
+8. If the second response causes a modification, no third response is allowed. Perform targeted Plan/Spec verification, record final-budget handling, and set `Final State Independently Rechecked` to `no`.
+9. Append the terminal `## Independent Plan Review` record. Appending the record itself never triggers another response.
+10. 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.
+
+## 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 modification, Never create a replacement Reviewer; rerun the local Plan/Spec review over the modification within its existing local semantics, record the downgrade and fallback, and return `PLAN_BLOCKED` if that verification cannot establish readiness.
+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 planning result.
+
+Strict downgrade is visible reduced assurance, not an error verdict and not permission to weaken the gate.
+
+## Terminal Record
+
+Append the terminal record shape from `${SKILL_DIR}/assets/plan-template.md` after review or downgrade. Include:
+
+- `Capability Gate: ENABLED | DOWNGRADED`;
+- a concrete downgrade reason or `none`;
+- Reviewer responses used, from `0` through `2`;
+- convergence or fallback mode;
+- whether the final state received an independent recheck;
+- every proposed correction, Main-Agent decision, evidence, and actual modification;
+- unresolved items, which must be absent for `PLAN_READY`.
+
+This section is audit metadata, not an implementation task and not input that requires another Reviewer response.

package/bundled/skills/prizmkit-plan/references/review-plan-spec-loop.md

@@ -4,7 +4,7 @@
 
 Run this local planning-quality gate after `spec.md` and `plan.md` are drafted or updated, before handing off to `/prizmkit-implement`.
 
-This is not a separate skill and it does not use a Critic agent. It is a bounded review loop executed inside `prizmkit-plan` to improve the planning artifacts only.
+This is not a separate skill and it does not use a Critic agent. It is the mandatory Main-Agent baseline executed inside `prizmkit-plan` to improve the planning artifacts only. Its maximum of two local rounds remains independent of the optional Reviewer described in `independent-plan-review.md`.
 
 ## Non-Goals
 
@@ -13,7 +13,7 @@ Do not do any of the following from this guide:
 - Start implementation or edit product/source code.
 - Run tests, builds, lint, or package commands.
 - Launch a feature, bugfix, or refactor pipeline.
-- Spawn or require a Critic agent.
+- Spawn or require a Critic agent inside this Main-Agent loop. The separate optional independent review is considered only after this loop converges and only through `independent-plan-review.md`.
 - Create a separate review-loop skill.
 - Expand scope beyond improving `spec.md` and `plan.md`.
 
@@ -87,8 +87,8 @@ Optional findings do not block handoff.
 4. Do not apply `OPTIONAL` findings unless they clearly improve readiness without expanding scope.
 5. If any fixes were applied, rerun this review once.
 6. Stop after at most 2 total review rounds.
-7. If unresolved `BLOCKER` findings remain after the final round, stop planning and ask targeted clarification questions. Do not escalate to a Critic agent.
-8. If no unresolved blockers remain, report that the planning quality gate passed and hand off to `/prizmkit-implement`.
+7. If unresolved `BLOCKER` findings remain after the final round, stop planning and ask targeted clarification questions. Do not escalate from this loop to a Critic agent or treat independent review as blocker recovery.
+8. If no unresolved blockers remain, report that the mandatory Main-Agent planning quality gate passed and hand off to the optional independent Plan review boundary in `independent-plan-review.md`.
 
 ## Output Summary
 

package/bundled/skills/prizmkit-plan/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-retrospective/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