prizmkit 1.1.123 → 1.1.125

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.123",
-  "bundledAt": "2026-07-11T17:38:07.991Z",
-  "bundledFrom": "9a8c719"
+  "frameworkVersion": "1.1.125",
+  "bundledAt": "2026-07-12T10:06:26.471Z",
+  "bundledFrom": "ae3f6a3"
 }

package/bundled/adapters/claude/command-adapter.js

@@ -20,6 +20,67 @@ function toClaudePrizmkitCommand(sub) {
   return `prizmkit-${normalized}`;
 }
 
+const REVIEWER_ROLE_SKILL = 'prizmkit-code-review';
+const REVIEWER_ROLE_FILE = 'prizmkit-code-reviewer.md';
+const REVIEWER_REQUIRED_UNAVAILABLE = new Set([
+  'workspace-mutation',
+  'shell-execution',
+  'downstream-execution-creation',
+  'delegation-equivalent-behavior',
+  'orchestration-reentry',
+  'skill-invocation',
+]);
+const CLAUDE_OBSERVATIONAL_TOOLS = new Map([
+  ['read-files', 'Read'],
+  ['search-content', 'Grep'],
+  ['search-paths', 'Glob'],
+]);
+
+function buildReviewerRoleDefinition(roleManifest) {
+  if (!roleManifest || roleManifest.role_name !== 'prizmkit-code-reviewer') {
+    throw new Error('prizmkit-code-review requires assets/reviewer-role.json');
+  }
+  const unavailable = new Set(roleManifest.unavailable_capabilities || []);
+  for (const capability of REVIEWER_REQUIRED_UNAVAILABLE) {
+    if (!unavailable.has(capability)) {
+      throw new Error(`Reviewer role must make ${capability} unavailable`);
+    }
+  }
+  if (roleManifest.execution_mode !== 'foreground-independent-review') {
+    throw new Error('Reviewer role must use foreground independent review');
+  }
+
+  const tools = (roleManifest.observational_capabilities || []).map(capability => {
+    const tool = CLAUDE_OBSERVATIONAL_TOOLS.get(capability);
+    if (!tool) throw new Error(`Unsupported Reviewer observational capability: ${capability}`);
+    return tool;
+  });
+  if (tools.length === 0) throw new Error('Reviewer role requires observational capabilities');
+
+  return `---
+name: ${roleManifest.role_name}
+description: ${roleManifest.description}
+tools: ${tools.join(', ')}
+permissionMode: dontAsk
+maxTurns: 80
+---
+
+You are a capability-restricted read-only Reviewer execution role.
+
+Read and follow the complete prompt supplied by the Main Agent. Perform the complete review yourself. Your tool allowlist intentionally excludes workspace mutation, shell execution, skill invocation, downstream execution creation, delegation-equivalent behavior, and orchestration re-entry.
+
+If the supplied review cannot be completed with the available read-only capabilities and current context, return \`BLOCKED\` with the missing capability or context. Do not delegate, request a helper, mutate the workspace, or claim \`PASS\` from incomplete work.
+`;
+}
+
+export function getClaudeSkillAgentDefinitions(skillName, roleManifest = null) {
+  if (skillName !== REVIEWER_ROLE_SKILL) return [];
+  return [{
+    fileName: REVIEWER_ROLE_FILE,
+    content: buildReviewerRoleDefinition(roleManifest),
+  }];
+}
+
 /**
  * Convert a core SKILL.md to Claude Code command.md format.
  * @param {string} skillContent - Content of the core SKILL.md
@@ -97,6 +158,20 @@ export async function installCommand(corePath, targetRoot) {
     for (const subdir of subdirs) {
       cpSync(path.join(corePath, subdir), path.join(targetDir, subdir), { recursive: true });
     }
+
+    // Install platform-native capability roles generated from canonical skill semantics.
+    const roleManifestPath = path.join(corePath, 'assets', 'reviewer-role.json');
+    const roleManifest = existsSync(roleManifestPath)
+      ? JSON.parse(await readFile(roleManifestPath, 'utf8'))
+      : null;
+    const agentDefinitions = getClaudeSkillAgentDefinitions(skillName, roleManifest);
+    if (agentDefinitions.length > 0) {
+      const agentsDir = path.join(targetRoot, '.claude', 'agents');
+      mkdirSync(agentsDir, { recursive: true });
+      for (const definition of agentDefinitions) {
+        await writeFile(path.join(agentsDir, definition.fileName), definition.content);
+      }
+    }
   } else {
     // Single file command
     const targetDir = path.join(targetRoot, COMMANDS_DIR);

package/bundled/dev-pipeline/prizmkit_runtime/gitops.py

@@ -11,14 +11,20 @@ from dataclasses import dataclass
 from pathlib import Path
 
 
-HIDDEN_TOOL_WORKTREE_EXCLUDES = (
+PIPELINE_TRANSIENT_EXCLUDES = (
     ":(top,exclude).prizmkit-worktree",
-    ":(top,exclude).skills-lock.json",
-    ":(top,exclude).AGENTS.md",
     ":(top,exclude,glob).*/worktree",
     ":(top,exclude,glob).*/worktree/**",
     ":(top,exclude,glob).*/worktrees",
     ":(top,exclude,glob).*/worktrees/**",
