prizmkit 1.1.111 → 1.1.112

package/bundled/dev-pipeline/scripts/update-feature-status.py

@@ -35,6 +35,8 @@ from utils import (
     error_out,
     pad_right,
     _build_progress_bar,
+    read_checkpoint_cursor,
+    dependency_rank_map,
 )
 
 
@@ -320,6 +322,36 @@ def reset_continuation_metadata(status_data):
 STALL_REASON = "context_overflow_without_git_checkpoint_or_artifact_progress"
 
 
+def _read_feature_checkpoint_phase(project_root, feature_slug):
+    """Read the phase index from the feature checkpoint file.
+
+    Returns an integer step index (e.g., 3 for S03) or None if the checkpoint
+    is not available. The value is consumed by the terminal status display as
+    ``CP-F-<n>``.
+    """
+    checkpoint_path = os.path.join(
+        os.path.abspath(project_root) if project_root else _default_project_root(),
+        ".prizmkit", "specs", feature_slug, "workflow-checkpoint.json",
+    )
+    return read_checkpoint_cursor(checkpoint_path)
+
+
+def _checkpoint_phase_or_cached(project_root, feature_slug, status_data):
+    """Return live checkpoint phase, falling back to cached status data."""
+    checkpoint_phase = _read_feature_checkpoint_phase(project_root, feature_slug)
+    if checkpoint_phase is not None:
+        return checkpoint_phase
+    return status_data.get("resume_from_phase")
+
+
+def _sync_checkpoint_phase(project_root, feature_slug, status_data):
+    """Cache live checkpoint phase in status.json runtime data."""
+    status_data["resume_from_phase"] = _read_feature_checkpoint_phase(
+        project_root, feature_slug,
+    )
+    return status_data.get("resume_from_phase")
+
+
 def _load_progress_fingerprint(raw):
     if not raw:
         return None
@@ -656,7 +688,7 @@ def auto_skip_blocked_features(feature_list_path, state_dir, failed_feature_id):
 # Action: get_next
 # ---------------------------------------------------------------------------
 
-def action_get_next(feature_list_data, state_dir, feature_filter=None):
+def action_get_next(feature_list_data, state_dir, feature_filter=None, project_root=None):
     """Find the next feature to process.
 
     Priority logic:
@@ -687,6 +719,16 @@ def action_get_next(feature_list_data, state_dir, feature_filter=None):
         fs = load_feature_status(state_dir, fid)
         status_data_map[fid] = fs
 
+    topo_rank, topo_errors = dependency_rank_map(
+        features,
+        id_key="id",
+        dependencies_key="dependencies",
+        item_label="Feature",
+    )
+    if topo_errors:
+        print("PIPELINE_BLOCKED")
+        return
+
     # Apply feature filter: only consider these features as candidates
     # for execution, but dependency checking still uses the full status_map
     if feature_filter is not None:
@@ -740,34 +782,41 @@ def action_get_next(feature_list_data, state_dir, feature_filter=None):
         fstatus = status_map.get(fid, "pending")
         if fstatus == "in_progress":
             in_progress_features.append(feature)
-        else:
+        elif fstatus == "pending":
             pending_features.append(feature)
 
-    # Priority mapping: string enum → sort order (critical first)
-    _PRIORITY_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3}
-
-    # Prefer in_progress features, then pending; sort by priority (high > medium > low)
+    # Prefer in_progress features, then pending. Within each class use stable
+    # topological order so dependencies precede dependents and unrelated items
+    # keep list order.
     if in_progress_features:
         candidates = sorted(
             in_progress_features,
-            key=lambda f: _PRIORITY_ORDER.get(f.get("priority", "low"), 3)
+            key=lambda f: topo_rank.get(f.get("id"), len(features))
         )
-    else:
+    elif pending_features:
         candidates = sorted(
             pending_features,
-            key=lambda f: _PRIORITY_ORDER.get(f.get("priority", "low"), 3)
+            key=lambda f: topo_rank.get(f.get("id"), len(features))
         )
+    else:
+        print("PIPELINE_BLOCKED")
+        return
 
     chosen = candidates[0]
     chosen_id = chosen["id"]
     chosen_status_data = status_data_map.get(chosen_id, {})
+    project_root = os.path.abspath(project_root) if project_root else _default_project_root()
+    feature_slug = _build_feature_slug(chosen_id, chosen.get("title", ""))
+    resume_phase = _checkpoint_phase_or_cached(
+        project_root, feature_slug, chosen_status_data,
+    )
 
     result = {
         "feature_id": chosen_id,
         "title": chosen.get("title", ""),
         "retry_count": chosen_status_data.get("retry_count", 0),
         "infra_error_count": chosen_status_data.get("infra_error_count", 0),
-        "resume_from_phase": chosen_status_data.get("resume_from_phase", None),
+        "resume_from_phase": resume_phase,
     }
     result.update(continuation_metadata_summary(chosen_status_data))
     print(json.dumps(result, indent=2, ensure_ascii=False))
@@ -931,6 +980,12 @@ def action_update(args, feature_list_path, state_dir):
         fs["last_session_id"] = session_id
 
     fs["updated_at"] = now_iso()
+    # Sync resume_from_phase from checkpoint (single source of truth)
+    _sync_checkpoint_phase(
+        args.project_root or _default_project_root(),
+        _get_feature_slug(feature_list_path, feature_id) or feature_id,
+        fs,
+    )
 
     err = save_feature_status(state_dir, feature_id, fs)
     if err:
@@ -1145,15 +1200,16 @@ def _estimate_remaining_time(features, state_dir, counts, feature_list_data=None
     return remaining_seconds, confidence
 
 
-def action_status(feature_list_data, state_dir, feature_filter=None):
+def action_status(feature_list_data, state_dir, feature_filter=None, project_root=None):
     """Print a formatted overview of all features and their status.
 
