prizmkit 1.1.8 → 1.1.9

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

@@ -1,18 +1,20 @@
 #!/usr/bin/env python3
 """Core state machine for updating refactor status in the refactor pipeline.
 
-Handles six actions:
+Handles eight actions:
   - get_next: Find the next refactor to process based on dependency order, priority, complexity
+  - start: Mark a refactor as in_progress when a session starts
   - update: Update a refactor's status based on session outcome
   - status: Print a formatted overview of all refactors
   - pause: Save pipeline state for graceful shutdown
   - reset: Reset a refactor to pending (status + retry count)
   - clean: Reset + delete session history + delete refactor artifacts
+  - unskip: Reset skipped refactors and their downstream dependents back to pending
 
 Usage:
     python3 update-refactor-status.py \
         --refactor-list <path> --state-dir <path> \
-        --action <get_next|update|status|pause|reset|clean> \
+        --action <get_next|start|update|status|pause|reset|clean|unskip> \
         [--refactor-id <id>] [--session-status <status>] \
         [--session-id <id>] [--max-retries <n>]
 """
@@ -21,6 +23,7 @@ import argparse
 import json
 import os
 import shutil
+import sys
 from datetime import datetime, timezone
 
 from utils import (
@@ -39,10 +42,12 @@ SESSION_STATUS_VALUES = [
     "failed",
     "crashed",
     "timed_out",
+    "commit_missing",
+    "docs_missing",
     "merge_conflict",
 ]
 
-TERMINAL_STATUSES = {"completed", "failed", "skipped"}
+TERMINAL_STATUSES = {"completed", "failed", "skipped", "auto_skipped"}
 
 # Artifact directory names (relative to project root)
 REFACTOR_ARTIFACTS_REL = os.path.join(".prizmkit", "refactor")
@@ -72,7 +77,7 @@ def parse_args():
     parser.add_argument("--state-dir", required=True, help="Path to the state directory (default: .prizmkit/state/refactor)")
     parser.add_argument(
         "--action", required=True,
-        choices=["get_next", "update", "status", "pause", "reset", "clean"],
+        choices=["get_next", "start", "update", "status", "pause", "reset", "clean", "unskip", "complete"],
         help="Action to perform",
     )
     parser.add_argument("--refactor-id", default=None, help="Refactor ID (required for 'update'/'reset'/'clean' actions)")
@@ -272,16 +277,23 @@ def action_update(args, refactor_list_path, state_dir):
         if err:
             error_out("Failed to update .prizmkit/plans/refactor-list.json: {}".format(err))
             return
-    elif session_status == "merge_conflict":
+    elif session_status in ("commit_missing", "docs_missing", "merge_conflict"):
+        # Degraded outcome: keep artifacts for retry.
+        # Write schema-valid status to refactor-list.json ("pending" for retry,
+        # "failed" if max retries exceeded). Store the granular degraded reason
+        # in status.json only (internal pipeline state, not schema-bound).
         rs["retry_count"] = rs.get("retry_count", 0) + 1
 
         if rs["retry_count"] >= max_retries:
             rs["status"] = "failed"
             target_status = "failed"
         else:
-            rs["status"] = "merge_conflict"
-            target_status = "merge_conflict"
+            # status.json keeps the granular degraded reason for diagnostics
+            rs["status"] = session_status
+            # refactor-list.json gets schema-valid "pending" (will be retried)
+            target_status = "pending"
 
+        rs["degraded_reason"] = session_status
         rs["resume_from_phase"] = None
         rs["sessions"] = []
         rs["last_session_id"] = None
@@ -329,6 +341,13 @@ def action_update(args, refactor_list_path, state_dir):
         error_out("Failed to save refactor status: {}".format(err))
         return
 
+    # Auto-skip downstream refactors when this refactor is marked as failed or skipped
+    auto_skipped_refactors = []
+    if rs["status"] in ("failed", "skipped"):
+        auto_skipped_refactors = auto_skip_blocked_refactors(
+            refactor_list_path, state_dir, refactor_id
+        )
+
     summary = {
         "action": "update",
         "refactor_id": refactor_id,
@@ -338,8 +357,10 @@ def action_update(args, refactor_list_path, state_dir):
         "resume_from_phase": rs.get("resume_from_phase"),
         "updated_at": rs["updated_at"],
     }
-    if session_status == "merge_conflict":
-        summary["degraded_reason"] = "merge_conflict"
+    if auto_skipped_refactors:
+        summary["auto_skipped"] = [info["refactor_id"] for info in auto_skipped_refactors]
+    if session_status in ("commit_missing", "docs_missing", "merge_conflict"):
+        summary["degraded_reason"] = session_status
         summary["restart_policy"] = "finalization_retry"
     elif session_status != "success":
         summary["restart_policy"] = "full_restart"
@@ -410,6 +431,116 @@ def load_session_status(state_dir, refactor_id, session_id):
     return data, None
 
 
+# ---------------------------------------------------------------------------
+# Auto-skip: cascade failure to blocked downstream refactors
+# ---------------------------------------------------------------------------
+
+def auto_skip_blocked_refactors(refactor_list_path, state_dir, failed_refactor_id):
+    """Recursively mark all downstream refactors blocked by a failed refactor as auto_skipped.
+
+    When a refactor is marked as failed, any refactor whose dependency chain includes
+    the failed refactor can never be executed. This function propagates the failure
+    by marking those blocked refactors as auto_skipped, allowing the pipeline to
+    continue processing unblocked refactors and eventually reach PIPELINE_COMPLETE.
+
+    Re-reads .prizmkit/plans/refactor-list.json from disk to get the latest state (including the
+    just-written failed status from update_refactor_in_list).
+
+    NOTE: This function performs a read-modify-write on .prizmkit/plans/refactor-list.json without
+    file locking. The caller (action_update) also writes to .prizmkit/plans/refactor-list.json
+    immediately before calling this. Safe for single-pipeline execution, but if
+    multiple pipeline instances share the same .prizmkit/plans/refactor-list.json concurrently,
+    a race condition may cause lost writes. Add file locking if parallel pipelines
+    are introduced.
+    """
+    data, err = load_json_file(refactor_list_path)
+    if err:
+        return []
+    refactors = data.get("refactors", [])
+
+    # Build current status map
+    status_map = {}
+    for r in refactors:
+        if isinstance(r, dict) and r.get("id"):
+            status_map[r["id"]] = r.get("status", "pending")
+
+    # Collect all refactors to auto-skip (recursive propagation)
+    to_skip = set()
+    changed = True
+    while changed:
+        changed = False
+        for r in refactors:
+            if not isinstance(r, dict):
+                continue
+            rid = r.get("id")
+            if not rid or rid in to_skip:
+                continue
+            current = status_map.get(rid, "pending")
+            if current in TERMINAL_STATUSES:
+                continue
+            deps = r.get("dependencies", [])
+            for dep_id in deps:
+                dep_status = status_map.get(dep_id, "pending")
+                if dep_status in ("failed", "skipped", "auto_skipped") or dep_id in to_skip:
+                    to_skip.add(rid)
+                    status_map[rid] = "auto_skipped"
+                    changed = True
+                    break
+
+    if not to_skip:
+        return []
+
+    # Batch-write to .prizmkit/plans/refactor-list.json
+    for r in refactors:
+        if isinstance(r, dict) and r.get("id") in to_skip:
+            r["status"] = "auto_skipped"
+    write_json_file(refactor_list_path, data)
+
+    # Sync status.json for each auto-skipped refactor
+    for rid in to_skip:
+        rs = load_refactor_status(state_dir, rid)
+        rs["status"] = "auto_skipped"
+        rs["updated_at"] = now_iso()
+        save_refactor_status(state_dir, rid, rs)
+
+    # Build blocking reason map for logging
+    skipped_info = []
+    for r in refactors:
+        if not isinstance(r, dict):
+            continue
+        rid = r.get("id")
+        if rid not in to_skip:
+            continue
+        deps = r.get("dependencies", [])
+        blockers = [
+            d for d in deps
+            if d == failed_refactor_id or d in to_skip
+        ]
+        skipped_info.append({
+            "refactor_id": rid,
+            "title": r.get("title", ""),
+            "blocked_by": blockers,
+        })
+
+    print(
+        "[auto-skip] {} refactor(s) auto-skipped due to failed {}:".format(
+            len(skipped_info), failed_refactor_id
+        ),
+        file=sys.stderr,
+    )
+    for info in skipped_info:
+        print(
+            "  {} ({}) — blocked by {}".format(
+                info["refactor_id"],
+                info["title"],
+                ", ".join(info["blocked_by"]),
+            ),
+            file=sys.stderr,
+        )
+
+    return skipped_info
+
+
 # ---------------------------------------------------------------------------
 # Action: status
 # ---------------------------------------------------------------------------
@@ -445,7 +576,7 @@ def action_status(refactor_list_data, state_dir):
     refactors = refactor_list_data.get("refactors", [])
     project_name = refactor_list_data.get("project_name", "Unknown")
 
-    counts = {"completed": 0, "in_progress": 0, "failed": 0, "pending": 0, "skipped": 0}
+    counts = {"completed": 0, "in_progress": 0, "failed": 0, "pending": 0, "skipped": 0, "auto_skipped": 0}
     refactor_lines = []
 
     for r in refactors:
@@ -478,6 +609,8 @@ def action_status(refactor_list_data, state_dir):
             icon = COLOR_RED + "[✗]" + COLOR_RESET
         elif rstatus == "skipped":
             icon = COLOR_GRAY + "[—]" + COLOR_RESET
+        elif rstatus == "auto_skipped":
+            icon = COLOR_GRAY + "[⊘]" + COLOR_RESET
         else:
             icon = COLOR_GRAY + "[ ]" + COLOR_RESET
 
@@ -525,8 +658,8 @@ def action_status(refactor_list_data, state_dir):
     summary_line = "Total: {} refactors | Completed: {} | In Progress: {}".format(
         total, completed, counts["in_progress"]
     )
-    summary_line2 = "Failed: {} | Pending: {} | Skipped: {}".format(
-        counts["failed"], counts["pending"], counts["skipped"]
+    summary_line2 = "Failed: {} | Pending: {} | Skipped: {} | Auto-skipped: {}".format(
+        counts["failed"], counts["pending"], counts["skipped"], counts["auto_skipped"]
     )
 
     inner = BOX_WIDTH - 2
@@ -685,6 +818,195 @@ def action_pause(state_dir):
     print(json.dumps(result, indent=2, ensure_ascii=False))
 
 
+# ---------------------------------------------------------------------------
+# Action: start
+# ---------------------------------------------------------------------------
+
+def action_start(args, refactor_list_path, state_dir):
+    """Mark a refactor as in_progress when a session starts.
+
+    This keeps refactor-list.json/state status in sync during execution,
+    instead of only updating after session end.
+    """
+    refactor_id = args.refactor_id
+    if not refactor_id:
+        error_out("--refactor-id is required for 'start' action")
+        return
+
+    rs = load_refactor_status(state_dir, refactor_id)
+    old_status = rs.get("status", "pending")
+
+    rs["status"] = "in_progress"
+    rs["updated_at"] = now_iso()
+
+    err = save_refactor_status(state_dir, refactor_id, rs)
+    if err:
+        error_out("Failed to save refactor status: {}".format(err))
+        return
+
+    err = update_refactor_in_list(refactor_list_path, refactor_id, "in_progress")
+    if err:
+        error_out("Failed to update .prizmkit/plans/refactor-list.json: {}".format(err))
+        return
+
+    result = {
+        "action": "start",
+        "refactor_id": refactor_id,
+        "old_status": old_status,
+        "new_status": "in_progress",
+        "updated_at": rs["updated_at"],
+    }
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+# ---------------------------------------------------------------------------
+# Action: unskip
+# ---------------------------------------------------------------------------
+
+def action_unskip(args, refactor_list_path, state_dir):
+    """Recover skipped/auto_skipped/failed refactors by resetting them and their failed upstream.
+
+    Two modes:
+    - --refactor-id R-001: Reset the specified failed/skipped/auto_skipped refactor + all
+      downstream auto_skipped refactors whose dependency chain includes it.
+      If the target is auto_skipped, also walk upstream to find and reset the
+      failed/skipped ancestor that caused the cascade.
+    - No --refactor-id: Reset ALL failed, skipped, and auto_skipped refactors to pending.
+    """
+    refactor_id = args.refactor_id
+
+    data, err = load_json_file(refactor_list_path)
+    if err:
+        error_out("Cannot load refactor list: {}".format(err))
+        return
+    refactors = data.get("refactors", [])
+
+    to_reset = set()
+
+    if refactor_id:
+        # Find the target refactor
+        target = None
+        for r in refactors:
+            if isinstance(r, dict) and r.get("id") == refactor_id:
+                target = r
+                break
+        if not target:
+            error_out("Refactor '{}' not found in .prizmkit/plans/refactor-list.json".format(refactor_id))
+            return
+        if target.get("status") not in ("failed", "skipped", "auto_skipped"):
+            error_out(
+                "Refactor '{}' has status '{}', expected 'failed', 'skipped', or 'auto_skipped'".format(
+                    refactor_id, target.get("status", "unknown")
+                )
+            )
+            return
+
+        # If target is failed or skipped, reset it and find all auto_skipped descendants
+        if target.get("status") in ("failed", "skipped"):
+            to_reset.add(refactor_id)
+            # Find all auto_skipped refactors that depend (transitively) on this one
+            changed = True
+            while changed:
+                changed = False
+                for r in refactors:
+                    if not isinstance(r, dict):
+                        continue
+                    rid = r.get("id")
+                    if not rid or rid in to_reset:
+                        continue
+                    if r.get("status") != "auto_skipped":
+                        continue
+                    deps = r.get("dependencies", [])
+                    if any(d in to_reset for d in deps):
+                        to_reset.add(rid)
+                        changed = True
+
+        # If target is auto_skipped, reset it and its failed upstream + siblings
+        elif target.get("status") == "auto_skipped":
+            to_reset.add(refactor_id)
+            # Transitively walk upstream to find ALL failed/auto_skipped ancestors
+            # (e.g., R-001 failed → R-002 auto_skipped → R-003 auto_skipped;
+            #  unskip R-003 must also find and reset R-001)
+            upstream_changed = True
+            while upstream_changed:
+                upstream_changed = False
+                for r in refactors:
+                    if not isinstance(r, dict):
+                        continue
+                    rid = r.get("id")
+                    if not rid or rid not in to_reset:
+                        continue
+                    for dep_id in r.get("dependencies", []):
+                        if dep_id in to_reset:
+                            continue
+                        for dep_r in refactors:
+                            if isinstance(dep_r, dict) and dep_r.get("id") == dep_id:
+                                if dep_r.get("status") in ("failed", "skipped", "auto_skipped"):
+                                    to_reset.add(dep_id)
+                                    upstream_changed = True
+            # Also reset downstream auto_skipped refactors blocked by the same upstreams
+            changed = True
+            while changed:
+                changed = False
+                for r in refactors:
+                    if not isinstance(r, dict):
+                        continue
+                    rid = r.get("id")
+                    if not rid or rid in to_reset:
+                        continue
+                    if r.get("status") != "auto_skipped":
+                        continue
+                    rdeps = r.get("dependencies", [])
+                    if any(d in to_reset for d in rdeps):
+                        to_reset.add(rid)
+                        changed = True
+    else:
+        # No refactor-id: reset ALL failed + skipped + auto_skipped
+        for r in refactors:
+            if isinstance(r, dict) and r.get("id"):
+                if r.get("status") in ("failed", "skipped", "auto_skipped"):
+                    to_reset.add(r["id"])
+
+    if not to_reset:
+        error_out("No refactors to unskip")
+        return
+
+    # Reset all collected refactors in refactor-list.json
+    reset_details = []
+    for r in refactors:
+        if isinstance(r, dict) and r.get("id") in to_reset:
+            old_status = r.get("status", "unknown")
+            r["status"] = "pending"
+            reset_details.append({
+                "refactor_id": r["id"],
+                "title": r.get("title", ""),
+                "old_status": old_status,
+            })
+
+    err = write_json_file(refactor_list_path, data)
+    if err:
+        error_out("Failed to write .prizmkit/plans/refactor-list.json: {}".format(err))
+        return
+
+    # Reset status.json for each refactor
+    for rid in to_reset:
+        rs = load_refactor_status(state_dir, rid)
+        rs["status"] = "pending"
+        rs["retry_count"] = 0
+        rs["sessions"] = []
+        rs["last_session_id"] = None
+        rs["resume_from_phase"] = None
+        rs["updated_at"] = now_iso()
+        save_refactor_status(state_dir, rid, rs)
+
+    result = {
+        "action": "unskip",
+        "reset_count": len(to_reset),
+        "refactors": reset_details,
+    }
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
 # ---------------------------------------------------------------------------
 # Main
 # ---------------------------------------------------------------------------
@@ -697,7 +1019,7 @@ def main():
             error_out("--refactor-id is required for 'update' action")
         if not args.session_status:
             error_out("--session-status is required for 'update' action")
-    if args.action in ("reset", "clean"):
+    if args.action in ("start", "reset", "clean", "complete"):
         if not args.refactor_id:
             error_out("--refactor-id is required for '{}' action".format(args.action))
     if args.action == "clean":
@@ -718,8 +1040,16 @@ def main():
         action_reset(args, args.refactor_list, args.state_dir)
     elif args.action == "clean":
         action_clean(args, args.refactor_list, args.state_dir)
+    elif args.action == "start":
+        action_start(args, args.refactor_list, args.state_dir)
     elif args.action == "pause":
         action_pause(args.state_dir)
+    elif args.action == "unskip":
+        action_unskip(args, args.refactor_list, args.state_dir)
+    elif args.action == "complete":
+        # Shortcut: 'complete' is equivalent to 'update --session-status success'
+        args.session_status = "success"
+        action_update(args, args.refactor_list, args.state_dir)
 
 
 if __name__ == "__main__":

package/bundled/dev-pipeline/templates/agent-prompts/dev-fix.md

@@ -1,5 +1,5 @@
 "Read {{DEV_SUBAGENT_PATH}}. Fix NEEDS_FIXES issues for feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}).
-1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` — '## Review Notes' section contains structured Fix Instructions with exact steps.
+1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/review-report.md` — contains structured Fix Instructions with exact steps.
 2. Follow Fix Instructions in order (respect Depends On / Blocks dependencies). Each FIX-N has: Root Cause, Fix Strategy, Code Guidance, and Verification criteria.
 3. After each fix, run the Verification command listed in that FIX-N to confirm it works.
 4. Run `{{TEST_CMD}}` to verify no regressions.

package/bundled/dev-pipeline/templates/agent-prompts/reviewer-review.md

@@ -1,12 +1,8 @@
 "Read {{REVIEWER_SUBAGENT_PATH}}. For feature {{FEATURE_ID}} (slug: {{FEATURE_SLUG}}):
-**IMPORTANT**: Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` FIRST.
-1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md`:
-   - Section 3: Prizm Context (RULES, PATTERNS to check against)
-   - Section 4: File Manifest (original file structure)
-   - '## Implementation Log': what Dev changed, key decisions, discoveries
-   - '## Acceptance Criteria Verification Checklist': verify all items are [x]
-2. **AC Verification Gate**: Check that AC Verification Checklist shows ALL criteria marked [x]. If any [ ] remains, return verdict NEEDS_FIXES with message "AC Verification incomplete: [list unmet criteria]"
-3. Run prizmkit-code-review (both phases): Phase 1 diagnostic review (spec compliance, code quality, correctness), then Phase 2 fix strategy formulation for any findings. Read ONLY files listed in Implementation Log for diagnosis; MAY read additional files for impact analysis.
-4. Run the full test suite using `{{TEST_CMD}}` — **ONLY if the Implementation Log does not already confirm all tests passing**. If Implementation Log states tests passed, trust it and skip the re-run. When running tests: `{{TEST_CMD}} 2>&1 | tee /tmp/review-test-out.txt | tail -20`, then grep `/tmp/review-test-out.txt` for details — do NOT re-run the suite multiple times. Write and execute integration tests covering all user stories from spec.md.
-5. Write structured '## Review Notes' to context-snapshot.md with Fix Instructions (Root Cause, Impact, Fix Strategy, Code Guidance, Verification for each finding) and Re-Review Expectations.
-Report verdict: PASS, PASS_WITH_WARNINGS, or NEEDS_FIXES."
+1. Read `.prizmkit/specs/{{FEATURE_SLUG}}/spec.md` (if it exists) for goals and acceptance criteria; if spec.md does not exist, read `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md` Section 1 instead
+2. Read `.prizmkit/specs/{{FEATURE_SLUG}}/plan.md` for architecture decisions and completed tasks
+3. Read `.prizm-docs/root.prizm` and relevant L1/L2 docs for RULES, PATTERNS, TRAPS
+4. Run /prizmkit-code-review with artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/: Phase 1 diagnostic review across all applicable dimensions, then Phase 2 fix strategy for any findings. Read ONLY files referenced in completed plan.md tasks for diagnosis; MAY read additional files for impact analysis.
+5. Run the full test suite using `{{TEST_CMD}}`. When running tests: `{{TEST_CMD}} 2>&1 | tee /tmp/review-test-out.txt | tail -20`, then grep `/tmp/review-test-out.txt` for details — do NOT re-run the suite multiple times. Write and execute integration tests covering all goals from spec.md.
+6. review-report.md will be written to .prizmkit/specs/{{FEATURE_SLUG}}/ by prizmkit-code-review.
+Report: number of findings found, or 'no findings' if clean."

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

@@ -1,10 +1,44 @@
-# DEPRECATED — bootstrap-prompt.md
+# Dev-Pipeline Fallback Bootstrap Prompt
 
-This file has been replaced by tier-specific templates:
+> **Note**: This is an emergency fallback template. Normally, `generate-bootstrap-prompt.py`
+> selects a tier-specific template (`bootstrap-tier1.md`, `bootstrap-tier2.md`, or `bootstrap-tier3.md`).
+> If you are seeing this prompt, the tier-specific templates were not found.
 
-- `bootstrap-tier1.md` — Tier 1: Single Agent (complexity: low)
-- `bootstrap-tier2.md` — Tier 2: Dual Agent (complexity: medium)
-- `bootstrap-tier3.md` — Tier 3: Full Team (complexity: high)
+## Feature Context
 
-`generate-bootstrap-prompt.py` selects the correct file automatically based on `estimated_complexity`.
-This file is kept as a fallback only — if none of the tier files exist, the script falls back to this path.
+- **Feature ID**: {{FEATURE_ID}}
+- **Title**: {{FEATURE_TITLE}}
+- **Description**: {{FEATURE_DESCRIPTION}}
+- **Slug**: {{FEATURE_SLUG}}
+
+### Acceptance Criteria
+
+{{ACCEPTANCE_CRITERIA}}
+
+## 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.
+
+### Execution Steps
+
+1. **Read context**: Read `.prizm-docs/root.prizm` and relevant L1/L2 docs to understand the codebase.
+
+2. **Plan**: Run `/prizmkit-plan` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` to produce `spec.md` and `plan.md`.
+
+3. **Implement**: Run `/prizmkit-implement` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` to execute the plan using TDD (write tests first, then implement).
+
+4. **Test**: Run the project test suite to verify all tests pass with no regressions.
+
+5. **Review**: Run `/prizmkit-code-review` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` to review changes against the spec. If findings exist, fix them and re-review (max 2 rounds).
+
+6. **Retrospective**: Run `/prizmkit-retrospective` to sync `.prizm-docs/` with code changes.
+
+7. **Commit**: Run `/prizmkit-committer` to commit all changes. Do NOT push.
+
+### Critical Rules
+
+- Do NOT ask for user input — decide autonomously.
+- Do NOT push to remote — the user will push manually.
+- Write all artifacts to `.prizmkit/specs/{{FEATURE_SLUG}}/`.
+- If a step fails after 3 attempts, write a status report and stop.

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

@@ -39,7 +39,9 @@ You are the **session orchestrator**. Implement Feature {{FEATURE_ID}}: "{{FEATU
 
 ## ⚠️ Context Budget Rules (CRITICAL — read before any phase)
 
-You are running in headless mode with a FINITE context window. Exceeding it will crash the session and lose all work. Follow these rules strictly:
+You are running in **headless non-interactive mode** with a FINITE context window. Exceeding it will crash the session and lose all work. Follow these rules strictly:
+
+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 builds it, ALWAYS read context-snapshot.md instead of re-reading individual source files
 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.
@@ -232,7 +234,7 @@ You just implemented this feature — you know the project's tech stack and buil
 3. **Assess and record** — append to context-snapshot.md:
    - **ALL builds pass** → `## Deploy Verification: PASS` — proceed to commit
    - **Some builds fail with fixable errors** → fix and re-verify (already handled in step 2)
-   - **Cannot build locally** (missing system-level deps you cannot install) → Generate `DEPLOY.md` with:
+   - **Cannot build locally** (missing system-level deps you cannot install) → Generate `.prizmkit/deploy.md` with:
      ```
      # Local Development Setup
 
@@ -248,7 +250,7 @@ You just implemented this feature — you know the project's tech stack and buil
      ## Verify
      [how to confirm the app is running correctly]
      ```
-     Record: `## Deploy Verification: PARTIAL — see DEPLOY.md for missing prerequisites`
+     Record: `## Deploy Verification: PARTIAL — see .prizmkit/deploy.md for missing prerequisites`
 
 Deploy verification does NOT block the commit, but you MUST attempt it.
 
@@ -289,6 +291,28 @@ Working tree MUST be clean after this step. If any feature-related files remain,
 
 **Exception**: `session-summary.md` in the artifact directory is a local cross-session artifact generated by `/prizmkit-committer` — it is NOT committed to git. Ignore it in the clean-tree check.
 
+**4e.** Write completion summary for downstream dependency context:
+
+Write `.prizmkit/specs/{{FEATURE_SLUG}}/completion-summary.json` with the key changes from this session. This file is NOT committed to git — the pipeline runner reads it to propagate context to dependent features.
+
+```json
+{
+  "completion_notes": [
+    "<each item: one key change, API, model, or integration point that downstream features may need>",
+    "Example: Added User model (id, email, password_hash, display_name) in prisma/schema.prisma",
+    "Example: POST /api/auth/register and POST /api/auth/login endpoints in src/api/auth.ts",
+    "Example: Auth middleware in src/middleware/auth.ts — validates JWT on protected routes"
+  ]
+}
+```
+
+Rules for writing completion notes:
+- Focus on **what downstream features need to know**: new APIs, models, exported functions, key file paths
+- Each note should be self-contained and concise (one line, under 120 characters preferred)
+- Include 3-8 notes covering the most important changes
+- Do NOT include test files, config changes, or internal implementation details unless they affect other features
+- If this feature has no downstream dependents, still write the summary (it serves as documentation)
+
 ## Critical Paths
 
 | Resource | Path |