prizmkit 1.1.128 → 1.1.130

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.128",
-  "bundledAt": "2026-07-12T17:44:30.283Z",
-  "bundledFrom": "341ff48"
+  "frameworkVersion": "1.1.130",
+  "bundledAt": "2026-07-15T08:17:59.816Z",
+  "bundledFrom": "81d54a2"
 }

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

@@ -11,7 +11,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 
-PIPELINE_TRANSIENT_EXCLUDES = (
+PIPELINE_METADATA_EXCLUDES = (
     ":(top,exclude).prizmkit-worktree",
     ":(top,exclude,glob).*/worktree",
     ":(top,exclude,glob).*/worktree/**",
@@ -19,10 +19,11 @@ PIPELINE_TRANSIENT_EXCLUDES = (
     ":(top,exclude,glob).*/worktrees/**",
     ":(top,exclude).prizmkit/state",
     ":(top,exclude,glob).prizmkit/state/**",
+    ":(top,exclude).prizmkit/manifest.json",
 )
 
 HIDDEN_TOOL_WORKTREE_EXCLUDES = (
-    *PIPELINE_TRANSIENT_EXCLUDES,
+    *PIPELINE_METADATA_EXCLUDES,
     ":(top,exclude).skills-lock.json",
     ":(top,exclude).AGENTS.md",
     ":(top,exclude).claude",
@@ -399,8 +400,23 @@ def ensure_linked_worktree(runtime: WorktreeRuntimeContext) -> WorktreeOperation
 
 
 def merge_linked_worktree(runtime: WorktreeRuntimeContext, *, auto_push: bool = False) -> WorktreeOperationResult:
-    """Rebase the linked worktree branch and fast-forward merge it into base."""
+    """Rebase a clean linked-worktree branch and fast-forward merge it into base."""
     results: list[GitCommandResult] = []
+    clean = run_git_command(
+        runtime.worktree_path,
+        ("status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES),
+    )
+    if clean.return_code == 0 and clean.stdout.strip():
+        clean = GitCommandResult(
+            args=clean.args,
+            return_code=1,
+            stdout=clean.stdout,
+            stderr="Task worktree is not clean; committed branch state is required",
+        )
+    results.append(clean)
+    if clean.return_code != 0:
+        return WorktreeOperationResult(False, "dirty_task_checkout", runtime, tuple(results))
+
     rebase = run_git_command(runtime.worktree_path, ("rebase", runtime.context.base_branch))
     results.append(rebase)
     if rebase.return_code != 0:
@@ -524,41 +540,33 @@ def branch_return_plan(context: BranchContext) -> GitCommandPlan:
 
 
 def branch_merge_plan(context: BranchContext, *, auto_push: bool = False) -> GitCommandPlan:
-    """Plan shell-equivalent branch_merge safety invariants."""
+    """Plan a merge that consumes only a clean, committed task branch."""
     commands = [
-        _git("diff", "--name-only", allow_failure=True, description="detect tracked dirty files"),
-        _git("diff", "--cached", "--name-only", allow_failure=True, description="detect staged dirty files"),
-        _git("stash", "push", "-m", "pipeline-merge-stash", allow_failure=True, description="stash tracked dirty files only"),
+        _git("status", "--porcelain", "--untracked-files=normal", description="require a clean task checkout"),
         _git("rebase", context.base_branch, context.working_branch, description="rebase dev onto original"),
         _git("checkout", context.base_branch, description="checkout original for fast-forward"),
         _git("merge", "--ff-only", context.working_branch, description="fast-forward original"),
     ]
     if auto_push:
         commands.append(_git("push", allow_failure=True, description="optional auto-push"))
-    commands.extend(
-        [
-            _git("branch", "-d", context.working_branch, allow_failure=True, description="delete merged dev branch"),
-            _git("stash", "pop", allow_failure=True, description="restore stashed tracked files"),
-        ]
-    )
+    commands.append(_git("branch", "-d", context.working_branch, allow_failure=True, description="delete merged dev branch"))
     return GitCommandPlan(
         name="branch_merge",
         commands=tuple(commands),
         notes=(
-            "Tracked-only stash avoids capturing ignored state artifacts.",
-            "Rebase then fast-forward preserves merge invariant.",
+            "The task checkout must be clean because committed branch state is the only merge input.",
+            "Rebase then fast-forward preserves merge history without pipeline-owned stashes.",
         ),
     )
 
 
 def branch_save_wip_plan(context: BranchContext) -> GitCommandPlan:
-    """Plan shell-equivalent never-fail WIP preservation."""
+    """Plan WIP preservation that fails when task state cannot be committed."""
     return GitCommandPlan(
         name="branch_save_wip",
         commands=(
-            _git("rev-parse", "--abbrev-ref", "HEAD", allow_failure=True, description="verify current branch"),
-            _git("status", "--porcelain", allow_failure=True, description="detect uncommitted work"),
-            _git("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES, allow_failure=True, description="stage non-ignored work excluding hidden tool worktrees"),
+            _git("rev-parse", "--abbrev-ref", "HEAD", description="verify current branch"),
+            _git("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES, description="stage non-ignored work excluding hidden tool worktrees"),
             _git(
                 "commit",
                 "--no-verify",
@@ -568,24 +576,26 @@ def branch_save_wip_plan(context: BranchContext) -> GitCommandPlan:
                 "Pipeline was interrupted by signal. This commit preserves work-in-progress.",
                 "-m",
                 f"To resume: git checkout {context.working_branch}",
-                allow_failure=True,
                 description="create WIP commit",
             ),
+            _git(
+                "status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES,
+                description="require clean task checkout after WIP commit",
+            ),
         ),
-        never_fails=True,
-        notes=("Never-fail cleanup helper; errors are diagnostics only.",),
+        notes=("Task state stays on its branch; failed preservation is reported.",),
     )
 
 
 def branch_ensure_return_plan(context: BranchContext) -> GitCommandPlan:
-    """Plan shell-equivalent guaranteed return cleanup."""
+    """Plan a fail-closed WIP commit followed by a clean base return."""
     return GitCommandPlan(
         name="branch_ensure_return",
         commands=(
             _git("rebase", "--abort", allow_failure=True, description="abort in-progress rebase"),
-            _git("rev-parse", "--abbrev-ref", "HEAD", allow_failure=True, description="detect current branch"),
-            _git("status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES, allow_failure=True, description="detect WIP before checkout"),
-            _git("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES, allow_failure=True, description="stage WIP before checkout"),
+            _git("rev-parse", "--abbrev-ref", "HEAD", description="detect current branch"),
+            _git("status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES, description="detect WIP before checkout"),
+            _git("add", "-A", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES, description="stage WIP before checkout"),
             _git(
                 "commit",
                 "--no-verify",
@@ -598,11 +608,13 @@ def branch_ensure_return_plan(context: BranchContext) -> GitCommandPlan:
                 allow_failure=True,
                 description="save WIP before return when on dev branch",
             ),
-            _git("stash", "push", "-m", "pipeline-ensure-return-stash", allow_failure=True, description="stash checkout blockers"),
-            _git("checkout", context.base_branch, allow_failure=True, description="return to original branch"),
+            _git(
+                "status", "--porcelain", "--", ".", *HIDDEN_TOOL_WORKTREE_EXCLUDES,
+                description="require clean task checkout before return",
+            ),
+            _git("checkout", context.base_branch, description="return to original branch"),
         ),
-        never_fails=True,
-        notes=("Always returns success to support trap/finally cleanup paths.",),
+        notes=("Return only after task state is committed and the checkout is clean.",),
     )
 
 
@@ -645,11 +657,24 @@ def worktree_save_wip(runtime: WorktreeRuntimeContext) -> GitPlanResult:
 
 
 def branch_ensure_return(project_root: Path, base_branch: str, working_branch: str = "") -> GitPlanResult:
-    """Best-effort shell-compatible ensure-return helper that never reports failure."""
+    """Commit task WIP and return to base only from a clean checkout."""
     active = current_branch(project_root)
-    if working_branch and active == working_branch:
-        branch_save_wip(project_root, working_branch)
     context = BranchContext(base_branch=base_branch, working_branch=working_branch or active, project_root=project_root)
+    if not active or active == base_branch:
+        return GitPlanResult(plan=branch_ensure_return_plan(context), results=())
+    if working_branch and active != working_branch:
+        mismatch_plan = GitCommandPlan(
+            name="branch_ensure_return",
+            commands=(_git("checkout", base_branch, description="refuse return from an unrelated branch"),),
+            notes=("The active checkout must match the recorded task branch.",),
+        )
+        failure = GitCommandResult(
+            args=mismatch_plan.commands[0].args,
+            return_code=1,
+            stdout="",
+            stderr=f"Active branch {active} does not match task branch {working_branch}",
+        )
+        return GitPlanResult(plan=mismatch_plan, results=(failure,))
     return run_git_plan(project_root, branch_ensure_return_plan(context))
 
 
@@ -713,10 +738,22 @@ def run_git_command(project_root: Path, args: Sequence[str]) -> GitCommandResult
 
 
 def run_git_plan(project_root: Path, plan: GitCommandPlan) -> GitPlanResult:
-    """Run a plan sequentially, stopping on non-allowed failures."""
+    """Run a plan sequentially, stopping on failures or dirty-state guards."""
     results: list[GitCommandResult] = []
     for command in plan.commands:
         result = run_git_command(project_root, command.args)
+        if (
+            command.args[:2] == ("status", "--porcelain")
+            and command.description.startswith("require clean")
+            and result.return_code == 0
+            and result.stdout.strip()
+        ):
+            result = GitCommandResult(
+                args=result.args,
+                return_code=1,
+                stdout=result.stdout,
+                stderr="Task checkout is not clean; committed branch state is required",
+            )
         results.append(result)
         if result.return_code != 0 and not (command.allow_failure or plan.never_fails):
             break
@@ -731,6 +768,8 @@ class ResetBranchCleanupResult:
     cleaned: bool
     deleted: bool
     returned_to: str
+    checkout_discarded: bool = False
+    branch_preserved: bool = False
     warnings: tuple[str, ...] = ()
 
 
@@ -765,16 +804,11 @@ def list_reset_branches(project_root: Path, prefix: str, item_id: str) -> tuple[
 
 
 def reset_cleanup_branch(project_root: Path, branch: str, *, return_branch: str, delete: bool) -> ResetBranchCleanupResult:
-    """Discard uncommitted branch changes and optionally delete the branch.
-
-    This is intentionally reset-specific: unlike interrupted runner cleanup, manual
-    reset abandons uncommitted work on matching dev branches to recreate the
-    shell helper contract.
-    """
+    """Reset the current task checkout or operate directly on a non-current branch ref."""
     warnings: list[str] = []
     active = current_branch(project_root)
     restored = active
-    stashed = False
+    cleaned = False
 
     if active == branch:
         run_git_command(project_root, ("reset", "HEAD"))
@@ -786,26 +820,22 @@ def reset_cleanup_branch(project_root: Path, branch: str, *, return_branch: str,
             restored = branch
         else:
             restored = return_branch
-    else:
-        dirty = run_git_command(project_root, ("status", "--porcelain"))
-        if dirty.stdout.strip():
-            stash = run_git_command(project_root, ("stash", "push", "--include-untracked", "-m", "reset-pipeline-temp"))
-            stashed = stash.return_code == 0
-        checkout = run_git_command(project_root, ("checkout", branch))
-        if checkout.return_code == 0:
-            run_git_command(project_root, ("reset", "HEAD"))
-            run_git_command(project_root, ("checkout", "--", "."))
-            run_git_command(project_root, ("clean", "-fd"))
-            run_git_command(project_root, ("checkout", active or return_branch))
-            restored = active or return_branch
-        else:
-            warnings.append(f"could not checkout {branch} to discard changes")
-        if stashed:
-            run_git_command(project_root, ("stash", "pop"))
+            cleaned = True
 
     deleted = False
     if delete:
         deleted = run_git_command(project_root, ("branch", "-D", branch)).return_code == 0
         if not deleted:
             warnings.append(f"failed to delete branch {branch}")
-    return ResetBranchCleanupResult(branch=branch, cleaned=True, deleted=deleted, returned_to=restored, warnings=tuple(warnings))
+    elif active != branch:
+        cleaned = True
+
+    return ResetBranchCleanupResult(
+        branch=branch,
+        cleaned=cleaned or deleted,
+        deleted=deleted,
+        returned_to=restored,
+        checkout_discarded=cleaned and active == branch,
+        branch_preserved=active != branch and not delete,
+        warnings=tuple(warnings),
+    )

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

@@ -294,11 +294,12 @@ def _reset_one(family: RunnerFamily, item: ResetItem, options: ResetOptions, pro
 
     for branch in branches:
         cleanup = reset_cleanup_branch(project_root, branch, return_branch=return_branch, delete=options.clean)
-        lines.append(f"Discarded uncommitted changes on dev branch: {cleanup.branch}")
+        if getattr(cleanup, "checkout_discarded", False):
+            lines.append(f"Discarded uncommitted changes on current dev branch: {cleanup.branch}")
+        elif getattr(cleanup, "branch_preserved", False):
+            lines.append(f"Preserved non-current dev branch without checkout: {cleanup.branch}")
         if cleanup.deleted:
             lines.append(f"Deleted dev branch: {cleanup.branch}")
-        elif not options.clean:
-            lines.append(f"Dev branch preserved for debugging: {cleanup.branch}")
         lines.extend(f"WARN: {warning}" for warning in cleanup.warnings)
         if cleanup.warnings:
             lines.append(f"ERROR: Reset {item.item_id} branch cleanup failed")

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

@@ -7,6 +7,7 @@ legacy ordering around branch creation and final status updates.
 
 from __future__ import annotations
 
+import json
 from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
@@ -27,6 +28,8 @@ LOCAL_ONLY_PLATFORM_PATHS = (
     ".codex/settings.local.json",
     ".agents/settings.local.json",
 )
+PIPELINE_MANIFEST_PATH = ".prizmkit/manifest.json"
+CONFLICT_MARKERS = (b"<<<<<<< ", b"=======", b">>>>>>> ")
 
 
 @dataclass(frozen=True)
@@ -39,7 +42,10 @@ class PreflightWorkspace:
 
     @property
     def preservable(self) -> tuple[str, ...]:
-        return _unique_paths((*self.tracked, *self.visible_untracked))
+        return _unique_paths(
+            path for path in (*self.tracked, *self.visible_untracked)
+            if path != PIPELINE_MANIFEST_PATH
+        )
 
 
 @dataclass(frozen=True)
@@ -127,6 +133,49 @@ def _preflight_failure(message: str) -> GitCommandResult:
     return GitCommandResult(args=("status", "preflight"), return_code=1, stdout="", stderr=message)
 
 
+def _preflight_integrity_failure(project_root: Path, workspace: PreflightWorkspace) -> GitCommandResult | None:
+    unmerged = run_git_command(project_root, ("ls-files", "-u"))
+    if unmerged.return_code != 0:
+        return unmerged
+    if unmerged.stdout.strip():
+        return _preflight_failure("Refusing to auto-commit unmerged Git paths")
+
+    manifest_path = project_root / PIPELINE_MANIFEST_PATH
+    if manifest_path.is_file():
+        try:
+            data = json.loads(manifest_path.read_text(encoding="utf-8"))
+        except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+            return _preflight_failure(
+                f"Refusing to continue because {PIPELINE_MANIFEST_PATH} is not valid JSON: {exc}"
+            )
+        if not isinstance(data, dict):
+            return _preflight_failure(
+                f"Refusing to continue because {PIPELINE_MANIFEST_PATH} is not a JSON object"
+            )
+    if PIPELINE_MANIFEST_PATH in workspace.tracked:
+        return _preflight_failure(
+            "Refusing to auto-commit installer-owned .prizmkit/manifest.json; "
+            "finish or revert the framework install/upgrade before starting a task"
+        )
+
+    marker_paths = []
+    for relative in workspace.preservable:
+        path = project_root / relative
+        if not path.is_file():
+            continue
+        try:
+            content = path.read_bytes()
+        except OSError as exc:
+            return _preflight_failure(f"Cannot inspect {relative} before auto-commit: {exc}")
+        if all(marker in content for marker in CONFLICT_MARKERS):
+            marker_paths.append(relative)
+    if marker_paths:
+        return _preflight_failure(
+            "Refusing to auto-commit unresolved conflict markers: " + ", ".join(marker_paths)
+        )
+    return None
+
+
 def _remaining_preflight_changes(project_root: Path) -> GitCommandResult:
     workspace, failure = _preflight_workspace(project_root)
     if failure is not None:
@@ -200,6 +249,9 @@ def commit_preflight_ready_changes(project_root: Path, item_id: str) -> Bookkeep
                 "Refusing to auto-commit local-only platform settings: " + ", ".join(workspace.unsafe_local)
             ),
         )
+    integrity_failure = _preflight_integrity_failure(project_root, workspace)
+    if integrity_failure is not None:
+        return BookkeepingResult(attempted=True, committed=False, result=integrity_failure)
     paths = workspace.preservable
     if not paths:
         return BookkeepingResult(attempted=False, committed=False)

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

@@ -405,8 +405,8 @@ def _emit_prompt_summary(prompt: PromptGenerationResult, session_id: str) -> Non
 def _pipeline_mode_label(mode: str) -> str:
     labels = {
         "lite": "lite (Tier 1 — Single Agent)",
-        "standard": "standard (Tier 2 — Orchestrator + Reviewer)",
-        "full": "full (Tier 3 — Orchestrator + Reviewer)",
+        "standard": "standard (Tier 2 — Main-Agent Review Gates)",
+        "full": "full (Tier 3 — Main-Agent Full Guardrails)",
     }
     return labels.get(mode, mode)
 
@@ -729,9 +729,14 @@ def _process_item_locked(
 
             if final_session_status != "success":
                 commit_final_bookkeeping(status_root, status_family, item_id, new_status)
-                _save_failure_wip(execution_root, family, item_id, new_status, worktree_runtime)
+                wip = _save_failure_wip(execution_root, family, item_id, new_status, worktree_runtime)
+                if not getattr(wip, "ok", True):
+                    _emit_warning(f"WIP preservation failed for {item_id}; leaving the task checkout active")
+                    return new_status
                 if not use_worktree:
-                    branch_ensure_return(paths.project_root, base_branch, branch_name)
+                    returned = branch_ensure_return(paths.project_root, base_branch, branch_name)
+                    if not getattr(returned, "ok", True):
+                        _emit_warning(f"Could not safely return to {base_branch}; leaving {branch_name} active")
                 return new_status
 
             return _complete_success_merge(
@@ -839,9 +844,12 @@ def _complete_success_merge(
     classification_fatal_error_code: str = "",
 ) -> str:
     env = RunnerEnvironment.from_env()
-    commit_final_bookkeeping(status_root, status_family, item_id, new_status)
-    commit_task_branch_changes(execution_root, family, item_id, new_status)
-    if worktree_runtime is not None:
+    final_bookkeeping = commit_final_bookkeeping(status_root, status_family, item_id, new_status)
+    task_commit = commit_task_branch_changes(execution_root, family, item_id, new_status)
+    finalization_committed = getattr(final_bookkeeping, "ok", True) and getattr(task_commit, "ok", True)
+    if not finalization_committed:
+        _emit_warning(f"Task finalization commit failed for {item_id}; preserving task checkout without merge")
+    if finalization_committed and worktree_runtime is not None:
         _emit_info(f"Merging {branch_name} into {base_branch}...")
         merge = merge_linked_worktree(worktree_runtime, auto_push=env.auto_push)
         _emit_git_plan_output(merge)
@@ -853,7 +861,7 @@ def _complete_success_merge(
             guarded_worktree_remove(worktree_runtime, delete_branch=True)
             _emit_success(f"Merged {branch_name} into {base_branch}")
             return new_status
-    else:
+    elif finalization_committed:
         _emit_info(f"Merging {branch_name} into {base_branch}...")
         merge = run_git_plan(paths.project_root, branch_merge_plan(branch_context, auto_push=env.auto_push))
         _emit_git_plan_output(merge)
@@ -893,17 +901,19 @@ def _complete_success_merge(
     _emit_update_summary(family, item_id, update)
     merged_status = _status_from_update(update)
     commit_final_bookkeeping(status_root, status_family, item_id, merged_status)
-    _save_failure_wip(execution_root, family, item_id, merged_status, worktree_runtime)
-    if worktree_runtime is None:
-        branch_ensure_return(paths.project_root, base_branch, branch_name)
+    wip = _save_failure_wip(execution_root, family, item_id, merged_status, worktree_runtime)
+    if worktree_runtime is None and getattr(wip, "ok", True):
+        returned = branch_ensure_return(paths.project_root, base_branch, branch_name)
+        if not returned.ok:
+            _emit_warning(f"Could not safely return to {base_branch}; leaving {branch_name} active")
     return merged_status
 
 
-def _save_failure_wip(execution_root: Path, family: RunnerFamily, item_id: str, status: str, worktree_runtime) -> None:
+def _save_failure_wip(execution_root: Path, family: RunnerFamily, item_id: str, status: str, worktree_runtime):
+    """Preserve failure work and return an observable bookkeeping result."""
     if worktree_runtime is not None:
-        worktree_save_wip(worktree_runtime)
-    else:
-        commit_wip_changes(execution_root, family, item_id, status)
+        return worktree_save_wip(worktree_runtime)
+    return commit_wip_changes(execution_root, family, item_id, status)
 
 
 def _record_setup_failure(
@@ -938,8 +948,14 @@ def _record_setup_failure(
     new_status = _status_from_update(update) if update.ok else "infra_error"
     if update.ok:
         commit_final_bookkeeping(status_root, status_family, item_id, new_status)
-        _save_failure_wip(status_root, family, item_id, new_status, worktree_runtime)
-    if worktree_runtime is None and current_branch(project_root) == branch_name:
+        wip = _save_failure_wip(status_root, family, item_id, new_status, worktree_runtime)
+    else:
+        wip = None
+    if (
+        worktree_runtime is None
+        and current_branch(project_root) == branch_name
+        and getattr(wip, "ok", True)
+    ):
         branch_ensure_return(project_root, base_branch, branch_name)
     return new_status
 

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

@@ -1192,8 +1192,8 @@ def load_active_agent_prompts(templates_dir):
     """Load explicit active agent prompt templates.
 
     Retired Dev implementation, review-fix, and plan-challenge prompts are
-    intentionally not loaded; feature implementation and accepted review fixes
-    are performed by the main orchestrator and reviewer gate.
+    intentionally not loaded; feature implementation, Code Review, and accepted
+    review fixes are performed directly by the current Main Agent.
     """
     agent_prompts_dir = os.path.join(templates_dir, "agent-prompts")
     if not os.path.isdir(agent_prompts_dir):
@@ -1235,11 +1235,12 @@ def _tier_header(pipeline_mode):
         ),
         "full": (
             "# Dev-Pipeline Session Bootstrap — Tier 3 "
-            "(Orchestrator + Reviewer)\n",
-            "**Tier 3 — Orchestrator + Reviewer**: For complex "
+            "(Main-Agent Full Guardrails)\n",
+            "**Tier 3 — Main-Agent Full Guardrails**: For complex "
             "features, the main orchestrator handles context, planning, "
-            "and implementation directly. Reviewer reviews, and no top-level "
-            "Dev implementation subagent is spawned.\n",
+            "implementation, and Code Review directly. No top-level Dev "
+            "implementation subagent is spawned, and Code Review never uses "
+            "direct or indirect delegation.\n",
         ),
     }
     return headers.get(pipeline_mode, headers["lite"])
@@ -1271,28 +1272,30 @@ def _tier_reminders(pipeline_mode):
         specific = [
             "- Tier 2: compatibility label only; feature prompts now render "
             "the unified full/tier3-equivalent guidance by default",
-            "- context-snapshot.md is append-only: orchestrator writes "
-            "Sections 1-4 + Implementation Log, Reviewer appends Review Notes",
-            "- Gate checks enforce Implementation Log (with Gate Evidence) "
-            "and Review Notes are written before proceeding",
-            "- Do NOT use `run_in_background=true` when spawning Reviewer",
-            "- On timeout: check snapshot + git diff HEAD → model:lite → "
-            "remaining steps only → max 2 retries per phase → "
-            "orchestrator fallback",
+            "- context-snapshot.md is the implementation knowledge base; "
+            "Code Review writes only review-report.md",
+            "- Gate checks require the Implementation Log (with Gate Evidence) "
+            "and a valid review-report.md Final Result before proceeding",
+            "- Code Review runs only in the current Main Agent and never uses "
+            "direct or indirect delegation",
+            "- On timeout outside Code Review: check snapshot + git diff HEAD "
+            "→ model:lite → remaining steps only → max 2 retries per phase → "
+            "Main Agent fallback",
         ]
     else:  # full
         specific = [
-            "- Tier 3: full orchestration — orchestrator implements "
-            "directly (no top-level Dev subagent), and Reviewer reviews",
-            "- context-snapshot.md is append-only: orchestrator writes "
-            "Sections 1-4 + Implementation Log, Reviewer appends "
-            "Review Notes",
-            "- Gate checks enforce Implementation Log and Review Notes are "
-            "written before proceeding",
+            "- Tier 3: full orchestration — the Main Agent implements directly "
+            "and owns the complete Code Review loop",
+            "- context-snapshot.md is the implementation knowledge base; "
+            "Code Review writes only review-report.md",
+            "- Gate checks require the Implementation Log and a valid "
+            "review-report.md Final Result before proceeding",
+            "- Code Review is excluded from normal work delegation and never "
+            "uses direct or indirect delegation or another review entry point",
             "- Do NOT use `run_in_background=true` when spawning normal work "
-            "agents",
-            "- If an Agent tool call fails with team/config/lock errors, retry "
-            "at most once; after a second failure, use the documented "
+            "agents outside Code Review",
+            "- If a normal work Agent call fails with team/config/lock errors, "
+            "retry at most once; after a second failure, use the documented "
             "inline/recovery fallback or write `failure-log.md` rather than "
             "spawning variants or polling indefinitely",
             "- NEVER delete, modify, or touch any file under `.prizmkit/state/` "
@@ -1550,9 +1553,8 @@ def validate_rendered(content):
     # contain literal double braces like Jinja or Go templates)
     unreplaced = re.findall(r"\{\{[A-Z][A-Z_0-9]+\}\}", content)
     if unreplaced:
-        # Deduplicate
         unique = sorted(set(unreplaced))
-        warnings.append(
+        errors.append(
             "Unreplaced placeholders: {}".format(", ".join(unique))
         )
 
@@ -1635,8 +1637,8 @@ def build_replacements(args, feature, features, global_context, script_dir):
         effective_resume = "6"
 
 
-    # Browser verification defaults to a mandatory attempt. It is disabled only
-    # by BROWSER_VERIFY=false or browser_interaction.enabled=false.
+    # Browser verification is opt-in through a browser_interaction object and
+    # can always be disabled globally with BROWSER_VERIFY=false.
     browser_enabled, browser_tool, browser_verify_steps, browser_blocking = browser_enabled_from_item(feature)
 
     if browser_tool not in ("playwright-cli", "opencli", "auto"):

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

@@ -356,13 +356,13 @@ def _bugfix_header(pipeline_mode):
     title = "# Dev-Pipeline Bug Fix Session Bootstrap — {}\n".format(pipeline_mode.title())
     desc = {
         "lite": "**Tier 1 — Single Agent**: direct root-cause fix by the main orchestrator.",
-        "standard": "**Tier 2 — Orchestrator + Reviewer**: direct implementation with review gates.",
+        "standard": "**Tier 2 — Main-Agent Review Gates**: direct implementation with Main-Agent-only review gates.",
         "full": "**Tier 3 — Full Bugfix Guardrails**: direct implementation with stronger diagnosis and review gates.",
     }.get(pipeline_mode, "**Bugfix pipeline**")
     return title + "\n" + desc + "\n"
 
 
-def assemble_bugfix_sections(pipeline_mode, sections_dir, browser_enabled, manual_gate):
+def assemble_bugfix_sections(pipeline_mode, sections_dir, browser_enabled, manual_gate, browser_tool="auto"):
     sections = [
         ("header", _bugfix_header(pipeline_mode)),
         ("bugfix-session-context", load_section(sections_dir, "bugfix-session-context.md")),
@@ -380,7 +380,11 @@ def assemble_bugfix_sections(pipeline_mode, sections_dir, browser_enabled, manua
         ("bugfix-phase-review", load_section(sections_dir, "bugfix-phase-review.md")),
     ])
     if browser_enabled:
-        sections.append(("phase-browser", load_section(sections_dir, "phase-browser-verification-auto.md")))
+        browser_section_file = {
+            "playwright-cli": "phase-browser-verification.md",
+            "opencli": "phase-browser-verification-opencli.md",
+        }.get(browser_tool, "phase-browser-verification-auto.md")
+        sections.append(("phase-browser", load_section(sections_dir, browser_section_file)))
     if manual_gate:
         sections.append(("bugfix-manual-gate", load_section(sections_dir, "bugfix-phase-manual-verification.md")))
         sections.extend([
@@ -463,6 +467,7 @@ def main():
         try:
             sections = assemble_bugfix_sections(
                 pipeline_mode, sections_dir, browser_enabled, manual_gate,
+                browser_tool=replacements["{{BROWSER_TOOL}}"],
             )
             rendered = render_from_sections(sections, replacements)
         except FileNotFoundError as exc:

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

@@ -97,9 +97,10 @@ Implement the minimal fix (red → green):
         """\
 Verify fix quality:
 1. Run `/prizmkit-code-review` with the current bugfix artifact directory.
-2. The Main Agent reviews the complete current change for up to ten rounds, directly repairs accepted findings, and verifies repairs.
+2. The current Main Agent is the only Code Review executor. It reviews the complete current change for up to ten rounds, directly repairs accepted findings, and verifies repairs.
 3. Converge only when accepted and unresolved findings are both zero; missing required evidence or round-ten non-convergence produces NEEDS_FIXES.
-4. Do not spawn a code-review-specific subagent. Continue only after the report's last Final Result is valid; preserve append-only progress for recovery.""",
+4. Do not delegate review directly or indirectly. Do not invoke another review skill or review workflow. Do not relabel delegated work as a finder, verifier, audit, compatibility review, verification, or gap sweep.
+5. `review-report.md` is the only persisted review artifact. Continue only after its last Final Result is valid; preserve append-only progress for recovery.""",
     ),
     6: (
         "User Verification",