-    Status is read exclusively from .prizmkit/plans/feature-list.json (the single source of
-    truth).  state_dir is only used for ETA estimation when session history
-    is available.
+    Status is read from .prizmkit/plans/feature-list.json. Runtime metadata such
+    as ETA, degraded reasons, and live checkpoint phase is read from status.json
+    and workflow-checkpoint.json.
     """
     features = feature_list_data.get("features", [])
     app_name = feature_list_data.get("project_name", feature_list_data.get("app_name", "Unknown"))
+    project_root = os.path.abspath(project_root) if project_root else _default_project_root()
 
     # Apply feature filter
     if feature_filter is not None:
@@ -1205,6 +1261,14 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
             continue
 
         fstatus = feature.get("status", "pending")
+        fs = load_feature_status(state_dir, fid)
+        feature_slug = _build_feature_slug(fid, title)
+        # Read phase cursor from checkpoint (single source of truth). The
+        # status.json field is only a cache/fallback for missing checkpoints.
+        resume_phase = _checkpoint_phase_or_cached(project_root, feature_slug, fs)
+        if resume_phase != fs.get("resume_from_phase"):
+            fs["resume_from_phase"] = resume_phase
+            save_feature_status(state_dir, fid, fs)
         degraded_reason = degraded_reason_map.get(fid)
 
         # Count statuses
@@ -1255,6 +1319,8 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
             ]
             if blocking:
                 detail = " (blocked by {})".format(", ".join(blocking))
+        elif fstatus == "in_progress" and resume_phase is not None:
+            detail = " (CP-F-{})".format(resume_phase)
         elif fstatus == "auto_skipped":
             deps = feature.get("dependencies", [])
             blockers = [
@@ -1764,13 +1830,13 @@ def main():
 
     # Dispatch action
     if args.action == "get_next":
-        action_get_next(feature_list_data, args.state_dir, feature_filter)
+        action_get_next(feature_list_data, args.state_dir, feature_filter, args.project_root)
     elif args.action == "start":
         action_start(args, args.feature_list, args.state_dir)
     elif args.action == "update":
         action_update(args, args.feature_list, args.state_dir)
     elif args.action == "status":
-        action_status(feature_list_data, args.state_dir, feature_filter)
+        action_status(feature_list_data, args.state_dir, feature_filter, args.project_root)
     elif args.action == "reset":
         action_reset(args, args.feature_list, args.state_dir)
     elif args.action == "clean":

package/bundled/dev-pipeline/scripts/update-refactor-status.py

@@ -32,6 +32,8 @@ from utils import (
     error_out,
     pad_right,
     _build_progress_bar,
+    read_checkpoint_cursor,
+    dependency_rank_map,
 )
 
 
@@ -219,6 +221,31 @@ def reset_continuation_metadata(status_data):
 STALL_REASON = "context_overflow_without_git_checkpoint_or_artifact_progress"
 
 
+def _read_refactor_checkpoint_phase(project_root, refactor_id):
+    """Read the phase index from the refactor checkpoint file."""
+    checkpoint_path = os.path.join(
+        os.path.abspath(project_root) if project_root else _default_project_root(),
+        ".prizmkit", "refactor", refactor_id, "workflow-checkpoint.json",
+    )
+    return read_checkpoint_cursor(checkpoint_path)
+
+
+def _checkpoint_phase_or_cached(project_root, refactor_id, status_data):
+    """Return live checkpoint phase, falling back to cached status data."""
+    checkpoint_phase = _read_refactor_checkpoint_phase(project_root, refactor_id)
+    if checkpoint_phase is not None:
+        return checkpoint_phase
+    return status_data.get("resume_from_phase")
+
+
+def _sync_checkpoint_phase(project_root, refactor_id, status_data):
+    """Cache live checkpoint phase in status.json runtime data."""
+    status_data["resume_from_phase"] = _read_refactor_checkpoint_phase(
+        project_root, refactor_id,
+    )
+    return status_data.get("resume_from_phase")
+
+
 def _load_progress_fingerprint(raw):
     if not raw:
         return None
@@ -304,31 +331,21 @@ def continuation_metadata_summary(status_data):
 
 
 def _dependencies_met(refactor, completed_set):
-    """Check if all dependencies for a refactor are in terminal (completed) status."""
+    """Check if all dependencies for a refactor are completed."""
     deps = refactor.get("dependencies", [])
     if not deps or not isinstance(deps, list):
         return True
     return all(dep in completed_set for dep in deps)
 
 
-def _count_unmet_deps(refactor, completed_set):
-    """Count how many dependencies are not yet completed."""
-    deps = refactor.get("dependencies", [])
-    if not deps or not isinstance(deps, list):
-        return 0
-    return sum(1 for dep in deps if dep not in completed_set)
-
-
-def action_get_next(refactor_list_data, state_dir):
+def action_get_next(refactor_list_data, state_dir, project_root=None):
     """Find the next refactor to process.
 
     Priority logic:
     1. Skip terminal statuses (completed, failed, skipped)
-    2. Only consider refactors whose dependencies are all completed
+    2. Only consider refactors whose dependencies are completed
     3. Prefer in_progress refactors (interrupted session resume) over pending
-    4. Sort by: dependency order (no-dependency items first),
-       then priority (critical > high > medium > low),
-       then complexity (low first)
+    4. Within each status class, use stable topological list order
     """
     refactors = refactor_list_data.get("refactors", [])
     if not refactors:
@@ -348,7 +365,16 @@ def action_get_next(refactor_list_data, state_dir):
         rs = load_refactor_status(state_dir, rid)
         status_data_map[rid] = rs
 
-    completed_set = {rid for rid, st in status_map.items() if st in TERMINAL_STATUSES}
+    completed_set = {rid for rid, st in status_map.items() if st == "completed"}
+    topo_rank, topo_errors = dependency_rank_map(
+        refactors,
+        id_key="id",
+        dependencies_key="dependencies",
+        item_label="Refactor",
+    )
+    if topo_errors:
+        print("PIPELINE_BLOCKED")
+        return
 
     # Check if all refactors are terminal
     non_terminal = [
@@ -377,16 +403,16 @@ def action_get_next(refactor_list_data, state_dir):
         elif rstatus == "pending":
             pending_refactors.append(r)
 
-    def sort_key(r):
-        unmet = _count_unmet_deps(r, completed_set)
-        priority = PRIORITY_ORDER.get(r.get("priority", "medium"), 2)
-        complexity = COMPLEXITY_ORDER.get(r.get("complexity", "medium"), 1)
-        return (unmet, priority, complexity)
-
     if in_progress_refactors:
-        candidates = sorted(in_progress_refactors, key=sort_key)
+        candidates = sorted(
+            in_progress_refactors,
+            key=lambda r: topo_rank.get(r.get("id"), len(refactors))
+        )
     elif pending_refactors:
-        candidates = sorted(pending_refactors, key=sort_key)
+        candidates = sorted(
+            pending_refactors,
+            key=lambda r: topo_rank.get(r.get("id"), len(refactors))
+        )
     else:
         print("PIPELINE_BLOCKED")
         return
@@ -394,6 +420,10 @@ def action_get_next(refactor_list_data, state_dir):
     chosen = candidates[0]
     chosen_id = chosen["id"]
     chosen_status_data = status_data_map.get(chosen_id, {})
+    project_root = os.path.abspath(project_root) if project_root else _default_project_root()
+    resume_phase = _checkpoint_phase_or_cached(
+        project_root, chosen_id, chosen_status_data,
+    )
 
     result = {
         "refactor_id": chosen_id,
@@ -403,7 +433,7 @@ def action_get_next(refactor_list_data, state_dir):
         "complexity": chosen.get("complexity", "medium"),
         "retry_count": chosen_status_data.get("retry_count", 0),
         "infra_error_count": chosen_status_data.get("infra_error_count", 0),
-        "resume_from_phase": chosen_status_data.get("resume_from_phase", None),
+        "resume_from_phase": resume_phase,
     }
     result.update(continuation_metadata_summary(chosen_status_data))
     print(json.dumps(result, indent=2, ensure_ascii=False))
@@ -533,6 +563,10 @@ def action_update(args, refactor_list_path, state_dir):
         rs["last_session_id"] = session_id
 
     rs["updated_at"] = now_iso()
+    # Sync resume_from_phase from checkpoint (single source of truth)
+    _sync_checkpoint_phase(
+        args.project_root or _default_project_root(), refactor_id, rs,
+    )
 
     err = save_refactor_status(state_dir, refactor_id, rs)
     if err:
@@ -829,9 +863,10 @@ COMPLEXITY_BADGES = {
 }
 
 
-def action_status(refactor_list_data, state_dir):
+def action_status(refactor_list_data, state_dir, project_root=None):
     refactors = refactor_list_data.get("refactors", [])
     project_name = refactor_list_data.get("project_name", "Unknown")
+    project_root = os.path.abspath(project_root) if project_root else _default_project_root()
 
     counts = {"completed": 0, "in_progress": 0, "failed": 0, "pending": 0, "skipped": 0, "auto_skipped": 0}
     refactor_lines = []
@@ -850,7 +885,12 @@ def action_status(refactor_list_data, state_dir):
         rs = load_refactor_status(state_dir, rid)
         retry_count = rs.get("retry_count", 0)
         max_retries_val = rs.get("max_retries", 3)
-        resume_phase = rs.get("resume_from_phase")
+        # Read phase cursor from checkpoint (single source of truth). The
+        # status.json field is only a cache/fallback for missing checkpoints.
+        resume_phase = _checkpoint_phase_or_cached(project_root, rid, rs)
+        if resume_phase != rs.get("resume_from_phase"):
+            rs["resume_from_phase"] = resume_phase
+            save_refactor_status(state_dir, rid, rs)
 
         if rstatus in counts:
             counts[rstatus] += 1
@@ -1302,11 +1342,11 @@ def main():
         error_out("Cannot load refactor list: {}".format(err))
 
     if args.action == "get_next":
-        action_get_next(refactor_list_data, args.state_dir)
+        action_get_next(refactor_list_data, args.state_dir, args.project_root)
     elif args.action == "update":
         action_update(args, args.refactor_list, args.state_dir)
     elif args.action == "status":
-        action_status(refactor_list_data, args.state_dir)
+        action_status(refactor_list_data, args.state_dir, args.project_root)
     elif args.action == "reset":
         action_reset(args, args.refactor_list, args.state_dir)
     elif args.action == "clean":

package/bundled/dev-pipeline/scripts/utils.py

@@ -93,6 +93,137 @@ def write_json_file(path, data):
     return None
 
 
+def _find_dependency_cycle(dep_map, item_ids):
+    """Return one dependency cycle as a list of IDs, or an empty list."""
+    visiting = set()
+    visited = set()
+    stack = []
+
+    def visit(node):
+        visiting.add(node)
+        stack.append(node)
+        for dep in dep_map.get(node, []):
+            if dep not in item_ids:
+                continue
+            if dep in visiting:
+                start = stack.index(dep)
+                return stack[start:] + [dep]
+            if dep not in visited:
+                cycle = visit(dep)
+                if cycle:
+                    return cycle
+        stack.pop()
+        visiting.remove(node)
+        visited.add(node)
+        return []
+
+    for item_id in sorted(item_ids):
+        if item_id not in visited:
+            cycle = visit(item_id)
+            if cycle:
+                return cycle
+    return []
+
+
+def stable_topological_order(items, id_key="id", dependencies_key="dependencies", item_label="Item"):
+    """Validate dependencies and return items in stable topological order.
+
+    Dependency edges are interpreted as ``item depends on dependency``. The
+    returned order guarantees dependencies appear before dependents. Items with
+    no dependency relationship keep their original list order.
+
+    Returns ``(ordered_items, errors)``. Callers should treat non-empty errors
+    as blocking because missing dependencies, self-dependencies, and cycles make
+    autonomous selection ambiguous.
+    """
+    errors = []
+    indexed_items = []
+    item_by_id = {}
+    index_by_id = {}
+
+    for index, item in enumerate(items or []):
+        if not isinstance(item, dict):
+            continue
+        item_id = item.get(id_key)
+        if not item_id:
+            continue
+        if item_id in item_by_id:
+            errors.append("Duplicate {} id: {}".format(item_label.lower(), item_id))
+            continue
+        item_by_id[item_id] = item
+        index_by_id[item_id] = index
+        indexed_items.append((index, item_id, item))
+
+    adjacency = {item_id: [] for item_id in item_by_id}
+    in_degree = {item_id: 0 for item_id in item_by_id}
+    dep_map = {item_id: [] for item_id in item_by_id}
+
+    for _index, item_id, item in indexed_items:
+        deps = item.get(dependencies_key, [])
+        if deps is None:
+            deps = []
+        if not isinstance(deps, list):
+            errors.append("{} '{}' dependencies must be an array".format(item_label, item_id))
+            continue
+        for dep_id in deps:
+            if not isinstance(dep_id, str):
+                errors.append(
+                    "{} '{}' has invalid dependency {!r}; dependency IDs must be strings".format(
+                        item_label, item_id, dep_id
+                    )
+                )
+                continue
+            if dep_id == item_id:
+                errors.append("{} '{}' cannot depend on itself".format(item_label, item_id))
+                continue
+            if dep_id not in item_by_id:
+                errors.append("{} '{}' depends on missing dependency '{}'".format(
+                    item_label, item_id, dep_id
+                ))
+                continue
+            adjacency[dep_id].append(item_id)
+            in_degree[item_id] += 1
+            dep_map[item_id].append(dep_id)
+
+    queue = sorted(
+        [item_id for item_id, degree in in_degree.items() if degree == 0],
+        key=lambda value: index_by_id[value],
+    )
+    ordered_ids = []
+
+    while queue:
+        item_id = queue.pop(0)
+        ordered_ids.append(item_id)
+        for dependent_id in sorted(adjacency.get(item_id, []), key=lambda value: index_by_id[value]):
+            in_degree[dependent_id] -= 1
+            if in_degree[dependent_id] == 0:
+                queue.append(dependent_id)
+                queue.sort(key=lambda value: index_by_id[value])
+
+    if len(ordered_ids) != len(item_by_id):
+        remaining = {item_id for item_id, degree in in_degree.items() if degree > 0}
+        cycle = _find_dependency_cycle(dep_map, remaining)
+        if cycle:
+            errors.append("Dependency cycle detected: {}".format(" -> ".join(cycle)))
+        else:
+            errors.append("Dependency cycle detected involving: {}".format(
+                ", ".join(sorted(remaining, key=lambda value: index_by_id[value]))
+            ))
+
+    return [item_by_id[item_id] for item_id in ordered_ids], errors
+
+
+def dependency_rank_map(items, id_key="id", dependencies_key="dependencies", item_label="Item"):
+    """Return ``(rank_map, errors)`` for stable dependency-aware ordering."""
+    ordered, errors = stable_topological_order(
+        items,
+        id_key=id_key,
+        dependencies_key=dependencies_key,
+        item_label=item_label,
+    )
+    return {item[id_key]: index for index, item in enumerate(ordered) if id_key in item}, errors
+
+
 def setup_logging(name="prizmkit.dev_pipeline", level=None):
     """Configure and return a standard logger for pipeline scripts.
 
