prizmkit 1.1.126 → 1.1.128

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

@@ -1,16 +1,16 @@
 ---
 name: "prizmkit-code-review"
-description: "Run a risk-routed dual-layer code review against the current spec, plan, workspace changes, applicable rules, contracts, and test evidence. The Main Agent first self-reviews and repairs for up to ten rounds, then semantic risk determines whether zero, one, or two fresh read-only independent Reviewers are required. Findings remain Main-Agent adjudicated, Reviewer 3 is forbidden, and one append-only progress report records the execution through PASS, NEEDS_FIXES, or BLOCKED. (project)"
+description: "Review the complete current change in a bounded Main-Agent loop. Adjudicate findings with evidence, directly repair accepted findings, verify repairs, and append progress until the review converges to PASS or stops with unresolved findings as NEEDS_FIXES. (project)"
 ---
 
 # PrizmKit Code Review
 
-Use a dual-layer review loop: the Main Agent owns iterative review and repair, while fresh independent Reviewers act only as semantic-risk gates.
+Use one Main-Agent review loop. The Main Agent performs the complete review, filters candidate findings, repairs accepted findings, verifies the repairs, and decides the final result without delegating code review.
 
 ## When to Use
 
 - After `/prizmkit-implement` as the Full path quality gate
-- For Fast path when behavior, risk, or the user warrants review
+- For Fast path when behavior, impact, or the user warrants review
 - When the user asks to validate implementation, find defects, assess regressions, or decide commit readiness
 
 ## Input
@@ -19,167 +19,101 @@ Use a dual-layer review loop: the Main Agent owns iterative review and repair, w
 |---|---|---|
 | `artifact_dir` | No | Directory containing `spec.md` and `plan.md`. Reuse a caller-provided directory; otherwise locate the current completed change artifact. |
 
-## Required Assets
+## Required Asset
 
-- `${SKILL_DIR}/references/reviewer-agent-prompt.md`: independent Reviewer input and output contract
 - `${SKILL_DIR}/references/review-report-template.md`: report lifecycle and append contract
-- `${SKILL_DIR}/assets/reviewer-role.json`: semantic read-only and non-delegating Reviewer boundary
-
-Do not weaken or summarize the Reviewer prompt. The protocol specifies semantic capabilities rather than platform-specific tool names.
 
 ## Phase 0: Initialize Report and Collect Context
 
 1. Resolve `{artifact_dir}` and `{artifact_dir}/review-report.md`.
-2. replace any prior report with a new execution header using the report template. The new report begins with `## Status: IN_PROGRESS` and contains no prior Final Result.
+2. At the start of every execution, replace any prior report with a new execution header using the report template. The new report begins with `## Status: IN_PROGRESS` and contains no prior Final Result.
 3. Read `spec.md`, `plan.md`, relevant `/prizmkit-test` evidence, `.prizmkit/prizm-docs/root.prizm`, applicable progressive docs, and project rules.
-4. Inspect and capture the complete current Git change:
+4. Inspect the complete current Git change:
    - staged and unstaged tracked changes;
    - untracked files;
    - deleted and renamed files;
    - relevant unchanged callers, dependents, contracts, and tests.
-5. Preserve the existing Reviewer input behavior: staged and unstaged Git diffs, full content of every untracked file, and explicit deleted/renamed states.
-6. If no changes exist, append risk `low` and exactly one final result with `PASS`, then finish without a Reviewer.
-
-### Checkout Access
-
-Prefer direct access to the active checkout. If the platform forces an isolated worktree, provide the same staged and unstaged diffs, untracked file contents, and changed-path states; use the worktree only for baseline and surrounding-context reads. Do not require workspace-equivalence proof.
-
-## Phase 1: Semantic Risk Assessment
+5. Review in the active workspace so dirty and untracked content is authoritative.
+6. If no changes exist, append final verification and exactly one final result with `PASS`, then finish.
 
-Classify the current change from behavior and failure impact, not changed-file count or a fixed path allowlist:
+## Phase 1: Main-Agent Review Loop
 
