prizmkit 1.1.127 → 1.1.129

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.127",
-  "bundledAt": "2026-07-12T15:13:24.439Z",
-  "bundledFrom": "d634625"
+  "frameworkVersion": "1.1.129",
+  "bundledAt": "2026-07-14T06:20:56.368Z",
+  "bundledFrom": "60410c0"
 }

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

@@ -7,6 +7,8 @@
  *   - Only `description` in frontmatter
  *   - `${SKILL_DIR}` references rewritten to relative paths
  *   - Skills with assets/scripts use directory structure
+ *
+ * Code-review-specific named agents are retired; review runs in the Main Agent.
  */
 
 import { parseFrontmatter, buildMarkdown } from '../shared/frontmatter.js';
@@ -20,67 +22,6 @@ 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
@@ -158,20 +99,6 @@ 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/assets/skill-subagent-integration.md

@@ -2,18 +2,19 @@
 
 ## Overview
 
-`dev-pipeline` drives feature, bugfix, and refactor sessions through the unified Python outer loop. Each iteration spawns a new AI CLI session with a bootstrap prompt that makes the main session orchestrator responsible for planning, implementation, review coordination, testing, retrospective, and commit.
+`dev-pipeline` drives feature, bugfix, and refactor sessions through the unified Python outer loop. Each iteration starts an AI CLI session with a bootstrap prompt that makes the main session orchestrator responsible for planning, implementation, review, testing, retrospective, and commit.
+
+Skill behavior is owned by canonical skills:
 
-Implementation and review behavior is owned by skills:
 - `/prizmkit-implement` executes plan tasks directly and may use its local implementation-subagent reference for narrow active-checkout delegation.
-- `/prizmkit-code-review` owns its internal inline reviewer subagent review loop through its local reviewer prompt reference.
+- `/prizmkit-code-review` runs its complete bounded review and repair loop directly in the Main Agent.
 
 ## Architecture
 
 ```text
 dev-pipeline (outer loop)
     |
-    +-- cli.py feature/bugfix/refactor       Python runtime CLI — picks next item, spawns CLI
+    +-- cli.py feature/bugfix/refactor       Python runtime CLI — picks next item, starts CLI
     +-- scripts/                             Python state and prompt management scripts
     +-- templates/                           Session prompt templates and sections
     |
@@ -22,7 +23,7 @@ dev-pipeline (outer loop)
             +-- Context snapshot + specify + plan (orchestrator)
             +-- Local plan/spec review loop inside prizmkit-plan
             +-- Implement through /prizmkit-implement
-            +-- Code review through /prizmkit-code-review inline reviewer loop
+            +-- Main-Agent code review through /prizmkit-code-review
             +-- Scoped test gate and browser attempt
             +-- Retrospective & commit (orchestrator)
 ```
@@ -30,24 +31,26 @@ dev-pipeline (outer loop)
 ## Skill-Owned References
 
 | Skill | Reference | Purpose |
-|-------|-----------|---------|
+|---|---|---|
 | `/prizmkit-implement` | skill-local `references/implementation-subagent-procedure.md` | Optional narrow implementation delegation contract |
-| `/prizmkit-code-review` | skill-local `references/reviewer-agent-prompt.md` | Required independent reviewer-loop prompt |
+| `/prizmkit-code-review` | skill-local `references/review-report-template.md` | Main-Agent review progress and terminal-result contract |
 
-The orchestrator role is handled by the main agent directly — no separate platform agent definition or team topology is installed.
+The orchestrator role is handled by the Main Agent directly. Code review does not install or invoke a separate platform agent definition.
 
 ## Active Checkout Contract
 
-Any skill-level implementation or review subagent must run in the expected active git top-level. The prompt contract forbids git worktrees, tool-created worktree isolation, copied repository checkouts, remote isolated checkouts, branch switching, and operating outside the expected active checkout.
+Any optional implementation subagent must run in the expected active git top-level. Its prompt contract forbids git worktrees, tool-created worktree isolation, copied repository checkouts, remote isolated checkouts, branch switching, and operating outside the expected active checkout.
+
+Code review always runs in the Main Agent's current workspace so staged, unstaged, and untracked content remains authoritative.
 
-Pipeline runner-owned linked worktrees are an outer runtime option. They do not authorize skill-level subagents to create or enter their own worktrees.
+Pipeline runner-owned linked worktrees are an outer runtime option. They do not authorize a skill-level execution unit to create or enter another worktree.
 
 ## Pipeline Scripts
 
 Located at `.prizmkit/dev-pipeline/scripts/`:
 
 | Script | Purpose |
-|--------|---------|
+|---|---|
 | `init-pipeline.py` | Initialize feature pipeline state |
 | `init-bugfix-pipeline.py` | Initialize bugfix pipeline state |
 | `init-refactor-pipeline.py` | Initialize refactor pipeline state |

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/prizmkit_runtime/runtime_helper.py

@@ -258,7 +258,6 @@ def _text_final_verdict(args: argparse.Namespace) -> HelperResult:
     markers = {
         "PASS": "REVIEW_PASS",
         "NEEDS_FIXES": "REVIEW_NEEDS_FIXES",
-        "BLOCKED": "REVIEW_BLOCKED",
     }
     marker = markers.get(verdict)
     if not marker: