prizmkit 1.1.119 → 1.1.121

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

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import sys
 import time
+from collections.abc import Mapping
 from pathlib import Path
 
 from .commands import CommandResult  # type: ignore  # imported only at runtime by commands.py
@@ -336,6 +337,32 @@ def _progress_data(path: Path) -> dict[str, object]:
     return data if isinstance(data, dict) else {}
 
 
+def _subagent_state_summary(progress: Mapping[str, object]) -> str:
+    states = progress.get("subagent_states")
+    if not isinstance(states, list):
+        return ""
+    parts = []
+    for item in states:
+        if not isinstance(item, Mapping):
+            continue
+        status = str(item.get("status") or "unknown")
+        count = int(item.get("count") or 0)
+        if count:
+            parts.append(f"{status}={count}")
+    return ", ".join(parts)
+
+
+def _child_log_activity_summary(progress: Mapping[str, object]) -> str:
+    child_bytes = int(progress.get("child_total_bytes") or 0)
+    child_files = progress.get("child_session_files")
+    child_file_count = len(child_files) if isinstance(child_files, list) else 0
+    if not child_bytes and not child_file_count:
+        return ""
+    if child_file_count:
+        return f"{_bytes_text(child_bytes)} across {child_file_count} files"
+    return _bytes_text(child_bytes)
+
+
 def _emit_prompt_summary(prompt: PromptGenerationResult, session_id: str) -> None:
     if prompt.pipeline_mode:
         _emit_info(f"Pipeline mode: {_pipeline_mode_label(prompt.pipeline_mode)}")