-- `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.
+The Main Agent reviews and repairs in the current context. The fixed limit is ten completed review rounds.
 
-Mixed risks use the highest applicable level. A large mechanical diff is not automatically high; a small money or authorization change is high.
-
-Append `## Risk Assessment` with the selected risk and concrete reasons before review begins.
-
-## Phase 2: Main-Agent Self-Review Loop
-
-The Main Agent reviews and repairs in the current context. Track Main-Agent rounds independently from Reviewer launch attempts:
+Track cumulative counts:
 
 ```yaml
 main_review_rounds: 0
-independent_reviewers_started: 0
-reviewer_1_accepted_high: false
+accepted_findings: 0
+fixed_findings: 0
+rejected_findings: 0
+unresolved_findings: 0
 ```
 
-Every Reviewer Agent launch attempt increments `independent_reviewers_started`, including a retry that starts a new Agent. The total may never exceed the semantic-risk limit.
-
-### Main-Agent Self-Review Loop
+### Review One Round
 
 Each round examines the complete current change against goals, contracts, rules, callers, dependents, regression risks, and test evidence.
 
-1. Identify concrete candidate findings.
-2. Classify each as:
-   - `accepted`: evidence supports the failure scenario;
-   - `rejected`: code or governing evidence disproves it or its regression path.
-3. Append `## Main Review Round N` with findings, accepted, rejected, and next action.
-4. Apply these rules:
+1. Identify concrete candidate findings. A finding must describe a reproducible failure scenario, affected behavior, and supporting evidence.
+2. Classify each candidate as exactly one of:
+   - `accepted`: concrete evidence supports the failure scenario and an in-scope repair is required;
+   - `rejected`: code, tests, contracts, or governing evidence disproves the failure scenario;
+   - `unresolved`: correctness cannot be established or repaired safely with the available evidence or environment.
+3. Treat Missing tools, permissions, environment, or required evidence as an unresolved finding when they prevent required verification. Do not treat missing evidence as success.
+4. Append `## Main Review Round N` with findings, accepted, rejected, unresolved, and the next action.
+5. Apply these rules:
 
 ```text
-accepted = 0                                 -> self-review converged
-accepted > 0 and round < 10                  -> Main Agent directly repairs, verifies, and continues
-accepted > 0 at ten completed Main-Agent rounds -> NEEDS_FIXES
-repair cannot be completed safely            -> NEEDS_FIXES
-unresolved new in-scope test failure          -> NEEDS_FIXES
+accepted = 0 and unresolved = 0                     -> review converged
+accepted > 0 and round < 10                         -> Main Agent directly repairs, verifies, and continues
+accepted > 0 at ten completed review rounds         -> NEEDS_FIXES
+unresolved > 0                                      -> NEEDS_FIXES
+repair cannot be completed safely                   -> unresolved finding -> NEEDS_FIXES
+required verification fails or cannot be performed -> unresolved finding -> NEEDS_FIXES
 ```
 
-When all findings are rejected, `accepted = 0` and the phase converges. Main-Agent rounds never increase the independent Reviewer counter. The fixed limit is ten completed Main-Agent rounds.
+When all candidate findings are rejected, `accepted = 0` and `unresolved = 0`, so the review converges. Rejected findings do not cause another round.
 
-After each repair batch, append `## Repair Verification` with fixed findings, verification evidence, and next phase.
-
-## Phase 3: Independent Reviewer 1
-
-After Main-Agent self-review and required tests converge:
-
-- low risk: skip all independent Reviewers and proceed to final verification;
-- medium or high risk: launch Reviewer 1.
-
-Before launch, append:
-
-```markdown
-## Independent Reviewer 1
-
-- Status: RUNNING
-- Risk Trigger: <medium|high>
-```
+## Phase 2: Repair and Verification
 
-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.
+When a round has accepted findings and fewer than ten rounds have completed:
 
