prizmkit 1.1.137 → 1.1.139

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.1.137",
-  "bundledAt": "2026-07-19T22:45:14.904Z",
-  "bundledFrom": "c036667"
+  "frameworkVersion": "1.1.139",
+  "bundledAt": "2026-07-20T10:59:24.300Z",
+  "bundledFrom": "a055a29"
 }

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

@@ -96,7 +96,6 @@ class PromptGenerationResult:
     output_path: Path
     model: str = ""
     pipeline_mode: str = ""
-    agent_count: int = 0
     checkpoint_path: Path | None = None
     artifact_path: Path | None = None
     raw: Mapping[str, object] = field(default_factory=dict)

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

@@ -96,7 +96,6 @@ def generate_prompt(
         output_path=output_path,
         model=str(data.get("model") or ""),
         pipeline_mode=str(data.get("pipeline_mode") or ""),
-        agent_count=int(data.get("agent_count") or 0),
         checkpoint_path=Path(str(checkpoint)) if checkpoint else None,
         artifact_path=_artifact_path(family, visible_root, item_id, data),
         raw=data,

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

@@ -424,16 +424,14 @@ def _child_log_activity_summary(progress: Mapping[str, object]) -> str:
 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)}")
-    if prompt.agent_count:
-        _emit_info(f"Agents: {prompt.agent_count}")
     _emit_info(f"Spawning AI CLI session: {session_id}")
 
 
 def _pipeline_mode_label(mode: str) -> str:
     labels = {
-        "lite": "lite (Tier 1 — Single Agent)",
-        "standard": "standard (Tier 2 — Main-Agent Review Gates)",
-        "full": "full (Tier 3 — Main-Agent Full Guardrails)",
+        "lite": "lite (Tier 1 — Scoped Guidance)",
+        "standard": "standard (Tier 2 — Review Gates)",
+        "full": "full (Full Guidance)",
     }
     return labels.get(mode, mode)
 

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

@@ -1615,13 +1615,10 @@ def _tier_header(pipeline_mode):
             "The standard label remains metadata only for compatibility.\n",
         ),
         "full": (
-            "# Dev-Pipeline Session Bootstrap — Tier 3 "
-            "(Main-Agent Full Guardrails)\n",
-            "**Tier 3 — Main-Agent Full Guardrails**: For complex "
-            "features, the main orchestrator handles context, planning, and "
-            "implementation directly, then runs mandatory Main-Agent review. "
-            "After convergence, the review skill may use only its strict-gated "
-            "skill-owned independent Reviewer.\n",
+            "# Dev-Pipeline Session Bootstrap — Full Guidance\n",
+            "**Full Guidance**: Follow the active skills and runtime contracts "
+            "for context, planning, implementation, review, testing, recovery, "
+            "and commit.\n",
         ),
     }
     return headers.get(pipeline_mode, headers["lite"])
@@ -1634,8 +1631,8 @@ def _tier_reminders(pipeline_mode):
         "— never skip these",
         "- Build context-snapshot.md FIRST; use it throughout instead of "
         "re-reading files",
-        "- `/prizmkit-committer` is mandatory — do NOT skip the commit phase, "
-        "and do NOT replace it with manual git commit commands",
+        "- `/prizmkit-committer` is mandatory after all required gates pass — "
+        "do NOT replace it with manual git commit commands",
         "- Do NOT run `git add`/`git commit` during implementation phases — "
         "all changes are committed once in the commit phase",
         "- If any files remain after the commit, amend the existing commit — "
@@ -1657,34 +1654,27 @@ def _tier_reminders(pipeline_mode):
             "Code Review writes only review-report.md",
             "- Gate checks require the Implementation Log (with Gate Evidence) "
             "and a valid review-report.md Final Result before proceeding",
-            "- Code Review keeps mandatory Main-Agent ownership; after convergence "
-            "it may use only its strict-gated skill-owned independent Reviewer",
-            "- On timeout outside Code Review: check snapshot + git diff HEAD "
-            "→ model:lite → remaining steps only → max 2 retries per phase → "
-            "Main Agent fallback",
+            "- Follow the active skills and runtime contracts for execution "
+            "units, review ownership, timeout, and recovery",
         ]
     else:  # full
         specific = [
-            "- Tier 3: full orchestration — the Main Agent implements directly "
-            "and owns the mandatory Code Review loop",
+            "- Tier 3: follow the active skills and runtime contracts for "
+            "execution topology and review ownership",
             "- context-snapshot.md is the implementation knowledge base; "
             "Code Review writes only review-report.md",
             "- Gate checks require the Implementation Log and a valid "
             "review-report.md Final Result before proceeding",
-            "- Code Review excludes ordinary work delegation and permits only "
-            "the skill-owned independent Reviewer under its strict structural gate",
-            "- Do NOT use `run_in_background=true` when spawning normal work "
-            "agents outside Code Review",
-            "- If a normal work Agent call fails with team/config/lock errors, "
-            "retry at most once; after a second failure, use the documented "
-            "inline/recovery fallback or write `failure-log.md` rather than "
-            "spawning variants or polling indefinitely",
+            "- Review execution outside the owning skill contract is forbidden",
+            "- Do not infer execution-unit permissions or retry behavior from "
+            "this prompt; use the owning skill/runtime contract",
             "- 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",
+            "- On execution-unit timeout: preserve the active checkout and "
+            "artifacts and follow the owning contract's recovery or downgrade "
+            "path",
         ]
 
     lines = ["## Reminders\n"] + specific + common
@@ -1715,18 +1705,16 @@ def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
         "## Your Mission\n\n"
         "You are the **session orchestrator**. Implement Feature "
         "{{FEATURE_ID}}: \"{{FEATURE_TITLE}}\".\n\n"
-        "**CRITICAL**: You MUST NOT exit until ALL work is complete "
-        "and committed."
+        "**CRITICAL**: Do not exit while recoverable work remains. "
+        "If a required gate is blocked or the workflow cannot safely "
+        "continue, record the blocker and stop with a truthful blocked "
+        "status; do not claim success or commit an incomplete change."
     )
     if pipeline_mode != "lite":
         mission += (
-            " When you spawn normal work subagents, wait for each to finish "
-            "(run_in_background=false)."
-        )
-    if pipeline_mode == "full":
-        mission += (
-            " Do NOT spawn work agents in background and exit — "
-            "that kills the session."
+            " Follow the active skill and runtime contracts for any "
+            "execution units they create, including completion, timeout, "
+            "resume, and failure handling."
         )
     mission += "\n\n" + tier_desc
     sections.append(("mission", mission))
@@ -1753,7 +1741,7 @@ def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
     sections.append(("directory-convention",
                       load_section(sections_dir, dc_file)))
 
-    # --- Subagent Timeout Recovery (only for agent tiers) ---
+    # --- Execution-unit timeout recovery ---
     if pipeline_mode in ("standard", "full"):
         sections.append(("timeout-recovery",
                           load_section(sections_dir,
@@ -2310,14 +2298,11 @@ def main():
 
     # ── Success JSON ───────────────────────────────────────────────────
     feature_model = feature.get("model", "")
-    mode_agent_counts = {"lite": 1, "standard": 3, "full": 3}
-    agent_count = mode_agent_counts.get(pipeline_mode, 1)
     output = {
         "success": True,
         "output_path": os.path.abspath(args.output),
         "model": feature_model,
         "pipeline_mode": pipeline_mode,
-        "agent_count": agent_count,
         "render_mode": "sections" if use_sections else "legacy",
         "validation_warnings": len(warnings),
         "validation_errors": len(errors),

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

@@ -20,7 +20,6 @@ from prompt_framework import (
     generate_checkpoint_from_sections,
     load_section,
     merge_checkpoint_state,
-    mode_agent_count,
     normalize_mode,
     pipeline_checkpoint_metadata,
     read_text_file,
@@ -386,9 +385,9 @@ def render_template(template_content, replacements, bug):
 def _bugfix_header(pipeline_mode):
     title = "# Dev-Pipeline Bug Fix Session Bootstrap — {}\n".format(pipeline_mode.title())
     desc = {
-        "lite": "**Tier 1 — Single Agent**: direct root-cause fix by the main orchestrator.",
-        "standard": "**Tier 2 — Main-Agent Review Gates**: direct implementation with mandatory Main-Agent review and optional strict capability-gated independent correctness review.",
-        "full": "**Tier 3 — Full Bugfix Guardrails**: direct implementation with stronger diagnosis and review gates.",
+        "lite": "**Tier 1 — Scoped Bugfix Guidance**: use the active skills and runtime contracts for diagnosis, implementation, review, and verification.",
+        "standard": "**Tier 2 — Bugfix Review Gates**: use the active skills and runtime contracts for diagnosis, implementation, review, and verification.",
+        "full": "**Tier 3 — Full Bugfix Guardrails**: use the active skills and runtime contracts for diagnosis, implementation, review, recovery, and verification.",
     }.get(pipeline_mode, "**Bugfix pipeline**")
     return title + "\n" + desc + "\n"
 
@@ -574,7 +573,6 @@ def main():
         "checkpoint_path": checkpoint_path,
         "model": bug.get("model", ""),
         "pipeline_mode": pipeline_mode,
-        "agent_count": mode_agent_count(pipeline_mode),
         "render_mode": "sections" if use_sections else "legacy",
         "validation_warnings": len(warnings),
         "validation_errors": len(errors),

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

@@ -97,11 +97,10 @@ Implement the minimal fix (red → green):
         """\
 Verify fix quality:
 1. Run `/prizmkit-code-review` with the current bugfix artifact directory.
-2. Run the mandatory Main-Agent review over the complete current change for up to ten rounds; directly repair accepted findings and verify repairs.
-3. After Main-Agent convergence, allow only the one skill-owned independent Reviewer under the strict structural capability gate. If any capability is unavailable or unproven, record downgrade and create none.
-4. Converge only when accepted and unresolved findings are both zero; missing required evidence or round-ten non-convergence produces NEEDS_FIXES.
-5. Do not invoke another review skill or add review execution outside the skill contract.
-6. `review-report.md` is the only persisted review artifact. Continue only after its last Final Result is valid; preserve append-only progress for recovery.""",
+2. Follow the skill's current review contract for review execution, repairs, verification, evidence, and handoff.
+3. Do not invoke another review skill or add a second review path outside the skill contract.
+4. Continue only after `review-report.md` has a valid last Final Result; preserve append-only progress for recovery.
+5. A missing, incomplete, unsafe, or non-converged review produces NEEDS_FIXES rather than a synthesized pass.""",
     ),
     6: (
         "User Verification",

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

@@ -20,7 +20,6 @@ from prompt_framework import (
     generate_checkpoint_from_sections,
     load_section,
     merge_checkpoint_state,
-    mode_agent_count,
     normalize_mode,
     pipeline_checkpoint_metadata,
     read_text_file,
@@ -410,9 +409,9 @@ def render_template(template_content, replacements, resume_phase, refactor):
 def _refactor_header(pipeline_mode):
     title = "# Dev-Pipeline Refactor Session Bootstrap — {}\n".format(pipeline_mode.title())
     desc = {
-        "lite": "**Tier 1 — Single Agent**: direct behavior-preserving refactor by the main orchestrator.",
-        "standard": "**Tier 2 — Main-Agent Review Gates**: direct refactor with mandatory Main-Agent review and optional strict capability-gated independent correctness review.",
-        "full": "**Tier 3 — Full Refactor Guardrails**: direct refactor with stronger behavior-preservation evidence.",
+        "lite": "**Tier 1 — Scoped Refactor Guidance**: use the active skills and runtime contracts for planning, implementation, review, and behavior verification.",
+        "standard": "**Tier 2 — Refactor Review Gates**: use the active skills and runtime contracts for planning, implementation, review, and behavior verification.",
+        "full": "**Tier 3 — Full Refactor Guardrails**: use the active skills and runtime contracts for planning, implementation, review, recovery, and behavior verification.",
     }.get(pipeline_mode, "**Refactor pipeline**")
     return title + "\n" + desc + "\n"
 
@@ -592,7 +591,6 @@ def main():
         "checkpoint_path": checkpoint_path,
         "model": refactor.get("model", ""),
         "pipeline_mode": pipeline_mode,
-        "agent_count": mode_agent_count(pipeline_mode),
         "render_mode": "sections" if use_sections else "legacy",
         "validation_warnings": len(warnings),
         "validation_errors": len(errors),

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

@@ -117,6 +117,14 @@ def pipeline_checkpoint_metadata(artifact_dir, evidence=None, stage="plan",
                                  blocked_reason=None, terminal_status=None):
     """Build family-neutral semantic L4 metadata without replacing L1 state."""
     evidence = evidence or {}
+    if evidence:
+        evidence_paths = {
+            "manifest": evidence.get("manifest_path"),
+            "verdict": evidence.get("verdict_path"),
+            "validation": evidence.get("validation_path"),
+        }
+    else:
+        evidence_paths = {"manifest": None, "verdict": None, "validation": None}
     current_stage = None if terminal_status else stage
     semantic_next_stage = None if terminal_status else next_stage
     return {
@@ -129,11 +137,7 @@ def pipeline_checkpoint_metadata(artifact_dir, evidence=None, stage="plan",
         "stage_result": stage_result,
         "repair_scope": repair_scope,
         "repair_round": repair_round,
-        "authoritative_evidence_paths": {
-            "manifest": evidence.get("manifest_path"),
-            "verdict": evidence.get("verdict_path"),
-            "validation": evidence.get("validation_path"),
-        },
+        "authoritative_evidence_paths": evidence_paths,
         "next_stage": semantic_next_stage,
         "resume_from": resume_from,
         "blocked_reason": blocked_reason,
@@ -444,11 +448,6 @@ def normalize_mode(value, default="lite"):
     return value if value in {"lite", "standard", "full"} else default
 
 
-def mode_agent_count(pipeline_mode):
-    """Return the prompt metadata agent count for a mode."""
-    return {"lite": 1, "standard": 3, "full": 3}.get(pipeline_mode, 1)
-
-
 def detect_dev_server_port(project_root):
     """Return a detected dev-server port string, or an unknown placeholder."""
     unknown = "<UNKNOWN_DETECT_FROM_PROJECT_CONFIG>"

package/bundled/dev-pipeline/scripts/update-checkpoint.py

@@ -213,6 +213,43 @@ def _checkpoint_project_root(checkpoint_path):
             return str(parent.parent)
     return str(path.parent)
 
+def _discover_test_evidence_paths(checkpoint_path, data):
+    """Discover the latest finalized test package from the artifact handoff pointer."""
+    project_root = Path(_checkpoint_project_root(checkpoint_path))
+    candidates = []
+    artifact_dir = data.get("artifact_dir")
+    if isinstance(artifact_dir, str) and artifact_dir:
+        candidates.append(project_root / artifact_dir)
+    for state_key in ("feature_state", "bugfix_state", "refactor_state"):
+        state = data.get(state_key)
+        if isinstance(state, dict) and isinstance(state.get("artifact_dir"), str):
+            candidates.append(project_root / state["artifact_dir"])
+    item_slug = data.get("item_slug")
+    if isinstance(item_slug, str) and item_slug:
+        candidates.append(project_root / ".prizmkit" / "specs" / item_slug)
+        candidates.append(project_root / ".prizmkit" / "bugfix" / item_slug)
+        candidates.append(project_root / ".prizmkit" / "refactor" / item_slug)
+
+    for artifact in candidates:
+        pointer = artifact / "test-report-path.txt"
+        try:
+            report = Path(pointer.read_text(encoding="utf-8").strip()).resolve()
+        except (OSError, ValueError):
+            continue
+        evidence_dir = report.parent
+        paths = {
+            "manifest": str(evidence_dir / "manifest.json"),
+            "verdict": str(evidence_dir / "verdict.json"),
+            "validation": str(evidence_dir / "validation.json"),
+        }
+        if all(Path(value).is_file() for value in paths.values()):
+            return {
+                key: str(Path(value).relative_to(project_root))
+                for key, value in paths.items()
+            }
+    return None
+
+
 def _finalize_semantics(checkpoint_path, data, state_key):
     """Derive a deterministic terminal status after an atomic mutation."""
     candidate = validate_checkpoint_data(
@@ -286,11 +323,25 @@ def update_checkpoint(
             return {"ok": False, "error": verdict_error}
 
     semantic_update = _normalize_semantic_update(semantic_update)
+    if (
+        semantic_update.get("stage_result") == "TEST_BLOCKED"
+        and not semantic_update.get("authoritative_evidence_paths")
+    ):
+        discovered = _discover_test_evidence_paths(checkpoint_path, data)
+        if discovered:
+            semantic_update["authoritative_evidence_paths"] = discovered
     semantic_error = _validate_semantic_update(step, semantic_update)
     if semantic_error:
         return {"ok": False, "error": semantic_error}
 
     stage_result = semantic_update.get("stage_result")
+    if step.get("skill") == "prizmkit-test" and stage_result in TEST_RESULTS:
+        evidence = semantic_update.get("authoritative_evidence_paths") or step.get("authoritative_evidence_paths")
+        if not isinstance(evidence, dict) or set(evidence) != {"manifest", "verdict", "validation"}:
+            return {
+                "ok": False,
+                "error": "Every terminal test verdict requires manifest, verdict, and validation evidence paths",
+            }
     if new_status == "completed" and step.get("skill") == "prizmkit-code-review":
         stage_result = stage_result or step.get("stage_result")
         if stage_result != "REVIEW_PASS":

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

@@ -20,7 +20,7 @@
 ## Instructions
 
 You are running in **headless non-interactive mode** — no human is available for input.
-Infer what needs to be done from the feature context above and follow the standard dev loop.
+Infer what needs to be done from the feature context above and follow the active skill and runtime contracts. Do not exit while recoverable work remains. If a required gate is blocked or the workflow cannot safely continue, record the blocker and stop with a truthful blocked status; do not claim success or commit an incomplete change.
 
 ### Execution Steps
 
@@ -30,7 +30,7 @@ Infer what needs to be done from the feature context above and follow the standa
 
 3. **Implement**: Run `/prizmkit-implement` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` to execute the plan using TDD (write tests first, then implement).
 
-4. **Review**: Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. Its mandatory Main-Agent loop reviews the complete current change for up to ten internal rounds and directly repairs accepted findings. After convergence, its one skill-owned independent Reviewer is optional only under a strict structural capability gate; otherwise the skill records downgrade and creates none. Require the last `## Final Result`. `REVIEW_PASS` proceeds to test; `REVIEW_NEEDS_FIXES` increments the shared outer repair round and routes implement → code-review → test. Do not invoke another review entry point or add review execution outside the skill contract.
+4. **Review**: Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` and follow the skill's current review contract for review execution, repairs, verification, evidence, and handoff. Require the last `## Final Result`. `REVIEW_PASS` proceeds to test; `REVIEW_NEEDS_FIXES` increments the shared outer repair round and routes implement → code-review → test. Do not invoke another review entry point or add a second review path outside the skill contract.
 
 5. **Test**: After review passes, run `/prizmkit-test scope=this-change artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/`. Treat the Markdown report only as a derived view. Consume `.prizmkit/test/evidence/<evidence-id>/manifest.json`, `verdict.json`, and `validation.json`; verify identity/scope, every manifest hash, verdict/validator agreement, and current target hashes before accepting `TEST_PASS`. `TEST_FAIL/test-infrastructure` routes implement → test; production/runtime/schema/dependency/public-interface routes implement → code-review → test; unknown unsafe scope blocks. `TEST_BLOCKED` allows bounded environment recovery or a test-stage resume but never speculative production edits. Stop outer repairs after three rounds; preserve evidence and truthful recovery metadata.
 
@@ -44,7 +44,7 @@ Infer what needs to be done from the feature context above and follow the standa
 - Remote publication is controlled by the runtime after the local commit; do not make a publication decision in this session.
 - Write all artifacts to `.prizmkit/specs/{{FEATURE_SLUG}}/`.
 - If a step fails after 3 attempts, write a status report and stop.
-- **Never re-read unmodified files**: once you read a file into context, do NOT read it again unless it was modified by an Edit/Write after your last read — use `grep -n`/`sed -n` for specific lines. Before issuing a Read, ask: "Have I read this file before, and has it changed since?" If no — do NOT read it. Normal work delegation outside the optional skill-owned review contract must rely on context-snapshot.md rather than re-reading files the Main Agent already read. Code Review keeps mandatory Main-Agent ownership and may use only its strict-gated skill-owned Reviewer after convergence.
+- **Never re-read unmodified files**: once you read a file into context, do NOT read it again unless it was modified by an Edit/Write after your last read — use `grep -n`/`sed -n` for specific lines. Before issuing a Read, ask: "Have I read this file before, and has it changed since?" If no — do NOT read it. Follow the active skill and runtime contracts when an execution unit is created; do not infer its permissions, continuation, or retry behavior from this fallback prompt.
 - **Read offset safety**: if Read returns "shorter than offset"/"empty" — run `wc -l` then `sed -n`, do NOT retry same offset.
 - **Hard Round Cap**: after 6 total test-fix rounds, STOP trial-and-error. Switch to read-once-then-rewrite. Do NOT exceed 7 rounds.
 - **Layered test**: debug with single-file tests, only run full suite as gate when single-file is green.

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

@@ -1,4 +1,4 @@
-# Dev-Pipeline Session Bootstrap — Tier 3 (Main-Agent Full Guardrails)
+# Dev-Pipeline Session Bootstrap — Full Guidance
 
 ## Session Context
 
@@ -10,15 +10,14 @@
 
 You are the **session orchestrator**. Implement Feature {{FEATURE_ID}}: "{{FEATURE_TITLE}}".
 
-**CRITICAL**: You MUST NOT exit until ALL work is complete and committed. Normal work delegation outside the optional skill-owned review contract must finish before exit (`run_in_background=false`).
+**CRITICAL**: Do not exit while recoverable work remains. If a required gate is blocked or the workflow cannot safely continue, record the blocker and stop with a truthful blocked status; do not claim success or commit an incomplete change.
 
-**Tier 3 — Main-Agent Full Guardrails**: For complex features, the Main Agent handles context, planning, and implementation directly, then runs the mandatory Main-Agent review in `/prizmkit-code-review`. After convergence, that skill may use one skill-owned independent Reviewer only when its strict structural capability gate passes; otherwise it records downgrade and creates none. Do not spawn a top-level Dev implementation subagent.
+**Tier 3 — Full Guardrails**: Follow the active skills and runtime contracts for context loading, planning, implementation, review, testing, recovery, and commit. The active contracts determine the execution topology and permissions for any execution units they create.
 
-**Agent spawn failure policy (all execution-unit creation)**:
-- Code Review must not invoke another review skill/workflow or add review execution outside the single optional Reviewer owned and gated by `prizmkit-code-review`.
-- If the second attempt fails, do not keep spawning variants and do not enter artifact polling for Implementation Log, challenge report, or review report markers.
-- Use the documented inline/recovery fallback for that phase: write the required report yourself where possible, complete remaining work directly in the orchestrator when safe, or write `failure-log.md` with the spawn error and last observable state before stopping for recovery.
-- Apply the same cap to any re-spawn for report repair or resume prompts; do not burn multiple minutes on identical team/config/lock failures.
+**Execution-unit failure policy**:
+- Do not invoke another review skill/workflow or add review execution outside the contract owned by `prizmkit-code-review`.
+- If an execution unit cannot be created or resumed under its owning skill's contract, follow that contract's downgrade or recovery path; do not create an unapproved replacement.
+- Do not enter indefinite polling or repeated retries after the owning contract's retry budget is exhausted.
 
 ### Feature Description
 
@@ -50,9 +49,9 @@ You are running in **headless non-interactive mode** with a FINITE context windo
 
 0. **NON-INTERACTIVE MODE** — There is NO human on the other end. NEVER ask for user confirmation, NEVER wait for user input, NEVER use interactive prompts (e.g. "Would you like me to…"). If a skill has an interactive step (e.g. offer remediation, ask for approval), skip it and proceed autonomously. Make decisions based on the data available and move forward.
 
-1. **context-snapshot.md is your single source of truth** — After Phase 1-2 makes it available, use it instead of re-reading individual source files. If you just created or updated it in this session, continue from the in-context content; read it only when resuming/continuing, after context compaction/loss, or when handing work to a subagent.
+1. **context-snapshot.md is your single source of truth** — After Phase 1-2 makes it available, use it instead of re-reading individual source files. If you just created or updated it in this session, continue from the in-context content; read it only when resuming/continuing, after context compaction/loss, or when handing work to an execution unit.
 2. **Never re-read your own writes** — After you create/modify a file, do NOT read it back to verify. Trust your write was correct.
-3. **Never re-read unmodified files** — Once you have read a file into context, do NOT read it again unless it was modified by an Edit/Write operation after your last read. Use platform file/search tools for targeted lookup; when shell-free helper lookup is needed, run `{{RUNTIME_HELPER_CMD}} text search <file> --pattern "<pattern>" --json`, then read only the smallest bounded range with the platform file-reading tool instead of full-file Read. Before issuing a Read, ask yourself: "Have I read this file before, and has it changed since?" If the answer is "no, it hasn't changed" — do NOT read it. This applies to all files including those summarized in context-snapshot.md Section 4. Normal work delegation outside the optional skill-owned review contract must receive context-snapshot.md and rely on it rather than independently re-reading files the Main Agent already read. Code Review keeps mandatory Main-Agent ownership and may use only its strict-gated skill-owned Reviewer after convergence.
+3. **Never re-read unmodified files** — Once you have read a file into context, do NOT read it again unless it was modified by an Edit/Write operation after your last read. Use platform file/search tools for targeted lookup; when shell-free helper lookup is needed, run `{{RUNTIME_HELPER_CMD}} text search <file> --pattern "<pattern>" --json`, then read only the smallest bounded range with the platform file-reading tool instead of full-file Read. Before issuing a Read, ask yourself: "Have I read this file before, and has it changed since?" If the answer is "no, it hasn't changed" — do NOT read it. This applies to all files including those summarized in context-snapshot.md Section 4. Follow the active skill and runtime contracts when an execution unit is created; do not infer its permissions, continuation, or retry behavior from this bootstrap.
 4. **Stay focused** — Do NOT explore code unrelated to this feature. No curiosity-driven reads.
 4. **One task at a time** — In Phase 4 (implement), complete and test one task before starting the next.
 5. **Minimize tool output** — Never load full command output into context. First capture command output to a temp file using the command/tool output option or the host-appropriate redirection, then inspect only the final relevant lines and use targeted search helpers to extract the information needed for the current task. Only read the filtered result — never the raw full output.
@@ -76,14 +75,13 @@ You are running in **headless non-interactive mode** with a FINITE context windo
 
 ---
 
-## Subagent Timeout Recovery
+## Execution-Unit Timeout Recovery
 
-If any agent times out:
+If an execution unit times out:
 1. `{{RUNTIME_HELPER_CMD}} artifact list .prizmkit/specs/{{FEATURE_SLUG}}` — check what exists
-2. If `context-snapshot.md` exists: open recovery prompt with `"Read .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md for project context and the Implementation Log from previous normal work execution. Run git diff HEAD to see actual code changes already made. Do NOT re-read individual source files unless the File Manifest directs you to."` + only remaining steps + `model: "lite"`
-3. Max 2 retries per phase. After 2 failures, orchestrator completes the work directly and appends a Recovery Note to context-snapshot.md.
-
----
+2. If `context-snapshot.md` exists: open a recovery prompt with `"Read .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md for project context and the Implementation Log from the previous execution. Run git diff HEAD to see actual code changes already made. Do NOT re-read individual source files unless the File Manifest directs you to."` + only remaining steps + `model: "lite"`
+3. Apply the owning skill or runtime contract for retry, native continuation, strict downgrade, or Main-Agent fallback. Do not create an unapproved replacement execution unit.
+4. Do not poll indefinitely after the owning contract's retry budget is exhausted; write `failure-log.md` with the timeout and last observable state when recovery is blocked.
 
 ## Execution
 
@@ -181,7 +179,7 @@ Before proceeding past CP-1, verify:
 
 ### Phase 3: Plan Self-Check — Orchestrator Direct
 
-Do not delegate planning analysis. The current Main Agent performs a bounded self-check before implementation:
+The active planning skill and runtime determine whether any additional planning execution is appropriate. Do not treat this bounded self-check as a substitute for the planning skill's own review contract:
 
 1. Re-read only `context-snapshot.md`, `spec.md`, and `plan.md`.
 2. Cross-check spec.md and plan.md Tasks against the feature description and acceptance criteria.
@@ -191,26 +189,26 @@ Do not delegate planning analysis. The current Main Agent performs a bounded sel
 **CP-2**: Plan self-check complete; no CRITICAL plan issues remain.
 
 
-### Implement — Orchestrator Direct (no Dev subagent)
+### Implement — Plan Execution
 
-**Rationale**: Development is deterministic plan execution — the orchestrator already built full context in Phase 1-2. Spawning a Dev subagent forces it to rebuild context (re-reading files the orchestrator already read), wastes context, and risks worktree double-edit. The orchestrator implements directly.
+Execute the reviewed plan through the active implementation skill. The skill and runtime determine the execution topology; preserve the shared artifact directory, active checkout, and task checkpoints.
 
 Before starting, check plan.md Tasks:
 ```bash
 {{RUNTIME_HELPER_CMD}} text count .prizmkit/specs/{{FEATURE_SLUG}}/plan.md --pattern "- [ ]"
 ```
 - If result is `0` (all tasks already `[x]`) → **SKIP to Review**.
-- If non-zero → implement directly below.
+- If non-zero → execute the remaining tasks below.
 
 **Build artifacts rule**: After any build/compile command, ensure output is in `.gitignore`. Never commit binaries/build output.
 
 **3a.** Run `/prizmkit-implement` directly:
 - Continue from the `spec.md` / `plan.md` / `context-snapshot.md` content you created in Phase 1-2; do not re-read self-authored artifacts just because implementation starts
 - Re-read `plan.md` or `context-snapshot.md` only when resuming/continuing, when current context was compacted or lost, or when task checkbox state may have changed outside this session
-- Implementation remains in the current Main Agent; do not delegate it to a Dev subagent
+- Follow the implementation skill's current execution and delegation contract
 - Use context-snapshot.md Section 4 File Manifest for targeted source reads; avoid re-reading source files already summarized there unless they changed after the snapshot
 - Implements task-by-task, marking each `[x]` immediately
-- Remeber to update checkpoints after finishing a series of tasks
+- Remember to update checkpoints after finishing a series of tasks
 
 **3b. Focused checks only (no test gate here)**:
 - During implementation, do not run mandatory periodic or full-suite tests.
@@ -237,7 +235,7 @@ For each Verification Gate from the Task Contract, write one evidence line to Im
 
 ### Review — Code Review
 
-Review the completed implementation before the full Feature test gate. Run `/prizmkit-code-review artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` in the current Main Agent. The mandatory Main-Agent loop reviews and repairs the complete change for up to ten rounds. After it converges, the skill may use its one skill-owned independent Reviewer only when every strict structural capability is proven; otherwise it records downgrade and creates none. Do not invoke another review skill or add any review execution beyond that skill contract.
+Review the completed implementation before the full Feature test gate. Run `/prizmkit-code-review artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` and follow the skill's current review contract for review execution, repairs, verification, evidence, and handoff. Do not invoke another review skill or add a second review path outside that contract.
 
 - `REVIEW_PASS` → record `stage=code-review`, `status=REVIEW_PASS`, `stage_result=PASS`, `next_stage=prizmkit-test`, and `resume_from=prizmkit-test`; then run the test gate.
 - `REVIEW_NEEDS_FIXES` → increment the shared outer `repair_round` and route `prizmkit-implement` → `prizmkit-code-review` → `prizmkit-test`.
@@ -524,14 +522,14 @@ If you encounter an unrecoverable error, context overflow, or are about to exit
 
 ## Reminders
 
-- Tier 3: orchestrator implements directly; `/prizmkit-code-review` runs mandatory Main-Agent review and optional strict-gated skill-owned independent review
+- Tier 3: orchestrator follows the active skill and runtime contracts; they determine execution topology, review ownership, and delegation boundaries
 - context-snapshot.md contains Main-Agent implementation context; Code Review writes only review-report.md
 - Gate checks require the Implementation Log and a valid review-report.md Final Result before proceeding
-- Review execution outside the skill contract is forbidden; normal work delegation must not use `run_in_background=true`
+- Review execution outside the owning skill contract is forbidden; execution-unit retry and background behavior come from the active skill/runtime contract
 - Commit phase must use `/prizmkit-committer`; do NOT replace with manual git commit commands
 - **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
 - Do NOT run `git add`/`git commit` during Phase 1-5 — all changes are committed once in Phase 6
 - If any files remain after the commit, amend the existing commit — do NOT create a follow-up commit
 - When staging files, always use explicit file names — NEVER use `git add -A` or `git add .`
-- On timeout: check snapshot → model:lite → remaining steps only → max 2 retries → orchestrator fallback
+- On execution-unit timeout: follow the owning skill/runtime contract, preserve the active checkout and artifacts, and record a truthful blocker when recovery is exhausted

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

@@ -11,9 +11,9 @@
 
 You are the **bug fix session agent**. Fix Bug {{BUG_ID}}: "{{BUG_TITLE}}".
 
-**CRITICAL**: You MUST NOT exit until ALL automated work is complete and committed. Manual/hybrid verification labels do not authorize a partial stop: select deterministic local verification tooling and record its evidence.
+**CRITICAL**: Do not exit while recoverable work remains. If a required gate is blocked or the workflow cannot safely continue, record the blocker and stop with a truthful blocked status; do not claim success or commit an incomplete change.
 
-**SUBAGENT LIFECYCLE**: Any normal work subagent must be awaited with `run_in_background=false`. Do not spawn persistent background subagents for headless recovery.
+**Execution model**: Follow the active skills and runtime contracts for planning, implementation, review, recovery, and commit. Those contracts determine the execution topology, permissions, and delegation boundaries.
 
 **NON-INTERACTIVE MODE**: There is NO human on the other end. NEVER ask for user confirmation, NEVER wait for user input. Make decisions autonomously and move forward.
 
@@ -46,7 +46,7 @@ You are the **bug fix session agent**. Fix Bug {{BUG_ID}}: "{{BUG_TITLE}}".
 0. **NON-INTERACTIVE MODE** — NEVER ask for confirmation. Proceed autonomously.
 1. **context-snapshot.md is your single source of truth** — After it is built, read context-snapshot.md instead of re-reading individual source files.
 2. **Never re-read your own writes** — Trust your write was correct.
-3. **Never re-read unmodified files** — Once you have read a file into context, do NOT read it again unless it was modified by an Edit/Write after your last read. Use `grep -n` or `sed -n` for targeted lookups instead of full-file Read. Before issuing a Read, ask: "Have I read this file before, and has it changed since?" If no — do NOT read it. Subagents must rely on context-snapshot.md rather than re-reading files the orchestrator already read.
+3. **Never re-read unmodified files** — Once you read a file into context, do NOT read it again unless it was modified by an Edit/Write after your last read. Use `grep -n` or `sed -n` for targeted lookups instead of full-file Read. Before issuing a Read, ask: "Have I read this file before, and has it changed since?" If no — do NOT read it. Follow the active skill and runtime contracts when an execution unit is created; do not infer its permissions, continuation, or retry behavior from this bootstrap.
 4. **Stay focused** — Do NOT explore code unrelated to this bug.
 4. **Minimize tool output** — Capture to temp file, scan head/tail, filter with grep/sed/awk. Never load full output.
 5. **No intermediate commits** — All changes committed once at the end via `/prizmkit-committer`.
@@ -315,7 +315,8 @@ Write to: `{{SESSION_STATUS_PATH}}`
 
 ## Reminders
 
-- Use L1 Skills: `/prizmkit-plan`, `/prizmkit-implement`, `/prizmkit-code-review`, `/prizmkit-committer`, `/prizmkit-retrospective`
+- Follow the active skills and runtime contracts; they determine execution topology, review ownership, and delegation boundaries
+- On execution-unit timeout, preserve the active checkout and artifacts and follow the owning contract's recovery or downgrade path
 - All skills use `artifact_dir=.prizmkit/bugfix/{{BUG_ID}}/`
 - plan.md first task MUST be reproduction test (RED → GREEN TDD)
 - Commit with `fix(<scope>):` prefix, NOT `feat:`

package/bundled/dev-pipeline/templates/feature-list-schema.json

@@ -75,7 +75,7 @@
               "high",
               "critical"
             ],
-            "description": "Estimated implementation complexity. Determines pipeline execution tier: low/medium → lite (single agent), high → standard (orchestrator + reviewer), critical → full (orchestrator + stronger guardrails)."
+            "description": "Estimated implementation complexity. Determines prompt depth and guardrails: low/medium → lite, high → standard, critical → full. Execution topology is defined by the active skills and runtime, not by this field."
           },
           "dependencies": {
             "type": "array",

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

@@ -17,7 +17,7 @@ You are the **refactor session orchestrator**. Execute Refactor {{REFACTOR_ID}}:
 
 **NON-INTERACTIVE MODE**: You are running in headless non-interactive mode. There is NO human on the other end. NEVER ask for user confirmation, NEVER wait for user input, and NEVER use interactive prompts. Resolve uncertainty from existing code, project docs, and conservative behavior-preserving defaults.
 
-**MAIN-AGENT-DIRECT RULE**: Do not spawn a top-level Dev implementation subagent. The Main Agent plans, implements via `/prizmkit-implement`, and runs `/prizmkit-code-review` directly without direct or indirect review delegation.
+**Execution model**: Follow the active skills and runtime contracts for planning, implementation, review, recovery, and commit. Those contracts determine the execution topology, permissions, and delegation boundaries.
 
 **REFACTOR DOCUMENTATION POLICY**:
 - Default: run `/prizmkit-retrospective` with full sync because refactoring changes structure and interfaces.
@@ -267,7 +267,8 @@ Before exiting, write `{{SESSION_STATUS_PATH}}`:
 ## Reminders
 
 - Use L1 skills: `/prizmkit-plan`, `/prizmkit-implement`, `/prizmkit-code-review`, `/prizmkit-retrospective`, `/prizmkit-committer`.
-- Do not spawn a top-level Dev implementation subagent; Code Review keeps mandatory Main-Agent ownership and may use only its strict-gated skill-owned Reviewer after convergence.
+- Follow the active skills and runtime contracts; they determine execution topology, review ownership, and delegation boundaries
+- On execution-unit timeout, preserve the active checkout and artifacts and follow the owning contract's recovery or downgrade path
 - Behavior preservation is the first priority.
 - Browser verification is a mandatory attempt by default; it blocks only when explicitly required.
 - If `DEV_PORT` is unknown, discover it from project config; do not guess port 3000.