@@ -359,9 +386,24 @@ def _emit_session_summary(session_result, session_paths: SessionPaths, classific
     _emit_info(f"exit_code={getattr(session_result, 'exit_code', None)}")
     _emit_info(f"Session result: {classification.session_status}")
     progress = _progress_data(session_paths.progress_json)
-    subagent_calls = int(progress.get("subagent_spawn_count") or 0)
-    if subagent_calls:
-        _emit_info(f"Subagent calls detected in session: {subagent_calls}")
+    subagent_stats = progress.get("subagent_statistics")
+    if isinstance(subagent_stats, Mapping):
+        spawned = int(subagent_stats.get("spawned") or 0)
+        active = int(subagent_stats.get("active") or 0)
+        providers = subagent_stats.get("providers")
+        provider_text = ",".join(str(provider) for provider in providers) if isinstance(providers, list) else ""
+    else:
+        spawned = int(progress.get("subagent_spawn_count") or 0)
+        active = int(progress.get("active_subagent_count") or 0)
+        provider_text = str(progress.get("subagent_provider") or "")
+    state_summary = _subagent_state_summary(progress)
+    if spawned or active or state_summary:
+        suffix = f" ({provider_text}; source=session.log)" if provider_text else " (source=session.log)"
+        state_text = f", states: {state_summary}" if state_summary else ""
+        _emit_info(f"Subagents: spawned={spawned}, active={active}{state_text}{suffix}")
+    child_summary = _child_log_activity_summary(progress)
+    if child_summary:
+        _emit_info(f"Child log activity: {child_summary} (heartbeat liveness only)")
     if classification.session_status == "success":
         _emit_info("CHECKPOINT: All workflow steps completed")
 
@@ -489,8 +531,11 @@ def _process_item(
         previous_no_progress_count = int(metadata.get("no_progress_count") or 0)
         continuation_pending = bool(metadata.get("continuation_pending"))
         previous_session_id = str(metadata.get("previous_session_id") or metadata.get("last_context_overflow_session_id") or "")
+        failure_classification = str(metadata.get("continuation_reason") or "context_overflow")
         continuation_count = int(metadata.get("continuation_count") or 0)
         context_overflow_count = int(metadata.get("context_overflow_count") or 0)
+        retry_count = int(metadata.get("retry_count") or 0)
+        infra_error_count = int(metadata.get("infra_error_count") or 0)
 
         while True:
             session_id = _session_id(item_id)
@@ -499,8 +544,15 @@ def _process_item(
             if continuation_pending:
                 continuation = {
                     "previous_session_id": previous_session_id,
+                    "failure_classification": failure_classification,
                     "continuation_count": continuation_count,
                     "context_overflow_count": context_overflow_count,
+                    "retry_count": retry_count,
+                    "infra_error_count": infra_error_count,
+                    "max_retries": _max_retries(invocation),
+                    "max_infra_retries": invocation.max_infra_retries,
+                    "no_progress_count": previous_no_progress_count,
+                    "progress_fingerprint": previous_fingerprint or {},
                     "task_type": family.task_type,
                     "active_dev_branch": branch_name,
                     "base_branch": base_branch,
@@ -512,7 +564,7 @@ def _process_item(
                 item_id=item_id,
                 session_id=session_id,
                 run_id="run-python",
-                retry_count=0,
+                retry_count=retry_count,
                 session_paths=session_paths,
                 project_root=paths.project_root,
                 execution_root=execution_root,
@@ -557,34 +609,8 @@ def _process_item(
                 previous_no_progress_count=previous_no_progress_count,
             )
             _emit_session_summary(session_result, session_paths, classification)
-            if classification.session_status == "context_overflow":
-                summary_path = _continuation_summary_path(execution_root, family, item_id, prompt)
-                update = update_item(
-                    status_family,
-                    status_invocation,
-                    item_id,
-                    "context_overflow",
-                    session_id,
-                    status_root,
-                    active_dev_branch=branch_name,
-                    base_branch=base_branch,
-                    last_fatal_error_code=classification.fatal_error_code or "context_overflow",
-                    continuation_summary_path=summary_path,
-                    no_progress_count=classification.no_progress_count,
-                    progress_fingerprint=classification.progress_fingerprint,
-                )
-                if not update.ok:
-                    raise RuntimeError(update.text)
-                _emit_update_summary(family, item_id, update)
-                previous_fingerprint = classification.progress_fingerprint
-                previous_no_progress_count = classification.no_progress_count
-                continuation_pending = True
-                previous_session_id = session_id
-                continuation_count += 1
-                context_overflow_count += 1
-                continue
-
             final_session_status = classification.session_status
+            summary_path = _continuation_summary_path(execution_root, family, item_id, prompt)
 
             _write_session_status(
                 session_paths,
@@ -609,6 +635,7 @@ def _process_item(
                 active_dev_branch=branch_name,
                 base_branch=base_branch,
                 last_fatal_error_code=classification.fatal_error_code,
+                continuation_summary_path=summary_path,
                 no_progress_count=classification.no_progress_count,
                 progress_fingerprint=classification.progress_fingerprint,
             )
@@ -616,6 +643,22 @@ def _process_item(
                 raise RuntimeError(update.text)
             _emit_update_summary(family, item_id, update)
             new_status = _status_from_update(update)
+            update_data = update.data if isinstance(update.data, dict) else {}
+            retry_count = int(update_data.get("retry_count", retry_count) or 0)
+            infra_error_count = int(update_data.get("infra_error_count", infra_error_count) or 0)
+
+            if _is_retryable_ai_outcome(final_session_status, new_status):
+                previous_fingerprint = classification.progress_fingerprint
+                previous_no_progress_count = classification.no_progress_count
+                continuation_pending = True
+                previous_session_id = session_id
+                failure_classification = classification.reason or final_session_status
+                continuation_count = int(update_data.get("continuation_count", continuation_count + 1) or 0)
+                context_overflow_count = int(update_data.get("context_overflow_count", context_overflow_count) or 0)
+                _emit_info(f"Retryable AI outcome persisted ({failure_classification}); continuing in 5s...")
+                time.sleep(5)
+                continue
+
             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)
@@ -652,6 +695,19 @@ def _process_item(
         raise
 
 
+def _is_retryable_ai_outcome(session_status: str, new_status: str) -> bool:
+    """Return whether a persisted post-launch outcome should continue in-process."""
+    if session_status == "success" or session_status == "stalled_context_continuation":
+        return False
+    return new_status in {"in_progress", "pending"} and session_status in {
+        "context_overflow",
+        "infra_error",
+        "crashed",
+        "timed_out",
+        "failed",
+    }
+
+
 def _finalize_recovered_success(
     family: RunnerFamily,
     item_id: str,
@@ -970,7 +1026,7 @@ def _default_branch_name(family: RunnerFamily, item_id: str) -> str:
 
 
 def _session_id(item_id: str) -> str:
-    return f"{item_id}-{time.strftime('%Y%m%d%H%M%S')}"
+    return f"{item_id}-{time.strftime('%Y%m%d%H%M%S')}-{time.time_ns()}"
 
 
 def _continuation_summary_path(project_root: Path, family: RunnerFamily, item_id: str, prompt: PromptGenerationResult | None) -> Path:

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

@@ -402,6 +402,10 @@ def _progress_refresh_key(data: Mapping[str, object]) -> tuple[object, ...]:
         int(data.get("total_tool_calls") or 0),
         int(data.get("active_subagent_count") or 0),
         int(data.get("subagent_spawn_count") or 0),
+        str(data.get("subagent_stats_source") or ""),
+        str(data.get("subagent_provider") or ""),
+        json.dumps(data.get("subagent_states") or [], sort_keys=True, default=str),
+        json.dumps(data.get("subagent_observed_ids") or [], sort_keys=True, default=str),
         str(data.get("child_activity_signature") or ""),
         int(data.get("child_total_bytes") or 0),
         str(data.get("fatal_error_code") or ""),
@@ -549,12 +553,30 @@ def _compact_progress_line(
         f"log: {_format_bytes(log_size)}",
     ]
     child_bytes = int(data.get("child_total_bytes") or 0)
-    subagents = int(data.get("subagent_spawn_count") or 0)
-    if child_bytes or subagents:
-        child = _format_bytes(child_bytes)
-        if subagents:
-            child = f"{child}/{subagents}"
-        parts.append(f"child: {child}")
+    child_files = data.get("child_session_files")
+    child_file_count = len(child_files) if isinstance(child_files, list) else 0
+    spawned = int(data.get("subagent_spawn_count") or 0)
+    active = int(data.get("active_subagent_count") or 0)
+    subagent_states = data.get("subagent_states")
+    if spawned or active or subagent_states:
+        state_bits = []
+        if isinstance(subagent_states, list):
+            for item in subagent_states:
+                if not isinstance(item, Mapping):
+                    continue
+                status = str(item.get("status") or "unknown")
+                count = int(item.get("count") or 0)
+                if count:
+                    state_bits.append(f"{status}={count}")
+        subagent_text = f"spawned={spawned} active={active}"
+        if state_bits:
+            subagent_text = f"{subagent_text} states:{','.join(state_bits)}"
+        parts.append(f"subagents: {subagent_text}")
+    if child_bytes or child_file_count:
+        child_text = _format_bytes(child_bytes)
+        if child_file_count:
+            child_text = f"{child_text}/{child_file_count} files"
+        parts.append(f"child logs: {child_text}")
     phase = _checkpoint_phase_label(checkpoint_path)
     if phase:
         parts.append(f"phase: {phase}")

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

@@ -1,5 +1,6 @@
 """Continuation prompt and durable handoff helpers for pipeline prompt generators."""
 
+import json
 import os
 import sys
 
@@ -9,7 +10,7 @@ if _PIPELINE_ROOT not in sys.path:
 
 from prizmkit_runtime.checkpoint_state import checkpoint_cursor as shared_checkpoint_cursor  # noqa: E402
 
-SUPPORTED_CONTINUATION_MODES = {"context_overflow"}
+SUPPORTED_CONTINUATION_MODES = {"context_overflow", "ai_error"}
 TASK_TYPES = {"feature", "bugfix", "refactor"}
 
 
@@ -19,13 +20,18 @@ def add_continuation_args(parser, default_task_type):
         "--continuation-mode",
         choices=sorted(SUPPORTED_CONTINUATION_MODES),
         default="",
-        help="Continuation recovery mode, currently context_overflow.",
+        help="Provider-neutral in-process AI error continuation mode.",
     )
     parser.add_argument(
         "--previous-session-id",
         default="",
         help="Session ID that triggered this continuation.",
     )
+    parser.add_argument(
+        "--failure-classification",
+        default="context_overflow",
+        help="Classified outcome from the previous launched AI session.",
+    )
     parser.add_argument(
         "--continuation-count",
         default="0",
@@ -36,6 +42,12 @@ def add_continuation_args(parser, default_task_type):
         default="0",
         help="Cumulative context overflow count for this task.",
     )
+    parser.add_argument("--code-retry-count", default="0", help="Persisted code retry count.")
+    parser.add_argument("--infra-error-count", default="0", help="Persisted infrastructure retry count.")
+    parser.add_argument("--max-code-retries", default="0", help="Configured code retry budget.")
+    parser.add_argument("--max-infra-retries", default="0", help="Configured infrastructure retry budget.")
+    parser.add_argument("--no-progress-count", default="0", help="Consecutive context continuations without durable progress.")
+    parser.add_argument("--progress-fingerprint", default="", help="JSON durable Git/checkpoint/artifact progress summary.")
     parser.add_argument(
         "--task-type",
         choices=sorted(TASK_TYPES),
@@ -72,6 +84,16 @@ def _safe_int(value, default=0):
     return parsed if parsed >= 0 else default
 
 
+def _safe_json_object(value):
+    if isinstance(value, dict):
+        return value
+    try:
+        parsed = json.loads(str(value or ""))
+    except (TypeError, ValueError, json.JSONDecodeError):
+        return {}
+    return parsed if isinstance(parsed, dict) else {}
+
+
 def _norm(path):
     return str(path).replace(os.sep, "/")
 
@@ -193,7 +215,7 @@ def _build_summary(context):
         "## Reason",
         "",
         "- Continuation mode: {}".format(context["mode"]),
-        "- This continuation was started after context overflow.",
+        "- Previous AI session classification: {}".format(context["failure_classification"]),
         "- This artifact is the durable handoff summary; do not rely on the previous full transcript.",
         "",
         "## Previous Session",
@@ -211,6 +233,17 @@ def _build_summary(context):
         "- Base branch: {}".format(context["base_branch"] or "(unknown)"),
         "- Continuation count: {}".format(context["continuation_count"]),
         "- Context overflow count: {}".format(context["context_overflow_count"]),
+        "- Code retry count: {} / {}".format(context["code_retry_count"], context["max_code_retries"]),
+        "- Infrastructure retry count: {} / {}".format(context["infra_error_count"], context["max_infra_retries"]),
+        "- Consecutive no-progress context count: {}".format(context["no_progress_count"]),
+        "",
+        "## Git and Checkpoint Progress",
+        "",
+        "- Current checkpoint phase: {}".format(cursor["first_cursor"]),
+        "- Git status fingerprint: {}".format(context["progress_fingerprint"].get("git_diff_fingerprint", "(unknown)")),
+        "- HEAD commit: {}".format(context["progress_fingerprint"].get("head_commit", "(unknown)")),
+        "- Artifact fingerprint: {}".format(context["progress_fingerprint"].get("artifact_fingerprint", "(unknown)")),
+        "- Checkpoint cursor fingerprint: {}".format(context["progress_fingerprint"].get("checkpoint_cursor", "(unknown)")),
         "",
         "## Observed Partial Progress",
         "",
@@ -247,16 +280,18 @@ def _build_addendum(context):
     runtime = context["runtime"]
     summary_paths = context["summary_paths"]
     lines = [
-        "## Continuation Addendum — Context Overflow Recovery",
+        "## Continuation Addendum — In-Process AI Error Recovery",
         "",
-        "This is an automatic continuation after context overflow.",
+        "This is an automatic continuation after the previous launched AI session ended with `{}`.".format(context["failure_classification"]),
         "This is a fresh headless AI CLI session for the same task.",
         "Continue on the current branch/worktree.",
         "Do not reset, clean, switch branches, or discard work.",
         "",
         "### Required First Actions",
         "",
-        "- Start with `git status` and `git diff`.",
+        "- Inspect `git status` and `git diff` before editing.",
+        "- Validate the workflow checkpoint and current phase before resuming.",
+        "- Inspect existing task artifacts and run only the tests necessary to establish current test state.",
         "- Reuse the same durable task artifact directory: `{}`.".format(_norm(durable["artifact_dir"])),
         "- Treat completed/skipped checkpoint steps as already done.",
         "- Continue from the first pending/in-progress checkpoint step: `{}`.".format(cursor["first_cursor"]),
@@ -276,7 +311,10 @@ def _build_addendum(context):
         "- Failure log path: `{}`".format(_norm(durable["failure_log"])),
         "- Continuation summary path(s): `{}`".format(", ".join(_norm(p) for p in summary_paths)),
         "- Continuation count: `{}`".format(context["continuation_count"]),
+        "- Previous failure classification: `{}`".format(context["failure_classification"]),
         "- Context overflow count: `{}`".format(context["context_overflow_count"]),
+        "- Code retry count: `{}` / `{}`".format(context["code_retry_count"], context["max_code_retries"]),
+        "- Infrastructure retry count: `{}` / `{}`".format(context["infra_error_count"], context["max_infra_retries"]),
         "- Previous session id: `{}`".format(context["previous_session_id"] or "(unknown)"),
         "- Previous session log reference: `{}`".format(runtime["previous_session_log"]),
         "",
@@ -316,8 +354,15 @@ def append_continuation_handoff(rendered_prompt, args, project_root, task_type,
         "task_id": task_id,
         "task_slug": task_slug,
         "previous_session_id": previous_session_id,
+        "failure_classification": getattr(args, "failure_classification", "") or "context_overflow",
         "continuation_count": _safe_int(getattr(args, "continuation_count", 0)),
         "context_overflow_count": _safe_int(getattr(args, "context_overflow_count", 0)),
+        "code_retry_count": _safe_int(getattr(args, "code_retry_count", 0)),
+        "infra_error_count": _safe_int(getattr(args, "infra_error_count", 0)),
+        "max_code_retries": _safe_int(getattr(args, "max_code_retries", 0)),
+        "max_infra_retries": _safe_int(getattr(args, "max_infra_retries", 0)),
+        "no_progress_count": _safe_int(getattr(args, "no_progress_count", 0)),
+        "progress_fingerprint": _safe_json_object(getattr(args, "progress_fingerprint", "")),
         "active_dev_branch": getattr(args, "active_dev_branch", ""),
         "base_branch": getattr(args, "base_branch", ""),
         "durable": durable,

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

@@ -3,14 +3,16 @@
 
 Supports two modes:
 1. **Section assembly** (preferred): Loads modular section files from
-   templates/sections/ and assembles them based on tier, conditions, and
-   feature configuration. Conditional logic is handled in Python code,
+   templates/sections/ and assembles the unified full/tier3-equivalent
+   feature guidance by default. Conditional logic is handled in Python code,
    not regex-based template blocks.
-2. **Legacy template** (fallback): Reads a monolithic bootstrap-tier{1,2,3}.md
-   template and resolves {{PLACEHOLDER}} variables and {{IF_xxx}} blocks.
+2. **Legacy template** (fallback): Reads the monolithic bootstrap-tier3.md
+   template, falling back to bootstrap-prompt.md when tier3 is unavailable,
+   and resolves {{PLACEHOLDER}} variables and {{IF_xxx}} blocks.
 
-The section assembly mode is used when templates/sections/ directory exists.
-Otherwise, falls back to legacy templates for backward compatibility.
+The section assembly mode is used when templates/sections/ directory exists
+and no explicit --template path is supplied. Otherwise, falls back to legacy
+templates for backward compatibility.
 
 Usage:
     python3 generate-bootstrap-prompt.py \
@@ -93,8 +95,9 @@ def parse_args():
         "--template",
         default=None,
         help=(
-            "Custom template path. Defaults to "
-            "{script_dir}/../templates/bootstrap-prompt.md"
+            "Custom template path. Defaults to section-based full feature "
+            "prompt assembly, or {script_dir}/../templates/bootstrap-tier3.md "
+            "when sections are unavailable."
         ),
     )
     parser.add_argument(
@@ -620,18 +623,21 @@ def detect_existing_artifacts(project_root, feature_slug):
 
 
 def determine_pipeline_mode(complexity):
-    """Map estimated_complexity to pipeline mode.
-
-    Returns: 'lite', 'standard', or 'full'
-
-    Tier assignment rationale:
-    - low + medium → lite (single agent): most features don't benefit from
-      the orchestrator→dev→reviewer overhead. A single agent reading
-      .prizmkit/prizm-docs + implementing directly is faster and cheaper.
-    - high → standard (orchestrator + dev + reviewer): complex features
-      need the spec→plan→analyze→implement→review pipeline.
-    - critical → full (full team + framework guardrails): architectural
-      changes that touch many files and need extra safety checks.
+    """Return the unified feature prompt mode for any complexity.
+
+    ``estimated_complexity`` remains input metadata for planning summaries,
+    dependency ordering, and rendered Session Context, but prompt guidance is
+    intentionally no longer tiered by complexity. Every feature task receives
+    the full/tier3-equivalent guidance by default.
+    """
+    return "full"
+
+
+def determine_legacy_template_mode(complexity):
+    """Map complexity for explicit custom template conditional compatibility.
+
+    This is used only when a caller supplies ``--template`` and omits
+    ``--mode``. The normal feature prompt path never uses this mapping.
     """
     mapping = {
         "low": "lite",
@@ -1214,16 +1220,18 @@ def _tier_header(pipeline_mode):
     """Return the tier-specific header and mission description."""
     headers = {
         "lite": (
-            "# Dev-Pipeline Session Bootstrap — Tier 1 (Single Agent)\n",
-            "**Tier 1 — Single Agent**: You handle everything directly. "
-            "No normal work subagents. No TeamCreate.\n",
+            "# Dev-Pipeline Session Bootstrap — Unified Full Guidance "
+            "(compatibility mode: lite)\n",
+            "**Unified Full Guidance**: Feature prompts use the "
+            "full/tier3-equivalent sections for every estimated complexity. "
+            "The lite label remains metadata only for compatibility.\n",
         ),
         "standard": (
-            "# Dev-Pipeline Session Bootstrap — Tier 2 "
-            "(Orchestrator + Reviewer)\n",
-            "**Tier 2 — Orchestrator + Reviewer**: You handle "
-            "context + planning + implementation directly. Reviewer reviews. "
-            "No Dev subagent — orchestrator implements directly (P0-6).\n",
+            "# Dev-Pipeline Session Bootstrap — Unified Full Guidance "
+            "(compatibility mode: standard)\n",
+            "**Unified Full Guidance**: Feature prompts use the "
+            "full/tier3-equivalent sections for every estimated complexity. "
+            "The standard label remains metadata only for compatibility.\n",
         ),
         "full": (
             "# Dev-Pipeline Session Bootstrap — Tier 3 "
@@ -1256,13 +1264,13 @@ def _tier_reminders(pipeline_mode):
 
     if pipeline_mode == "lite":
         specific = [
-            "- Tier 1: you handle everything directly — no normal work "
-            "subagents needed",
+            "- Tier 1: compatibility label only; feature prompts now render "
+            "the unified full/tier3-equivalent guidance by default",
         ]
     elif pipeline_mode == "standard":
         specific = [
-            "- Tier 2: orchestrator builds context+plan, implements directly "
-            "(no Dev subagent), and Reviewer reviews — see P0-6",
+            "- 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) "
@@ -1283,6 +1291,14 @@ def _tier_reminders(pipeline_mode):
             "written before proceeding",
             "- 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 "
+            "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/` "
+            "— those are pipeline runtime files managed by the runner",
+            "- NEVER run `rm -rf`, `git clean`, or destructive filesystem "
+            "cleanup during the feature session",
             "- On timeout: check snapshot → model:lite → remaining steps "
             "only → max 2 retries → orchestrator fallback",
         ]
@@ -1575,56 +1591,8 @@ def build_replacements(args, feature, features, global_context, script_dir):
     """Build the full dict of placeholder -> replacement value."""
     project_root = _args_project_root(args, script_dir)
 
-    # Resolve paths - platform-aware agent/team resolution.
-    # Mixed `--platform all` installs must render commands for the actual AI
-    # environment, not whichever platform directory happens to be checked first.
-    platform = resolve_prompt_platform(project_root)
-    home_dir = os.path.expanduser("~")
-
-    if platform == "claude":
-        # Claude Code: agents in .claude/agents/, no native team config
-        agents_dir = os.path.join(project_root, ".claude", "agents")
-        team_config_path = os.path.join(
-            project_root, ".claude", "team-info.json",
-        )
-    elif platform == "codex":
-        # Codex: agents and team metadata are project-local references.
-        agents_dir = os.path.join(project_root, ".codex", "agents")
-        team_config_path = os.path.join(
-            project_root, ".codex", "team-info.json",
-        )
-    else:
-        # CodeBuddy: agents in .codebuddy/agents/, team in ~/.codebuddy/teams/
-        agents_dir = os.path.join(project_root, ".codebuddy", "agents")
-        team_config_path = os.path.join(
-            home_dir, ".codebuddy", "teams", "prizm-dev-team", "config.json",
-        )
-
-    # Agent definitions are native .toml for Codex and .md for Claude/CodeBuddy.
-    agent_ext = ".toml" if platform == "codex" else ".md"
-    dev_subagent = os.path.join(
-        agents_dir, f"prizm-dev-team-dev{agent_ext}",
-    )
-    reviewer_subagent = os.path.join(
-        agents_dir, f"prizm-dev-team-reviewer{agent_ext}",
-    )
-
-    # Verify agent files actually exist — missing files cause confusing
-    # errors when the AI session tries to read them later.
-    for agent_path, agent_name in [
-        (dev_subagent, "dev agent"),
-        (reviewer_subagent, "reviewer agent"),
-    ]:
-        if not os.path.isfile(agent_path):
-            LOGGER.warning(
-                "Agent file not found: %s (%s). "
-                "Subagent spawning may fail. "
-                "Run `npx prizmkit install` to reinstall agent definitions.",
-                agent_path, agent_name,
-            )
-    # Validator scripts - check if they exist in .codebuddy/scripts/, otherwise use .prizmkit/dev-pipeline/scripts/
-    validator_scripts_dir = os.path.join(project_root, ".prizmkit", "dev-pipeline", "scripts")
-    init_script_path = os.path.join(validator_scripts_dir, "init-dev-team.py")
+    # Resolve platform for platform-specific project convention references only.
+    resolve_prompt_platform(project_root)
 
     # Session status is controlled by the main runner state dir, even when
     # rendered project paths are AI-visible worktree paths.
@@ -1650,10 +1618,15 @@ def build_replacements(args, feature, features, global_context, script_dir):
         "estimated_complexity",
         feature.get("complexity", "medium"),
     )
-    if args.mode:
-        pipeline_mode = args.mode
+    if args.template:
+        pipeline_mode = args.mode or determine_legacy_template_mode(complexity)
     else:
         pipeline_mode = determine_pipeline_mode(complexity)
+    if args.mode and args.mode != pipeline_mode and not args.template:
+        LOGGER.info(
+            "Ignoring feature prompt --mode=%s; unified full guidance is used",
+            args.mode,
+        )
 
     # Auto-detect resume: if all planning artifacts exist and resume_phase
     # is "null" (fresh start), skip to Phase 6
@@ -1710,10 +1683,6 @@ def build_replacements(args, feature, features, global_context, script_dir):
         ),
         "{{GLOBAL_CONTEXT}}": format_global_context(global_context, project_root),
         "{{PROJECT_BRIEF}}": _read_project_brief(project_root),
-        "{{TEAM_CONFIG_PATH}}": team_config_path,
-        "{{DEV_SUBAGENT_PATH}}": dev_subagent,
-        "{{REVIEWER_SUBAGENT_PATH}}": reviewer_subagent,
-        "{{INIT_SCRIPT_PATH}}": init_script_path,
         "{{SESSION_STATUS_PATH}}": session_status_abs,
         "{{PROJECT_ROOT}}": project_root,
         "{{FEATURE_SLUG}}": feature_slug,
@@ -1859,20 +1828,9 @@ def main():
         if args.template:
             template_path = args.template
         else:
-            complexity = feature.get(
-                "estimated_complexity",
-                feature.get("complexity", "medium"),
-            )
-            _mode = args.mode or determine_pipeline_mode(complexity)
-            _tier_file_map = {
-                "lite": "bootstrap-tier1.md",
-                "standard": "bootstrap-tier2.md",
-                "full": "bootstrap-tier3.md",
-            }
-            _tier_file = _tier_file_map.get(_mode, "bootstrap-tier2.md")
-            _tier_path = os.path.join(templates_dir, _tier_file)
-            if os.path.isfile(_tier_path):
-                template_path = _tier_path
+            tier3_path = os.path.join(templates_dir, "bootstrap-tier3.md")
+            if os.path.isfile(tier3_path):
+                template_path = tier3_path
             else:
                 template_path = os.path.join(
                     templates_dir, "bootstrap-prompt.md"