prizmkit 1.0.147 → 1.0.149

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.0.147",
-  "bundledAt": "2026-03-30T17:09:52.213Z",
-  "bundledFrom": "4cdb143"
+  "frameworkVersion": "1.0.149",
+  "bundledAt": "2026-03-31T17:50:05.806Z",
+  "bundledFrom": "9c1abf7"
 }

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

@@ -103,8 +103,9 @@ export async function installCommand(corePath, targetRoot) {
   const hasAssets = existsSync(path.join(corePath, 'assets'));
   const hasScripts = existsSync(path.join(corePath, 'scripts'));
   const hasRules = existsSync(path.join(corePath, 'rules'));
+  const hasReferences = existsSync(path.join(corePath, 'references'));
 
-  if (hasAssets || hasScripts || hasRules) {
+  if (hasAssets || hasScripts || hasRules || hasReferences) {
     // Use directory structure for commands with resources
     const targetDir = path.join(targetRoot, COMMANDS_DIR, skillName);
     mkdirSync(targetDir, { recursive: true });
@@ -118,7 +119,7 @@ export async function installCommand(corePath, targetRoot) {
     }
 
     // Copy assets and scripts
-    for (const subdir of ['scripts', 'assets', 'rules']) {
+    for (const subdir of ['scripts', 'assets', 'rules', 'references']) {
       const srcSubdir = path.join(corePath, subdir);
       if (existsSync(srcSubdir)) {
         cpSync(srcSubdir, path.join(targetDir, subdir), { recursive: true });

package/bundled/dev-pipeline/run.sh

@@ -938,10 +938,28 @@ for f in data.get('stuck_features', []):
         if [[ "$next_feature" == "PIPELINE_COMPLETE" ]]; then
             echo ""
             log_success "════════════════════════════════════════════════════"
-            log_success "  All features completed! Pipeline finished."
+            log_success "  Pipeline finished."
             log_success "  Total sessions: $session_count"
             log_success "  Total subagent calls: $total_subagent_calls"
             log_success "════════════════════════════════════════════════════"
+
+            # Check for auto-skipped features
+            local auto_skipped_count
+            auto_skipped_count=$(python3 -c "
+import json, sys
+with open(sys.argv[1]) as f:
+    data = json.load(f)
+count = sum(1 for f in data.get('features', []) if f.get('status') == 'auto_skipped')
+print(count)
+" "$feature_list" 2>/dev/null || echo "0")
+
+            if [[ "$auto_skipped_count" -gt 0 ]]; then
+                echo ""
+                log_warn "$auto_skipped_count feature(s) were auto-skipped due to failed dependencies."
+                log_warn "Run './run.sh status' to see details."
+                log_warn "Run './run.sh unskip' to reset and retry them."
+            fi
+
             break
         fi
 
@@ -1093,6 +1111,7 @@ show_help() {
     echo "  run [feature-list.json] [--features <filter>]  Run features (all or filtered subset)"
     echo "  run <feature-id> [options]              Run a single feature"
     echo "  status [feature-list.json]               Show pipeline status"
+    echo "  unskip [feature-id] [feature-list.json]  Reset auto-skipped/failed features"
     echo "  test-cli                                 Test AI CLI: show detected CLI, version, and model"
     echo "  reset                                    Clear all state and start fresh"
     echo "  help                                     Show this help message"
@@ -1244,6 +1263,40 @@ case "${1:-run}" in
         rm -rf "$STATE_DIR"
         log_success "State cleared. Run './run.sh run' to start fresh."
         ;;
+    unskip)
+        check_dependencies
+        if [[ ! -f "$STATE_DIR/pipeline.json" ]]; then
+            log_error "No pipeline state found. Run './run.sh run' first."
+            exit 1
+        fi
+        _unskip_feature_list="feature-list.json"
+        _unskip_feature_id=""
+        shift || true
+        # Parse arguments: optional feature-id and feature-list path
+        while [[ $# -gt 0 ]]; do
+            if [[ "$1" =~ ^[Ff]-[0-9]+ ]]; then
+                _unskip_feature_id="$1"
+            else
+                _unskip_feature_list="$1"
+            fi
+            shift
+        done
+        _unskip_args=(
+            --feature-list "$_unskip_feature_list"
+            --state-dir "$STATE_DIR"
+            --action unskip
+        )
+        if [[ -n "$_unskip_feature_id" ]]; then
+            _unskip_args+=(--feature-id "$_unskip_feature_id")
+        fi
+        python3 "$SCRIPTS_DIR/update-feature-status.py" "${_unskip_args[@]}"
+
+        # Commit the status change
+        if ! git diff --quiet "$_unskip_feature_list" 2>/dev/null; then
+            git add "$_unskip_feature_list"
+            git commit -m "chore: unskip auto-skipped features" 2>/dev/null || true
+        fi
+        ;;
     help|--help|-h)
         show_help
         ;;

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Core state machine for updating feature status in the dev-pipeline.
 
-Handles eight actions:
+Handles nine actions:
   - get_next: Find the next feature to process based on priority and dependencies
   - start: Mark a feature as in_progress when a session starts
   - update: Update a feature's status based on session outcome
@@ -10,11 +10,12 @@ Handles eight actions:
   - reset: Reset a feature to pending (status + retry count)
   - clean: Reset + delete session history + delete prizmkit artifacts
   - complete: Shortcut for manually marking a feature as completed
+  - unskip: Recover auto-skipped features (reset failed/skipped upstream + auto_skipped downstream)
 
 Usage:
     python3 update-feature-status.py \
         --feature-list <path> --state-dir <path> \
-        --action <get_next|start|update|status|pause|reset|clean|complete> \
+        --action <get_next|start|update|status|pause|reset|clean|complete|unskip> \
         [--feature-id <id>] [--session-status <status>] \
         [--session-id <id>] [--max-retries <n>] \
         [--features <filter>]
@@ -25,6 +26,7 @@ import json
 import os
 import re
 import shutil
+import sys
 from datetime import datetime, timezone
 
 from utils import (
@@ -48,7 +50,7 @@ SESSION_STATUS_VALUES = [
     "merge_conflict",
 ]
 
-TERMINAL_STATUSES = {"completed", "failed", "skipped"}
+TERMINAL_STATUSES = {"completed", "failed", "skipped", "auto_skipped", "split"}
 
 
 def parse_args():
@@ -68,7 +70,7 @@ def parse_args():
     parser.add_argument(
         "--action",
         required=True,
-        choices=["get_next", "start", "update", "status", "pause", "reset", "clean", "complete"],
+        choices=["get_next", "start", "update", "status", "pause", "reset", "clean", "complete", "unskip"],
         help="Action to perform",
     )
     parser.add_argument(
@@ -322,6 +324,116 @@ def load_session_status(state_dir, feature_id, session_id):
     return data, None
 
 
+# ---------------------------------------------------------------------------
+# Auto-skip: cascade failure to blocked downstream features
+# ---------------------------------------------------------------------------
+
+def auto_skip_blocked_features(feature_list_path, state_dir, failed_feature_id):
+    """Recursively mark all downstream features blocked by a failed feature as auto_skipped.
+
+    When a feature is marked as failed, any feature whose dependency chain includes
+    the failed feature can never be executed. This function propagates the failure
+    by marking those blocked features as auto_skipped, allowing the pipeline to
+    continue processing unblocked features and eventually reach PIPELINE_COMPLETE.
+
+    Re-reads feature-list.json from disk to get the latest state (including the
+    just-written failed status from update_feature_in_list).
+
+    NOTE: This function performs a read-modify-write on feature-list.json without
+    file locking. The caller (action_update) also writes to feature-list.json
+    immediately before calling this. Safe for single-pipeline execution, but if
+    multiple pipeline instances share the same feature-list.json concurrently,
+    a race condition may cause lost writes. Add file locking if parallel pipelines
+    are introduced.
+    """
+    data, err = load_json_file(feature_list_path)
+    if err:
+        return []
+    features = data.get("features", [])
+
+    # Build current status map
+    status_map = {}
+    for f in features:
+        if isinstance(f, dict) and f.get("id"):
+            status_map[f["id"]] = f.get("status", "pending")
+
+    # Collect all features to auto-skip (recursive propagation)
+    to_skip = set()
+    changed = True
+    while changed:
+        changed = False
+        for f in features:
+            if not isinstance(f, dict):
+                continue
+            fid = f.get("id")
+            if not fid or fid in to_skip:
+                continue
+            current = status_map.get(fid, "pending")
+            if current in TERMINAL_STATUSES:
+                continue
+            deps = f.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(fid)
+                    status_map[fid] = "auto_skipped"
+                    changed = True
+                    break
+
+    if not to_skip:
+        return []
+
+    # Batch-write to feature-list.json
+    for f in features:
+        if isinstance(f, dict) and f.get("id") in to_skip:
+            f["status"] = "auto_skipped"
+    write_json_file(feature_list_path, data)
+
+    # Sync status.json for each auto-skipped feature
+    for fid in to_skip:
+        fs = load_feature_status(state_dir, fid)
+        fs["status"] = "auto_skipped"
+        fs["updated_at"] = now_iso()
+        save_feature_status(state_dir, fid, fs)
+
+    # Build blocking reason map for logging
+    skipped_info = []
+    for f in features:
+        if not isinstance(f, dict):
+            continue
+        fid = f.get("id")
+        if fid not in to_skip:
+            continue
+        deps = f.get("dependencies", [])
+        blockers = [
+            d for d in deps
+            if d == failed_feature_id or d in to_skip
+        ]
+        skipped_info.append({
+            "feature_id": fid,
+            "title": f.get("title", ""),
+            "blocked_by": blockers,
+        })
+
+    print(
+        "[auto-skip] {} feature(s) auto-skipped due to failed {}:".format(
+            len(skipped_info), failed_feature_id
+        ),
+        file=sys.stderr,
+    )
+    for info in skipped_info:
+        print(
+            "  {} ({}) — blocked by {}".format(
+                info["feature_id"],
+                info["title"],
+                ", ".join(info["blocked_by"]),
+            ),
+            file=sys.stderr,
+        )
+
+    return skipped_info
+
+
 # ---------------------------------------------------------------------------
 # Action: get_next
 # ---------------------------------------------------------------------------
@@ -330,7 +442,7 @@ def action_get_next(feature_list_data, state_dir, feature_filter=None):
     """Find the next feature to process.
 
     Priority logic:
-    1. Skip terminal statuses (completed, failed, skipped)
+    1. Skip terminal statuses (completed, failed, skipped, auto_skipped, split)
     2. If feature_filter is set, skip features not in the filter
     3. Check that all dependencies are completed
     4. Prefer in_progress features over pending ones (interrupted session resume)
@@ -551,6 +663,13 @@ def action_update(args, feature_list_path, state_dir):
         error_out("Failed to save feature status: {}".format(err))
         return
 
+    # Auto-skip downstream features when this feature is marked as failed or skipped
+    auto_skipped_features = []
+    if fs["status"] in ("failed", "skipped"):
+        auto_skipped_features = auto_skip_blocked_features(
+            feature_list_path, state_dir, feature_id
+        )
+
     summary = {
         "action": "update",
         "feature_id": feature_id,
@@ -560,6 +679,8 @@ def action_update(args, feature_list_path, state_dir):
         "resume_from_phase": fs.get("resume_from_phase"),
         "updated_at": fs["updated_at"],
     }
+    if auto_skipped_features:
+        summary["auto_skipped"] = [info["feature_id"] for info in auto_skipped_features]
     if session_status in ("commit_missing", "docs_missing", "merge_conflict"):
         summary["degraded_reason"] = session_status
         summary["restart_policy"] = "finalization_retry"
@@ -760,6 +881,7 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
         "failed": 0,
         "pending": 0,
         "skipped": 0,
+        "auto_skipped": 0,
         "commit_missing": 0,
         "docs_missing": 0,
     }
@@ -800,6 +922,8 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
             icon = COLOR_RED + "[✗]" + COLOR_RESET
         elif fstatus == "skipped":
             icon = COLOR_GRAY + "[—]" + COLOR_RESET
+        elif fstatus == "auto_skipped":
+            icon = COLOR_GRAY + "[⊘]" + COLOR_RESET
         elif fstatus == "commit_missing":
             icon = COLOR_RED + "[↑]" + COLOR_RESET
         elif fstatus == "docs_missing":
@@ -818,6 +942,14 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
             ]
             if blocking:
                 detail = " (blocked by {})".format(", ".join(blocking))
+        elif fstatus == "auto_skipped":
+            deps = feature.get("dependencies", [])
+            blockers = [
+                d for d in deps
+                if status_map.get(d, "pending") in ("failed", "skipped", "auto_skipped")
+            ]
+            if blockers:
+                detail = " (auto-skipped: blocked by {})".format(", ".join(blockers))
 
         # Apply color to the whole line content
         if fstatus == "completed":
@@ -863,8 +995,8 @@ def action_status(feature_list_data, state_dir, feature_filter=None):
     summary_line = "Total: {} features | 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"]
     )
     summary_line3 = "Commit Missing: {} | Docs Missing: {}".format(
         counts["commit_missing"], counts["docs_missing"]
@@ -1086,6 +1218,152 @@ def action_clean(args, feature_list_path, state_dir):
     print(json.dumps(result, indent=2, ensure_ascii=False))
 
 
+# ---------------------------------------------------------------------------
+# Action: unskip
+# ---------------------------------------------------------------------------
+
+def action_unskip(args, feature_list_path, state_dir):
+    """Recover auto-skipped features by resetting them and their failed upstream.
+
+    Two modes:
+    - --feature-id F-032: Reset the specified failed/skipped feature + all auto_skipped
+      features whose dependency chain includes it.
+    - No --feature-id: Reset ALL failed, skipped, and auto_skipped features to pending.
+    """
+    feature_id = args.feature_id
+
+    data, err = load_json_file(feature_list_path)
+    if err:
+        error_out("Cannot load feature list: {}".format(err))
+        return
+    features = data.get("features", [])
+
+    to_reset = set()
+
+    if feature_id:
+        # Find the target feature
+        target = None
+        for f in features:
+            if isinstance(f, dict) and f.get("id") == feature_id:
+                target = f
+                break
+        if not target:
+            error_out("Feature '{}' not found in feature-list.json".format(feature_id))
+            return
+        if target.get("status") not in ("failed", "skipped", "auto_skipped"):
+            error_out(
+                "Feature '{}' has status '{}', expected 'failed', 'skipped', or 'auto_skipped'".format(
+                    feature_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(feature_id)
+            # Find all auto_skipped features that depend (transitively) on this one
+            changed = True
+            while changed:
+                changed = False
+                for f in features:
+                    if not isinstance(f, dict):
+                        continue
+                    fid = f.get("id")
+                    if not fid or fid in to_reset:
+                        continue
+                    if f.get("status") != "auto_skipped":
+                        continue
+                    deps = f.get("dependencies", [])
+                    if any(d in to_reset for d in deps):
+                        to_reset.add(fid)
+                        changed = True
+
+        # If target is auto_skipped, reset it and its failed upstream + siblings
+        elif target.get("status") == "auto_skipped":
+            to_reset.add(feature_id)
+            # Transitively walk upstream to find ALL failed/auto_skipped ancestors
+            # (e.g., F-001 failed → F-002 auto_skipped → F-003 auto_skipped;
+            #  unskip F-003 must also find and reset F-001)
+            upstream_changed = True
+            while upstream_changed:
+                upstream_changed = False
+                for f in features:
+                    if not isinstance(f, dict):
+                        continue
+                    fid = f.get("id")
+                    if not fid or fid not in to_reset:
+                        continue
+                    for dep_id in f.get("dependencies", []):
+                        if dep_id in to_reset:
+                            continue
+                        for dep_f in features:
+                            if isinstance(dep_f, dict) and dep_f.get("id") == dep_id:
+                                if dep_f.get("status") in ("failed", "skipped", "auto_skipped"):
+                                    to_reset.add(dep_id)
+                                    upstream_changed = True
+            # Also reset downstream auto_skipped features blocked by the same upstreams
+            changed = True
+            while changed:
+                changed = False
+                for f in features:
+                    if not isinstance(f, dict):
+                        continue
+                    fid = f.get("id")
+                    if not fid or fid in to_reset:
+                        continue
+                    if f.get("status") != "auto_skipped":
+                        continue
+                    fdeps = f.get("dependencies", [])
+                    if any(d in to_reset for d in fdeps):
+                        to_reset.add(fid)
+                        changed = True
+    else:
+        # No feature-id: reset ALL failed + skipped + auto_skipped
+        for f in features:
+            if isinstance(f, dict) and f.get("id"):
+                if f.get("status") in ("failed", "skipped", "auto_skipped"):
+                    to_reset.add(f["id"])
+
+    if not to_reset:
+        error_out("No features to unskip")
+        return
+
+    # Reset all collected features in feature-list.json
+    reset_details = []
+    for f in features:
+        if isinstance(f, dict) and f.get("id") in to_reset:
+            old_status = f.get("status", "unknown")
+            f["status"] = "pending"
+            reset_details.append({
+                "feature_id": f["id"],
+                "title": f.get("title", ""),
+                "old_status": old_status,
+            })
+
+    err = write_json_file(feature_list_path, data)
+    if err:
+        error_out("Failed to write feature-list.json: {}".format(err))
+        return
+
+    # Reset status.json for each feature
+    for fid in to_reset:
+        fs = load_feature_status(state_dir, fid)
+        fs["status"] = "pending"
+        fs["retry_count"] = 0
+        fs["sessions"] = []
+        fs["last_session_id"] = None
+        fs["resume_from_phase"] = None
+        fs["updated_at"] = now_iso()
+        save_feature_status(state_dir, fid, fs)
+
+    result = {
+        "action": "unskip",
+        "reset_count": len(to_reset),
+        "features": reset_details,
+    }
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
 # ---------------------------------------------------------------------------
 # Action: pause
 # ---------------------------------------------------------------------------
@@ -1167,6 +1445,8 @@ def main():
         action_update(args, args.feature_list, args.state_dir)
     elif args.action == "pause":
         action_pause(args.state_dir)
+    elif args.action == "unskip":
+        action_unskip(args, args.feature_list, args.state_dir)
 
 
 if __name__ == "__main__":

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

@@ -70,7 +70,7 @@
           },
           "status": {
             "type": "string",
-            "enum": ["pending", "in_progress", "completed", "failed", "skipped", "split"]
+            "enum": ["pending", "in_progress", "completed", "failed", "skipped", "split", "auto_skipped"]
           },
           "session_granularity": {
             "type": "string",

package/bundled/dev-pipeline/tests/conftest.py

@@ -24,3 +24,4 @@ def _load_hyphenated_module(module_name, filename):
 # Register hyphenated script files so tests can import them with underscores.
 _load_hyphenated_module("generate_bootstrap_prompt", "generate-bootstrap-prompt.py")
 _load_hyphenated_module("generate_bugfix_prompt", "generate-bugfix-prompt.py")
+_load_hyphenated_module("update_feature_status", "update-feature-status.py")