-### Reviewer Infrastructure Failure
+1. Main Agent directly repairs every accepted in-scope finding in the active workspace.
+2. Run targeted tests, static checks, or other verification appropriate to each repaired behavior.
+3. Inspect resulting changes and ensure the repair did not introduce a new regression.
+4. Append `## Repair Verification` with fixed findings, verification evidence, and the next round.
+5. Start the next complete review round.
 
-If the Reviewer cannot start, exits abnormally, returns unusable output, or lacks essential context:
+If a repair is unsafe, incomplete, or cannot receive required verification, record the affected finding as unresolved and finish with `NEEDS_FIXES`.
 
-1. append the observable failure;
-2. count the failed launch attempt against the semantic-risk Reviewer limit;
-3. allow at most one infrastructure retry at this same Reviewer position only when the risk limit still has an unused launch;
-4. append a new RUNNING retry section before retrying and increment the Reviewer launch counter;
-5. if the retry fails or the risk limit is exhausted, append Final Result `BLOCKED` and stop;
-6. do not convert infrastructure failure into a code finding;
-7. Do not substitute Main-Agent self-review for a required independent result.
-
-### Finding Adjudication
-
-For a usable Reviewer result, append `## Independent Reviewer 1 Result`, then classify every finding as accepted or rejected with evidence.
-
-```text
-accepted = 0 -> Reviewer 1 converged
-accepted > 0 -> Main Agent repairs, verifies, and reruns its self-review loop
-```
-
-Accepted findings do not automatically trigger another independent Reviewer.
-
-## Phase 4: Reviewer 2 Eligibility
-
-Reviewer 2 is allowed only when every condition is true:
-
-- risk is `high`;
-- Reviewer 1 contained at least one accepted high-severity finding;
-- all accepted high findings were repaired;
-- targeted verification passed;
-- Main-Agent self-review reconverged.
-
-Accepted medium or low findings alone never trigger Reviewer 2. Medium risk never starts Reviewer 2.
-
-When eligible, append a RUNNING section and launch one fresh Reviewer 2 with the unchanged complete-review prompt and current change input.
-
-After Reviewer 2:
-
-- accepted = 0: proceed to final verification;
-- accepted > 0: Main Agent repairs, verifies, and runs its final self-review loop;
-- unresolved repair: `NEEDS_FIXES`;
-- Do not launch Reviewer 3 under any condition.
-
-## Phase 5: Append-Only Reporting
+## Phase 3: Append-Only Reporting
 
 `{artifact_dir}/review-report.md` is the only required persisted review artifact.
 
 Within one execution, append new sections only. Do not rewrite an earlier progress section. Append after:
 
-- risk assessment;
 - every Main-Agent review round;
 - every repair and verification batch;
-- every Reviewer launch;
-- every Reviewer result and adjudication;
-- every infrastructure retry;
-- final verification.
+- final verification;
+- the final result.
+
+An interrupted execution remains `IN_PROGRESS` and shows its latest completed phase. It has no terminal verdict.
 
-A RUNNING section is not edited after completion; append a separate result section. An interrupted execution remains `IN_PROGRESS` and shows its latest running or completed phase.
+## Phase 4: Final Verification and Result
 
-## Phase 6: Final Result
+Before completing:
 