+    ":(top,exclude).prizmkit/state",
+    ":(top,exclude,glob).prizmkit/state/**",
+)
+
+HIDDEN_TOOL_WORKTREE_EXCLUDES = (
+    *PIPELINE_TRANSIENT_EXCLUDES,
+    ":(top,exclude).skills-lock.json",
+    ":(top,exclude).AGENTS.md",
     ":(top,exclude).claude",
     ":(top,exclude,glob).claude/**",
     ":(top,exclude).codebuddy",
@@ -31,12 +37,17 @@ HIDDEN_TOOL_WORKTREE_EXCLUDES = (
     ":(top,exclude,glob).prizmkit/prizm-docs/**",
     ":(top,exclude).prizmkit/config.json",
     ":(top,exclude).prizmkit/manifest.json",
-    ":(top,exclude).prizmkit/state",
-    ":(top,exclude,glob).prizmkit/state/**",
     ":(top,exclude).prizmkit/dev-pipeline",
     ":(top,exclude,glob).prizmkit/dev-pipeline/**",
 )
 
+UNTRACKED_TRANSIENT_EXCLUDES = (
+    *HIDDEN_TOOL_WORKTREE_EXCLUDES,
+    ":(top,exclude,glob)**/__pycache__",
+    ":(top,exclude,glob)**/__pycache__/**",
+    ":(top,exclude,glob)**/*.py[cod]",
+)
+
 PIPELINE_FALLBACK_GIT_NAME = "PrizmKit Pipeline"
 PIPELINE_FALLBACK_GIT_EMAIL = "prizmkit-pipeline@example.invalid"
 

package/bundled/dev-pipeline/prizmkit_runtime/runner_bookkeeping.py

@@ -11,10 +11,37 @@ from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
 
-from .gitops import HIDDEN_TOOL_WORKTREE_EXCLUDES, GitCommandResult, git_status_safe, run_git_command
+from .gitops import (
+    HIDDEN_TOOL_WORKTREE_EXCLUDES,
+    UNTRACKED_TRANSIENT_EXCLUDES,
+    GitCommandResult,
+    git_status_safe,
+    run_git_command,
+)
 from .runner_models import RunnerFamily
 
 
+LOCAL_ONLY_PLATFORM_PATHS = (
+    ".claude/settings.local.json",
+    ".codebuddy/settings.local.json",
+    ".codex/settings.local.json",
+    ".agents/settings.local.json",
+)
+
+
+@dataclass(frozen=True)
+class PreflightWorkspace:
+    """Exact Git paths participating in startup preservation."""
+
+    tracked: tuple[str, ...]
+    visible_untracked: tuple[str, ...]
+    unsafe_local: tuple[str, ...]
+
+    @property
+    def preservable(self) -> tuple[str, ...]:
+        return _unique_paths((*self.tracked, *self.visible_untracked))
+
+
 @dataclass(frozen=True)
 class BookkeepingResult:
     """Result from an optional bookkeeping commit boundary."""
@@ -42,6 +69,81 @@ def _repo_path(project_root: Path, path: Path) -> str:
         return path.as_posix()
 
 
+def _tracked_status_result(project_root: Path) -> GitCommandResult:
+    return run_git_command(project_root, ("status", "--porcelain=v1", "-z", "--untracked-files=no", "--", "."))
+
+
+def _untracked_status_result(project_root: Path) -> GitCommandResult:
+    return run_git_command(
+        project_root,
+        ("ls-files", "--others", "--exclude-standard", "-z", "--", ".", *UNTRACKED_TRANSIENT_EXCLUDES),
+    )
+
+
+def _unique_paths(paths: Sequence[str]) -> tuple[str, ...]:
+    return tuple(dict.fromkeys(path for path in paths if path))
+
+
+def _literal_pathspecs(paths: Sequence[str]) -> tuple[str, ...]:
+    return tuple(f":(top,literal){path}" for path in paths)
+
+
+def _status_record_paths(stdout: str) -> tuple[str, ...]:
+    """Decode exact paths from NUL-delimited porcelain-v1 records."""
+    records = stdout.split("\0")
+    changed: list[str] = []
+    index = 0
+    while index < len(records):
+        record = records[index]
+        index += 1
+        if not record:
+            continue
+        if len(record) < 4 or record[2] != " ":
+            continue
+        status = record[:2]
+        changed.append(record[3:])
+        if "R" in status or "C" in status:
+            if index < len(records) and records[index]:
+                changed.append(records[index])
+                index += 1
+    return _unique_paths(changed)
+
+
+def _preflight_workspace(project_root: Path) -> tuple[PreflightWorkspace | None, GitCommandResult | None]:
+    tracked_result = _tracked_status_result(project_root)
+    if tracked_result.return_code != 0:
+        return None, tracked_result
+    untracked_result = _untracked_status_result(project_root)
+    if untracked_result.return_code != 0:
+        return None, untracked_result
+
+    tracked = _status_record_paths(tracked_result.stdout)
+    visible_untracked = _unique_paths(untracked_result.stdout.split("\0"))
+    unsafe_local = tuple(path for path in tracked if path in LOCAL_ONLY_PLATFORM_PATHS)
+    return PreflightWorkspace(tracked, visible_untracked, unsafe_local), None
+
+
+def _preflight_failure(message: str) -> GitCommandResult:
+    return GitCommandResult(args=("status", "preflight"), return_code=1, stdout="", stderr=message)
+
+
+def _remaining_preflight_changes(project_root: Path) -> GitCommandResult:
+    workspace, failure = _preflight_workspace(project_root)
+    if failure is not None:
+        return failure
+    assert workspace is not None
+    if workspace.unsafe_local:
+        return _preflight_failure(
+            "Refusing to auto-commit local-only platform settings: " + ", ".join(workspace.unsafe_local)
+        )
+    return GitCommandResult(
+        args=("status", "preflight"),
+        return_code=0,
+        stdout="\0".join(workspace.preservable),
+        stderr="",
+    )
+
+
 def _visible_status_result(project_root: Path) -> GitCommandResult:
     return run_git_command(project_root, ("status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES))
 
@@ -85,23 +187,33 @@ def commit_bookkeeping_changes(
 
 
 def commit_preflight_ready_changes(project_root: Path, item_id: str) -> BookkeepingResult:
-    """Preserve visible pre-existing changes before task branch setup."""
-    visible_status = _visible_status_result(project_root)
-    if visible_status.return_code != 0:
-        return BookkeepingResult(attempted=True, committed=False, result=visible_status)
-    paths = _paths_from_status(visible_status.stdout)
+    """Preserve tracked changes and visible untracked files before task branch setup."""
+    workspace, failure = _preflight_workspace(project_root)
+    if failure is not None:
+        return BookkeepingResult(attempted=True, committed=False, result=failure)
+    assert workspace is not None
+    if workspace.unsafe_local:
+        return BookkeepingResult(
+            attempted=True,
+            committed=False,
+            result=_preflight_failure(
+                "Refusing to auto-commit local-only platform settings: " + ", ".join(workspace.unsafe_local)
+            ),
+        )
+    paths = workspace.preservable
     if not paths:
         return BookkeepingResult(attempted=False, committed=False)
-    add_result = run_git_command(project_root, ("add", "-A", "-f", "--", *paths))
+    pathspecs = _literal_pathspecs(paths)
+    add_result = run_git_command(project_root, ("add", "-A", "-f", "--", *pathspecs))
     if add_result.return_code != 0:
         return BookkeepingResult(attempted=True, committed=False, result=add_result)
     result = run_git_command(
         project_root,
-        ("commit", "--no-verify", "-m", f"chore: ready for {item_id}", "--", *paths),
+        ("commit", "--no-verify", "-m", f"chore: ready for {item_id}", "--", *pathspecs),
     )
     if result.return_code != 0:
         return BookkeepingResult(attempted=True, committed=False, result=result)
-    clean_result = _visible_status_result(project_root)
+    clean_result = _remaining_preflight_changes(project_root)
     if clean_result.return_code != 0 or clean_result.stdout.strip():
         return BookkeepingResult(attempted=True, committed=False, result=clean_result)
     return BookkeepingResult(attempted=True, committed=True, result=result)

package/bundled/dev-pipeline/scripts/generate-recovery-prompt.py

@@ -96,10 +96,9 @@ Implement the minimal fix (red → green):
         "Review",
         """\
 Verify fix quality:
-1. Self-review: does the fix address root cause (not just symptom)?
-   Edge cases covered? Follows project conventions?
-2. Run full test suite one final time
-3. If any issues found, fix and re-review (max 3 rounds)""",
+1. Run `/prizmkit-code-review` with the current bugfix artifact directory.
+2. The skill launches one fresh read-only Reviewer per completed round; the Main Agent filters and directly fixes accepted findings.
+3. Continue until no accepted finding remains or the ten-round safety fuse returns `NEEDS_FIXES`; stop and retry later if review returns `BLOCKED`.""",
     ),
     6: (
         "User Verification",

package/bundled/dev-pipeline/templates/bootstrap-prompt.md

@@ -30,7 +30,7 @@ Infer what needs to be done from the feature context above and follow the standa
 
 3. **Implement**: Run `/prizmkit-implement` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` to execute the plan using TDD (write tests first, then implement).
 
-4. **Review**: Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` to review and auto-fix changes against the spec (internal review-fix loop, max 3 rounds).
+4. **Review**: Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill uses one fresh read-only Reviewer per completed round, lets the Main Agent filter and directly fix accepted findings, and stops after at most ten completed rounds.
 
 5. **Test**: Run `/prizmkit-test scope=this-change artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` to generate and verify tests only for this feature's changed scope after review. Do not use bugfix/refactor artifact directories for this gate.
 

package/bundled/dev-pipeline/templates/bootstrap-tier3.md

@@ -240,9 +240,9 @@ For each Verification Gate from the Task Contract, write one evidence line to Im
 
 Review the completed implementation before the scoped feature test gate runs. Use `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` so the code-review skill can read spec, plan, context snapshot, implementation log, and current diff artifacts. Do not require or read a prior `/prizmkit-test` report here; test generation and test-fix looping happen in the next phase.
 
-Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill chooses a platform-supported independent Reviewer strategy and verifies that the Reviewer's snapshot is equivalent to the current workspace under its skill-owned workspace protocol. Do not prescribe Agent launch parameters from this bootstrap prompt.
+Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill chooses a platform-supported fresh read-only Reviewer, prefers direct access to the active checkout, and supplies changed content that a platform-forced worktree cannot see. Do not prescribe Agent launch parameters from this bootstrap prompt.
 
-The skill runs an internal review-fix loop (Reviewer Agent → filter → orchestrator fix, max 3 rounds) and writes `review-report.md` to the artifact directory.
+The skill runs an internal review-fix loop (fresh Reviewer → Main-Agent filter → Main-Agent fix, up to ten completed rounds) and writes `review-report.md` to the artifact directory.
 
 **Gate Check — Review Report**:
 After `/prizmkit-code-review` returns, verify the review report:
@@ -257,7 +257,8 @@ If GATE:MISSING:
 
 Read `review-report.md` and check the Verdict:
 - `PASS` → proceed to next phase
-- `NEEDS_FIXES` → the skill exhausted its max rounds; log the remaining findings and proceed (do not retry externally)
+- `NEEDS_FIXES` → log the unresolved accepted findings and proceed according to the task failure policy (do not retry externally)
+- `BLOCKED` → log the infrastructure reason and stop so the review can be retried
 
 **CP-3**: Review complete, report written.
 

package/bundled/dev-pipeline/templates/bugfix-bootstrap-prompt.md

@@ -180,8 +180,8 @@ After implement completes, verify:
 If `FAST_PATH=true` (≤ 2 tasks, obvious root cause), skip this phase entirely and mark checkpoint step `prizmkit-code-review` as `skipped` before continuing.
 
 Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/bugfix/{{BUG_ID}}/`:
-- The skill chooses a platform-supported independent Reviewer strategy and verifies a workspace-equivalent snapshot under its skill-owned protocol
-- The skill runs an internal review-fix loop (Reviewer → filter → orchestrator fix, max 3 rounds) and writes `review-report.md`
+- The skill chooses a platform-supported fresh read-only Reviewer, prefers direct access to the active checkout, and supplies changed content that a platform-forced worktree cannot see
+- The skill runs an internal review-fix loop (Reviewer → Main-Agent filter → Main-Agent fix, up to ten completed rounds) and writes `review-report.md`
 - `review-report.md` must contain `## Verdict`
 
 **Gate Check — Review Report**:
@@ -196,7 +196,8 @@ If GATE:MISSING:
 
 Read `review-report.md` and check the Verdict:
 - `PASS` → proceed
-- `NEEDS_FIXES` → the skill exhausted its max rounds; log remaining findings and proceed
+- `NEEDS_FIXES` → the skill reached the ten-round safety fuse or left an accepted finding unresolved; log remaining findings and proceed according to the task failure policy
+- `BLOCKED` → log the infrastructure reason and stop so the review can be retried
 
 {{IF_BROWSER_INTERACTION}}
 

package/bundled/dev-pipeline/templates/refactor-bootstrap-prompt.md

@@ -139,7 +139,7 @@ Apply the browser behavior preservation protocol where UI behavior can be affect
 
 ### Phase 4: Review — Code Review & Behavior Verification
 
-Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/` directly from the main orchestrator. The skill loads its skill-owned `references/reviewer-agent-prompt.md` and `references/reviewer-workspace-protocol.md`, chooses a platform-supported independent Reviewer strategy, and verifies a workspace-equivalent snapshot.
+Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/` directly from the main orchestrator. The skill loads its skill-owned `references/reviewer-agent-prompt.md`, chooses a platform-supported fresh read-only Reviewer, prefers direct access to the active checkout, and supplies changed content that a platform-forced worktree cannot see.
 
 Review requirements:
 - verify refactor quality against spec.md and plan.md;
@@ -149,7 +149,12 @@ Review requirements:
 
 If the report is missing after one bounded status check, write `failure-log.md` and stop with a clear recovery failure. Do not replace the independent Reviewer with Main-Agent self-review.
 
-**Checkpoint update**: set step `prizmkit-code-review` to `completed` in `{{CHECKPOINT_PATH}}`.
+Read `review-report.md` and check the Verdict:
+- `PASS` → proceed.
+- `NEEDS_FIXES` → log unresolved accepted findings and proceed only when they do not block behavior preservation.
+- `BLOCKED` → log the infrastructure reason and stop so the review can be retried.
+
+**Checkpoint update**: set step `prizmkit-code-review` to `completed` only after `PASS`, or after an explicitly accepted non-blocking `NEEDS_FIXES` result. Do not complete the checkpoint for `BLOCKED`.
 
 ---
 

package/bundled/dev-pipeline/templates/sections/bugfix-phase-review.md

@@ -12,9 +12,9 @@ If `FAST_PATH=true`, skip this phase intentionally:
 
 Then continue to the next checkpoint step.
 
-Otherwise, run `/prizmkit-code-review` with `artifact_dir=.prizmkit/bugfix/{{BUG_ID}}/`. The skill loads its skill-owned Reviewer prompt and workspace protocol, chooses a platform-supported subagent strategy, and verifies that the Reviewer's snapshot is equivalent to the current workspace before review.
+Otherwise, run `/prizmkit-code-review` with `artifact_dir=.prizmkit/bugfix/{{BUG_ID}}/`. The skill chooses a platform-supported fresh read-only Reviewer, prefers direct access to the active checkout, and supplies changed content that a platform-forced worktree cannot see.
 
-The skill runs its internal Reviewer Agent → filter → orchestrator fix loop and writes `review-report.md`. Do not prescribe Agent launch parameters from this pipeline template; the review skill owns strategy selection and workspace-equivalence verification.
+The skill runs its internal fresh Reviewer → Main-Agent filter → Main-Agent fix loop for up to ten completed rounds and writes `review-report.md`. Do not prescribe Agent launch parameters from this pipeline template.
 
 **Gate Check — Review Report**:
 
@@ -23,7 +23,8 @@ The skill runs its internal Reviewer Agent → filter → orchestrator fix loop
 ```
 
 - `PASS` → proceed.
-- `NEEDS_FIXES` → the skill exhausted its internal rounds; log remaining findings and proceed only when they do not block acceptance criteria.
-- Missing report → one bounded retry, then write `failure-log.md` and stop if the independent review protocol remains blocked; do not replace it with Main-Agent self-review.
+- `NEEDS_FIXES` → log unresolved accepted findings and proceed only when they do not block acceptance criteria.
+- `BLOCKED` → log the infrastructure reason and stop so the review can be retried.
+- Missing report → one bounded retry, then write `failure-log.md` and stop if independent review remains blocked; do not replace it with Main-Agent self-review.
 
 **Checkpoint update**: Set step `prizmkit-code-review` to `completed` when review is complete, or `skipped` for FAST_PATH.

package/bundled/dev-pipeline/templates/sections/phase-review-agent.md

@@ -2,9 +2,9 @@
 
 Review the completed implementation before the scoped feature test gate runs. Use `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` so the code-review skill can read spec, plan, context snapshot, implementation log, and current diff artifacts. Do not require or read a prior `/prizmkit-test` report here; test generation and test-fix looping happen in the next phase.
 
-Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill loads its skill-owned Reviewer prompt and workspace protocol, chooses a platform-supported subagent strategy, and verifies that the Reviewer's snapshot is equivalent to the current workspace before review.
+Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill chooses a platform-supported fresh read-only Reviewer, prefers direct access to the active checkout, and supplies changed content that a platform-forced worktree cannot see. Do not prescribe Agent launch parameters from this pipeline template.
 
-The skill runs an internal review-fix loop (Reviewer Agent → filter → orchestrator fix, max 3 rounds) and writes `review-report.md` to the artifact directory. Do not prescribe Agent launch parameters from this pipeline template; the review skill owns strategy selection and workspace-equivalence verification.
+The skill runs an internal review-fix loop (fresh Reviewer → Main-Agent filter → Main-Agent fix, up to ten completed rounds) and writes `review-report.md` to the artifact directory.
 
 **Gate Check — Review Report**:
 After `/prizmkit-code-review` returns, verify the review report:
@@ -19,8 +19,8 @@ If GATE:MISSING:
 
 Read `review-report.md` and check the Verdict:
 - `PASS` → proceed to next phase
-- `NEEDS_FIXES` → the skill exhausted its max rounds; log the remaining findings and proceed (do not retry externally)
+- `NEEDS_FIXES` → log the unresolved accepted findings and proceed according to the task failure policy (do not retry externally)
+- `BLOCKED` → log the infrastructure reason and stop so the review can be retried
 
 **CP-3**: Review complete, report written.
 
-

package/bundled/dev-pipeline/templates/sections/phase-review-full.md

@@ -2,11 +2,11 @@
 
 Review the completed implementation before the scoped feature test gate runs. Use `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` so the code-review skill can read spec, plan, context snapshot, implementation log, and current diff artifacts. Do not require or read a prior `/prizmkit-test` report here; test generation and test-fix looping happen in the next phase.
 
-Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill loads its skill-owned Reviewer prompt and workspace protocol, chooses a platform-supported subagent strategy, and verifies that the Reviewer's snapshot is equivalent to the current workspace before review.
+Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. The skill chooses a platform-supported fresh read-only Reviewer, prefers direct access to the active checkout, and supplies changed content that a platform-forced worktree cannot see. Do not prescribe Agent launch parameters from this bootstrap prompt.
 
-If the independent Reviewer cannot start or verify the snapshot because of a transient platform error, retry at most once. If the second attempt fails, do not keep spawning variants or enter report-polling loops; write `failure-log.md` with the observable error and let the skill report the unresolved verification blocker. Do not replace the independent Reviewer with Main-Agent self-review.
+If the independent Reviewer cannot start or return usable output because of a transient platform error, retry at most once. If the second attempt fails, do not keep spawning variants or enter report-polling loops; write `failure-log.md` with the observable error and let the skill report `BLOCKED`. Do not replace the independent Reviewer with Main-Agent self-review.
 
-The skill runs an internal review-fix loop (Reviewer Agent → filter → orchestrator fix, max 3 rounds) and writes `review-report.md` to the artifact directory. Do not prescribe Agent launch parameters from this pipeline template; the review skill owns strategy selection and workspace-equivalence verification.
+The skill runs an internal review-fix loop (fresh Reviewer → Main-Agent filter → Main-Agent fix, up to ten completed rounds) and writes `review-report.md` to the artifact directory. The review skill owns strategy selection and forced-worktree content fallback.
 
 **Gate Check — Review Report**:
 After `/prizmkit-code-review` returns, verify the review report:
@@ -21,7 +21,8 @@ If GATE:MISSING:
 
 Read `review-report.md` and check the Verdict:
 - `PASS` → proceed to next phase
-- `NEEDS_FIXES` → the skill exhausted its max rounds; log the remaining findings and proceed (do not retry externally)
+- `NEEDS_FIXES` → log the unresolved accepted findings and proceed according to the task failure policy (do not retry externally)
+- `BLOCKED` → log the infrastructure reason and stop so the review can be retried
 
 **CP-3**: Review complete, report written.
 

package/bundled/dev-pipeline/templates/sections/refactor-phase-review.md

@@ -1,8 +1,8 @@
 ### Phase 3: Review — Code Review & Behavior Verification
 
-Run `/prizmkit-code-review` directly with `artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/`. The skill loads its skill-owned `references/reviewer-agent-prompt.md` and `references/reviewer-workspace-protocol.md`, chooses a platform-supported subagent strategy, and verifies that the Reviewer's snapshot is equivalent to the current workspace before review.
+Run `/prizmkit-code-review` directly with `artifact_dir=.prizmkit/refactor/{{REFACTOR_ID}}/`. The skill loads its skill-owned `references/reviewer-agent-prompt.md`, chooses a platform-supported fresh read-only Reviewer, prefers direct access to the active checkout, and supplies changed content that a platform-forced worktree cannot see.
 
-Do not spawn a top-level Reviewer subagent. The code-review skill owns its internal Reviewer Agent → filter → orchestrator fix loop. Do not prescribe Agent launch parameters from this pipeline template; the review skill owns strategy selection and workspace-equivalence verification.
+Do not spawn a top-level Reviewer subagent. The code-review skill owns its internal fresh Reviewer → Main-Agent filter → Main-Agent fix loop for up to ten completed rounds. Do not prescribe Agent launch parameters from this pipeline template.
 
 **Gate Check — Review Report**:
 
@@ -11,9 +11,10 @@ Do not spawn a top-level Reviewer subagent. The code-review skill owns its inter
 ```
 
 - `PASS` → proceed.
-- `NEEDS_FIXES` → the skill exhausted its internal rounds; log remaining findings and proceed only when they do not block behavior preservation.
-- Missing report → one bounded retry, then write `failure-log.md` and stop if the independent review protocol remains blocked; do not replace it with Main-Agent self-review.
+- `NEEDS_FIXES` → log unresolved accepted findings and proceed only when they do not block behavior preservation.
+- `BLOCKED` → log the infrastructure reason and stop so the review can be retried.
+- Missing report → one bounded retry, then write `failure-log.md` and stop if independent review remains blocked; do not replace it with Main-Agent self-review.
 
 Verify the review explicitly checks behavior preservation, public API compatibility, imports, tests, and rollback assumptions.
 
-**Checkpoint update**: Set step `prizmkit-code-review` to `completed` when review is complete.
+**Checkpoint update**: Set step `prizmkit-code-review` to `completed` only after `PASS`, or after an explicitly accepted non-blocking `NEEDS_FIXES` result. Do not complete the checkpoint for `BLOCKED`.

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

@@ -882,7 +882,8 @@ class TestDirectOrchestratorImplementationPrompts:
             assert FORBIDDEN_TEST_CMD_PLACEHOLDER not in rendered
             assert FORBIDDEN_THREE_STRIKE not in rendered
             assert FORBIDDEN_TWENTY_STEP not in rendered
-            assert "Reviewer Agent → filter → orchestrator fix" in rendered
+            assert "fresh Reviewer → Main-Agent filter → Main-Agent fix" in rendered
+            assert "up to ten completed rounds" in rendered
 
     def test_retained_tier3_fallback_template_uses_direct_orchestrator_implementation(self):
         rendered = Path("dev-pipeline/templates/bootstrap-tier3.md").read_text(encoding="utf-8")