@@ -634,3 +765,43 @@ def read_platform_conventions(project_root):
             return "`{}`".format(filename)
 
     return "(No project conventions file found — AGENTS.md, CLAUDE.md, or CODEBUDDY.md)"
+
+
+def read_checkpoint_cursor(checkpoint_path):
+    """Read the phase cursor from a workflow-checkpoint.json file.
+
+    Returns the first non-completed/skipped step's step index (e.g., 3 for S03).
+    If every step is completed or skipped, returns the last completed/skipped
+    step index. Returns None if the file does not exist or is unreadable.
+
+    The cursor is what gets displayed as "CP-BF-<n>" in the terminal status.
+    """
+    if not os.path.isfile(checkpoint_path):
+        return None
+    try:
+        with open(checkpoint_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return None
+    if not isinstance(data, dict):
+        return None
+    steps = data.get("steps")
+    if not isinstance(steps, list):
+        return None
+    last_completed = 0
+    for step in steps:
+        if not isinstance(step, dict):
+            continue
+        status = step.get("status", "pending")
+        sid = step.get("id", "")
+        try:
+            step_num = int(sid.lstrip("S"))
+        except (ValueError, AttributeError):
+            continue
+        if status in ("completed", "skipped"):
+            last_completed = max(last_completed, step_num)
+        else:
+            # Return the first non-completed step's number
+            return step_num
+    # All steps are completed — return the last step number
+    return last_completed if last_completed > 0 else None

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

@@ -36,7 +36,7 @@ Infer what needs to be done from the feature context above and follow the standa
 
 6. **Retrospective**: Run `/prizmkit-retrospective` to sync `.prizmkit/prizm-docs/` with code changes.
 
-7. **Commit**: Run `/prizmkit-committer --headless` to commit all changes. Do NOT push.
+7. **Commit**: Run `/prizmkit-committer` to commit all changes. Do NOT push.
 
 ### Critical Rules
 

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

@@ -12,7 +12,7 @@ You are the **session orchestrator**. Implement Feature {{FEATURE_ID}}: "{{FEATU
 
 **CRITICAL**: You MUST NOT exit until ALL work is complete and committed. When you spawn Critic or Reviewer agents, wait for each to finish (run_in_background=false).
 
-**Tier 2 — Orchestrator + Critic/Reviewer**: You handle context, planning, and implementation directly. Critic challenges the plan when enabled, Reviewer reviews. Do not spawn a top-level Dev subagent for implementation.
+**Tier 2 — Orchestrator + Critic**: You handle context, planning, and implementation directly. Critic challenges the plan when enabled. Do not spawn top-level Dev or Reviewer subagents; code review runs later through `/prizmkit-code-review`.
 
 **Agent spawn failure policy (all Agent tool calls)**:
 - If spawning Reviewer or Critic fails with team/config/lock errors, retry at most once.
@@ -160,23 +160,16 @@ Before proceeding past CP-1, verify:
 
 **CP-1**: plan.md exists with Tasks section.
 
-### Phase 3: Analyze — Reviewer Subagent
+### Phase 3: Plan Self-Check — Orchestrator Direct
 
-Spawn Reviewer agent (Agent tool, subagent_type="prizm-dev-team-reviewer", mode="plan", run_in_background=false, isolation=default/no worktree). Do not request worktree isolation; this prevents AI tool-created `.claude/worktrees/...` subagent worktrees. PrizmKit pipeline-managed linked git worktrees under `.prizmkit/state/worktrees/...` are separate and controlled by `USE_WORKTREE`.
+Do not spawn a top-level Reviewer subagent for planning analysis. Perform a bounded self-check before implementation:
 
-Spawn failure cap: for team/config/lock errors, retry at most once for this Reviewer spawn. If the second attempt fails, do not poll for report artifacts; fix/check the plan inline or write `failure-log.md` before stopping for recovery.
+1. Re-read only `context-snapshot.md` and `plan.md`.
+2. Cross-check plan.md Tasks against the feature description and acceptance criteria.
+3. Verify the plan references the File Manifest and avoids unrelated work.
+4. If you find CRITICAL issues, fix ONLY those issues in plan.md before continuing.
 
-Prompt:
-> "Read {{REVIEWER_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}):
-> 1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST — Section 3 has project context, Section 4 has file manifest.
-> 2. Cross-check `plan.md` (including Tasks section) against feature description and acceptance criteria for consistency.
-> 3. Before flagging CRITICAL or HIGH issues, read the relevant source files listed in the File Manifest to verify.
-> Report: CRITICAL, HIGH, MEDIUM issues found (or 'No issues found')."
-
-Wait for Reviewer to return.
-- If CRITICAL issues found: fix them yourself — read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` for full project context. Fix ONLY the listed CRITICAL issues in plan.md. Then re-run analyze (max 1 round).
-
-**CP-2**: No CRITICAL issues.
+**CP-2**: Plan self-check complete; no CRITICAL plan issues remain.
 
 {{IF_CRITIC_ENABLED}}
 ### Phase 3.5: Plan Challenge — Critic Agent(s)
@@ -555,7 +548,6 @@ Rules for writing completion notes:
 |----------|------|
 | Feature Artifacts Dir | `.prizmkit/specs/{{FEATURE_SLUG}}/` |
 | Context Snapshot | `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` |
-| Reviewer Agent Def | {{REVIEWER_SUBAGENT_PATH}} |
 {{IF_CRITIC_ENABLED}}
 | Critic Agent Def | {{CRITIC_SUBAGENT_PATH}} |
 {{END_IF_CRITIC_ENABLED}}
@@ -580,11 +572,11 @@ If you encounter an unrecoverable error, context overflow, or are about to exit
 
 ## Reminders
 
-- Tier 2: orchestrator builds context+plan and implements directly; Critic challenges plan when enabled; Reviewer reviews
+- Tier 2: orchestrator builds context+plan and implements directly; Critic challenges plan when enabled; `/prizmkit-code-review` handles review later
 - Build context-snapshot.md FIRST; use it throughout instead of re-reading source files
 - 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
-- Do NOT use `run_in_background=true` when spawning Critic or Reviewer agents
+- Do NOT use `run_in_background=true` when spawning Critic agents
 - **NEVER delete, modify, or touch any file under `.prizmkit/state/`** — those are pipeline runtime files managed by the runner
 - NEVER run `rm -rf`, `git clean`, or any destructive filesystem operations
 - `/prizmkit-committer` is mandatory, and must not be replaced with manual git commit commands