-Append exactly one final result:
+1. Confirm the final workspace still represents the complete reviewed change.
+2. Confirm required tests and checks have credible evidence.
+3. Confirm no accepted or unresolved finding remains for `PASS`.
+4. Append `## Final Verification`.
+5. Append exactly one final result:
 
 ```markdown
 ## Final Result
 
-- Verdict: PASS | NEEDS_FIXES | BLOCKED
-- Risk: low | medium | high
+- Verdict: PASS | NEEDS_FIXES
 - Main Review Rounds: <count>
-- Independent Reviewers Started: <count>
 - Accepted Findings: <count>
 - Fixed Findings: <count>
 - Rejected Findings: <count>
@@ -189,9 +123,8 @@ Append exactly one final result:
 
 Final outcomes:
 
-- `PASS`: Main-Agent review converged, every required independent review completed, and no accepted finding remains unresolved.
-- `NEEDS_FIXES`: Main-Agent round ten still has accepted findings, a repair is unsafe, or verification remains unresolved.
-- `BLOCKED`: a required independent Reviewer position failed and either its one permitted retry failed or the semantic-risk launch limit left no retry capacity; essential independent-review context is unavailable.
+- `PASS`: review converged with `accepted = 0`, `unresolved = 0`, and required verification evidence is complete.
+- `NEEDS_FIXES`: round ten still has accepted findings, any finding remains unresolved, a repair cannot be completed safely, or required verification is unavailable or failed.
 
 Exactly one final result is allowed. Do not append progress after Final Result.
 
@@ -199,4 +132,3 @@ Completion handoff:
 
 - `PASS`: run `/prizmkit-retrospective` when structural docs or durable knowledge changed; otherwise proceed to `/prizmkit-committer`.
 - `NEEDS_FIXES`: report unresolved findings and stop.
-- `BLOCKED`: report infrastructure evidence and permit recovery.

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

@@ -16,17 +16,6 @@ Within that execution, append sections only. Never edit or replace an earlier pr
 
 ## 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
@@ -36,6 +25,7 @@ Within that execution, append sections only. Never edit or replace an earlier pr
 - Findings: <count>
 - Accepted: <count>
 - Rejected: <count>
+- Unresolved: <count>
 - Next: <next action>
 ```
 
@@ -44,34 +34,18 @@ Within that execution, append sections only. Never edit or replace an earlier pr
 ```markdown
 ## Repair Verification
 
-- Source: <main|reviewer-1|reviewer-2>
 - Fixed Findings: <count>
 - Verification: <evidence summary>
 - Next: <next action>
 ```
 
-### Independent Reviewer Running
-
-```markdown
-## Independent Reviewer <N>
-
-- Status: RUNNING
-- Risk Trigger: <medium|high>
-- Attempt: <1|2>
-```
-
-### Independent Reviewer Result
+### Final Verification
 
 ```markdown
-## Independent Reviewer <N> Result
+## Final Verification
 
-- Status: <COMPLETED|BLOCKED>
-- Result: <PASS|FINDINGS|BLOCKED>
-- Findings: <count>
-- Accepted: <count>
-- Rejected: <count>
-- Accepted High: <count>
-- Next: <next action>
+- Status: <COMPLETED|FAILED>
+- Evidence: <evidence summary>
 ```
 
 ## Final Result
@@ -81,10 +55,8 @@ Exactly one Final Result terminates a completed execution:
 ```markdown
 ## Final Result
 
-- Verdict: <PASS|NEEDS_FIXES|BLOCKED>
-- Risk: <low|medium|high>
+- Verdict: <PASS | NEEDS_FIXES>
 - Main Review Rounds: <count>
-- Independent Reviewers Started: <count>
 - Accepted Findings: <count>
 - Fixed Findings: <count>
 - Rejected Findings: <count>
@@ -96,8 +68,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.
-- Append RUNNING before each independent Reviewer launch or retry.
-- Do not modify a RUNNING section after completion; append its Result section.
+- 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.
 - 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.

package/bundled/skills/prizmkit-code-review/scripts/render_review_report.py

@@ -9,15 +9,10 @@ import sys
 from pathlib import Path
 from typing import Any
 
-VERDICTS = {"PASS", "NEEDS_FIXES", "BLOCKED"}
-RISKS = {"low", "medium", "high"}
+VERDICTS = {"PASS", "NEEDS_FIXES"}
 EVENTS = {
-    "risk-assessment",
     "main-review-round",
     "repair-verification",
-    "reviewer-running",
-    "reviewer-result",
-    "infrastructure-failure",
     "final-verification",
 }
 FINAL_HEADING = "## Final Result"
@@ -49,13 +44,6 @@ def _require_count(data: dict[str, Any], name: str, *, maximum: int | None = Non
     return value
 
 
-def _require_risk(data: dict[str, Any]) -> str:
-    risk = data.get("risk")
-    if risk not in RISKS:
-        raise ReportStateError(f"risk has invalid value: {risk!r}")
-    return risk
-
-
 def _report_text(path: Path) -> str:
     try:
         return path.read_text(encoding="utf-8")
@@ -87,24 +75,6 @@ def _render_event(data: dict[str, Any]) -> str:
     if event not in EVENTS:
         raise ReportStateError(f"event has invalid value: {event!r}")
 
-    if event == "risk-assessment":
-        risk = _require_risk(data)
-        reasons = data.get("reasons")
-        if not isinstance(reasons, list) or not reasons or not all(
-            isinstance(reason, str) and reason.strip() for reason in reasons
-        ):
-            raise ReportStateError("reasons must be a non-empty string array")
-        limit = {"low": 0, "medium": 1, "high": 2}[risk]
-        lines = [
-            "## Risk Assessment",
-            "",
-            f"- Risk: {risk}",
-            f"- Independent Reviewer Limit: {limit}",
-            "- Reasons:",
-        ]
-        lines.extend(f"  - {reason.strip()}" for reason in reasons)
-        return "\n".join(lines)
-
     if event == "main-review-round":
         round_number = _require_count(data, "round", maximum=10)
         if round_number < 1:
@@ -112,8 +82,11 @@ def _render_event(data: dict[str, Any]) -> str:
         findings = _require_count(data, "findings")
         accepted = _require_count(data, "accepted")
         rejected = _require_count(data, "rejected")
-        if accepted + rejected != findings:
-            raise ReportStateError("accepted + rejected must equal findings")
+        unresolved = _require_count(data, "unresolved")
+        if accepted + rejected + unresolved != findings:
+            raise ReportStateError(
+                "accepted + rejected + unresolved must equal findings"
+            )
         return "\n".join(
             [
                 f"## Main Review Round {round_number}",
@@ -122,93 +95,30 @@ def _render_event(data: dict[str, Any]) -> str:
                 f"- Findings: {findings}",
                 f"- Accepted: {accepted}",
                 f"- Rejected: {rejected}",
+                f"- Unresolved: {unresolved}",
                 f"- Next: {_require_text(data, 'next')}",
             ]
         )
 
     if event == "repair-verification":
-        source = _require_text(data, "source")
-        if source not in {"main", "reviewer-1", "reviewer-2"}:
-            raise ReportStateError(f"source has invalid value: {source!r}")
         return "\n".join(
             [
                 "## Repair Verification",
                 "",
-                f"- Source: {source}",
                 f"- Fixed Findings: {_require_count(data, 'fixed_findings')}",
                 f"- Verification: {_require_text(data, 'verification')}",
                 f"- Next: {_require_text(data, 'next')}",
             ]
         )
 
-    if event == "reviewer-running":
-        reviewer = _require_count(data, "reviewer", maximum=2)
-        if reviewer < 1:
-            raise ReportStateError("reviewer must be 1 or 2")
-        risk = _require_risk(data)
-        if risk == "low" or (risk == "medium" and reviewer == 2):
-            raise ReportStateError("reviewer exceeds the semantic risk limit")
-        attempt = data.get("attempt", 1)
-        if attempt not in {1, 2}:
-            raise ReportStateError("attempt must be 1 or 2")
-        return "\n".join(
-            [
-                f"## Independent Reviewer {reviewer}",
-                "",
-                "- Status: RUNNING",
-                f"- Risk Trigger: {risk}",
-                f"- Attempt: {attempt}",
-            ]
-        )
-
-    if event == "reviewer-result":
-        reviewer = _require_count(data, "reviewer", maximum=2)
-        if reviewer < 1:
-            raise ReportStateError("reviewer must be 1 or 2")
-        result = data.get("result")
-        if result not in {"PASS", "FINDINGS", "BLOCKED"}:
-            raise ReportStateError(f"result has invalid value: {result!r}")
-        findings = _require_count(data, "findings")
-        accepted = _require_count(data, "accepted")
-        rejected = _require_count(data, "rejected")
-        accepted_high = _require_count(data, "accepted_high")
-        if accepted + rejected != findings or accepted_high > accepted:
-            raise ReportStateError("reviewer finding counts are inconsistent")
-        status = "BLOCKED" if result == "BLOCKED" else "COMPLETED"
-        return "\n".join(
-            [
-                f"## Independent Reviewer {reviewer} Result",
-                "",
-                f"- Status: {status}",
-                f"- Result: {result}",
-                f"- Findings: {findings}",
-                f"- Accepted: {accepted}",
-                f"- Rejected: {rejected}",
-                f"- Accepted High: {accepted_high}",
-                f"- Next: {_require_text(data, 'next')}",
-            ]
-        )
-
-    if event == "infrastructure-failure":
-        reviewer = _require_count(data, "reviewer", maximum=2)
-        attempt = _require_count(data, "attempt", maximum=2)
-        if reviewer < 1 or attempt < 1:
-            raise ReportStateError("reviewer and attempt must be at least 1")
-        return "\n".join(
-            [
-                f"## Independent Reviewer {reviewer} Infrastructure Failure",
-                "",
-                f"- Attempt: {attempt}",
-                f"- Evidence: {_require_text(data, 'evidence')}",
-                f"- Next: {_require_text(data, 'next')}",
-            ]
-        )
-
+    status = _require_text(data, "status")
+    if status not in {"COMPLETED", "FAILED"}:
+        raise ReportStateError(f"status has invalid value: {status!r}")
     return "\n".join(
         [
             "## Final Verification",
             "",
-            f"- Status: {_require_text(data, 'status')}",
+            f"- Status: {status}",
             f"- Evidence: {_require_text(data, 'evidence')}",
         ]
     )
@@ -227,28 +137,28 @@ def append_final_result(path: Path, data: Any) -> None:
     verdict = valid.get("verdict")
     if verdict not in VERDICTS:
         raise ReportStateError(f"verdict has invalid value: {verdict!r}")
-    risk = _require_risk(valid)
     main_rounds = _require_count(valid, "main_review_rounds", maximum=10)
-    reviewers = _require_count(valid, "independent_reviewers_started", maximum=2)
-    if reviewers > {"low": 0, "medium": 1, "high": 2}[risk]:
-        raise ReportStateError("independent_reviewers_started exceeds risk limit")
     accepted = _require_count(valid, "accepted_findings")
     fixed = _require_count(valid, "fixed_findings")
     rejected = _require_count(valid, "rejected_findings")
     unresolved = _require_count(valid, "unresolved_findings")
-    if verdict == "PASS" and unresolved:
-        raise ReportStateError("PASS cannot contain unresolved findings")
-    if verdict == "NEEDS_FIXES" and not unresolved:
-        raise ReportStateError("NEEDS_FIXES requires unresolved findings")
+    if fixed > accepted:
+        raise ReportStateError("fixed_findings cannot exceed accepted_findings")
+    if verdict == "PASS" and (unresolved or fixed != accepted):
+        raise ReportStateError(
+            "PASS requires every accepted finding fixed and no unresolved findings"
+        )
+    if verdict == "NEEDS_FIXES" and not unresolved and fixed == accepted:
+        raise ReportStateError(
+            "NEEDS_FIXES requires an unfixed accepted or unresolved finding"
+        )
 
     section = "\n".join(
         [
             FINAL_HEADING,
             "",
             f"- Verdict: {verdict}",
-            f"- Risk: {risk}",
             f"- Main Review Rounds: {main_rounds}",
-            f"- Independent Reviewers Started: {reviewers}",
             f"- Accepted Findings: {accepted}",
             f"- Fixed Findings: {fixed}",
             f"- Rejected Findings: {rejected}",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.1.126",
+  "version": "1.1.128",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {

package/src/scaffold.js

@@ -81,6 +81,7 @@ const RETIRED_POWERSHELL_RUNTIME_FILES = new Set([
   'lib/heartbeat.ps1',
 ]);
 const LEGACY_TEAM_NAME = ['prizm', 'dev', 'team'].join('-');
+const RETIRED_CODE_REVIEW_AGENT_BASENAME = 'prizmkit-code-reviewer';
 const LEGACY_AGENT_BASENAMES = [
   `${LEGACY_TEAM_NAME}-dev`,
   `${LEGACY_TEAM_NAME}-reviewer`,
@@ -102,7 +103,10 @@ export async function removeRetiredAgentTeamArtifacts(platform, projectRoot, dry
       : path.join(projectRoot, '.codebuddy', 'agents');
   const agentExtensions = platform === 'codex' ? ['.toml', '.md'] : ['.md'];
 
-  for (const basename of LEGACY_AGENT_BASENAMES) {
+  const retiredBasenames = platform === 'claude'
+    ? [...LEGACY_AGENT_BASENAMES, RETIRED_CODE_REVIEW_AGENT_BASENAME]
+    : LEGACY_AGENT_BASENAMES;
+  for (const basename of retiredBasenames) {
     for (const extension of agentExtensions) {
       const filePath = path.join(agentDir, `${basename}${extension}`);
       if (!await fs.pathExists(filePath)) continue;
@@ -226,12 +230,10 @@ export async function installSkills(platform, skills, projectRoot, dryRun, runti
 
   // Load Claude command adapter for skill conversion
   let convertSkillToCommand;
-  let getClaudeSkillAgentDefinitions;
   let convertSkillToCodex;
   if (platform === 'claude') {
     const commandAdapter = await loadAdapter('claude', 'command-adapter.js');
     convertSkillToCommand = commandAdapter.convertSkillToCommand;
-    getClaudeSkillAgentDefinitions = commandAdapter.getClaudeSkillAgentDefinitions;
   } else if (platform === 'codex') {
     const codexSkillAdapter = await loadAdapter('codex', 'skill-adapter.js');
     convertSkillToCodex = codexSkillAdapter.convertSkill;
@@ -323,19 +325,6 @@ export async function installSkills(platform, skills, projectRoot, dryRun, runti
           await fs.copy(path.join(corePath, subdir), path.join(assetTargetDir, subdir));
         }
       }
-
-      const roleManifestPath = path.join(corePath, 'assets', 'reviewer-role.json');
-      const roleManifest = await fs.pathExists(roleManifestPath)
-        ? await fs.readJson(roleManifestPath)
-        : null;
-      const agentDefinitions = getClaudeSkillAgentDefinitions(skillName, roleManifest);
-      if (agentDefinitions.length > 0) {
-        const agentsDir = path.join(projectRoot, '.claude', 'agents');
-        await fs.ensureDir(agentsDir);
-        for (const definition of agentDefinitions) {
-          await fs.writeFile(path.join(agentsDir, definition.fileName), definition.content);
-        }
-      }
       console.log(chalk.green(`      ✓ .claude/commands/${skillName}.md`));
     } else if (platform === 'codex') {
       const content = await fs.readFile(skillMdPath, 'utf8');

package/bundled/skills/prizmkit-code-review/assets/reviewer-role.json

@@ -1,19 +0,0 @@
-{
-  "protocol_version": 2,
-  "role_name": "prizmkit-code-reviewer",
-  "description": "Use only as the one fresh independent read-only Reviewer for a completed /prizmkit-code-review round.",
-  "observational_capabilities": [
-    "read-files",
-    "search-content",
-    "search-paths"
-  ],
-  "unavailable_capabilities": [
-    "workspace-mutation",
-    "shell-execution",
-    "downstream-execution-creation",
-    "delegation-equivalent-behavior",
-    "orchestration-reentry",
-    "skill-invocation"
-  ],
-  "execution_mode": "foreground-independent-review"
-}