prizmkit 1.1.27 → 1.1.30

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.27",
+  "version": "1.1.30",
   "skills": {
     "prizm-kit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",

package/bundled/skills/recovery-workflow/SKILL.md

@@ -20,6 +20,29 @@ User says:
 - User wants a clean restart → use the original workflow skill directly (`/feature-workflow`, `/bug-fix-workflow`, `/refactor-workflow`)
 - Nothing was ever started → use the original workflow skill
 
+## Pipeline Recovery (Recommended)
+
+**IMPORTANT**: In Phase 1.3, you MUST present the user with a choice between pipeline recovery (`run-recovery.sh`) and interactive recovery. **NEVER skip this choice. NEVER decide for the user.** The pipeline approach is recommended because it generates a comprehensive bootstrap prompt that explicitly lists every remaining phase with full instructions, ensuring the AI completes the full workflow — not just the implementation part.
+
+Pipeline commands (for reference — Phase 1.3 will present these as a selectable option):
+
+```bash
+./dev-pipeline/run-recovery.sh                    # Auto-detect and recover
+./dev-pipeline/run-recovery.sh detect              # Detection report only
+./dev-pipeline/run-recovery.sh run --dry-run       # Generate prompt, don't execute
+./dev-pipeline/run-recovery.sh run --yes           # Skip confirmation
+./dev-pipeline/run-recovery.sh run --model <model> # Override AI model
+```
+
+### When to use pipeline vs interactive recovery
+
+| Scenario | Approach |
+|----------|----------|
+| Pipeline session timed out / crashed | `./run-recovery.sh` — autonomous, completes all phases reliably |
+| Interactive session interrupted | This skill (`/recovery-workflow`) — for in-session interactive use |
+| Want to inspect before recovering | `./run-recovery.sh detect` or `./run-recovery.sh run --dry-run` |
+| Daemon/scripted use | `./run-recovery.sh run --yes` — no user confirmation needed |
+
 ## Supported Workflows
 
 | Workflow | Branch Pattern | Key Artifacts |
@@ -42,10 +65,10 @@ recovery-workflow
   │   ├── Based on artifact presence → infer current phase
   │   └── No match → reject and guide user
   │
-  ├── Phase 1: Report + user confirmation
+  ├── Phase 1: Report + user choice
   │   ├── Display detection results
   │   ├── If code changes exist → run test suite
-  │   └── User confirms "continue" → proceed
+  │   └── User chooses: run-recovery.sh (recommended) | interactive | start fresh
   │
   └── Phase 2: Execute remaining steps
       ├── Read target workflow's SKILL.md
@@ -137,18 +160,55 @@ Include test results in the report:
 - How many tests pass/fail
 - If failures exist — which tests and why
 
-### 1.3 Ask User to Confirm
+### 1.3 Ask User to Choose Recovery Approach
+
+**User choice required (mandatory)** — Use `AskUserQuestion` to present interactive selectable options. **NEVER skip this step. NEVER choose for the user.**
+
+```
+AskUserQuestion:
+  question: "Interrupted {workflow_type} detected at Phase {N} ({phase_name}). How would you like to recover?"
+  header: "Recovery"
+  options:
+    - label: "Run recovery script (Recommended)"
+      description: "Execute ./dev-pipeline/run-recovery.sh — autonomously completes ALL remaining phases (review, commit, merge, etc.) via a dedicated AI session with explicit phase instructions"
+    - label: "Copy command and run manually"
+      description: "I'll give you the exact shell command to paste into your terminal — you run it yourself outside this session"
+    - label: "Resume interactively in this session"
+      description: "Continue from Phase {N} within this conversation — more control, but may not complete all phases if session is interrupted again"
+    - label: "Start fresh"
+      description: "Discard interrupted work and restart the original workflow from scratch"
+```
+
+**If "Run recovery script"** → Execute the pipeline recovery:
+```bash
+./dev-pipeline/run-recovery.sh
+```
+The script handles everything: detection, confirmation, prompt generation, session spawn, and post-session validation. **End this skill after launching the script** — do not proceed to Phase 2.
 
+**If "Copy command and run manually"** → Output the command for the user to copy and run in their own terminal:
 ```
-Ready to resume from Phase 5 (Review). Continue?
+To recover, run this command in your project root:
+
+  ./dev-pipeline/run-recovery.sh
+
+Or with options:
+  ./dev-pipeline/run-recovery.sh run --dry-run    # Preview the recovery prompt first
+  ./dev-pipeline/run-recovery.sh run --yes         # Skip confirmation
+  ./dev-pipeline/run-recovery.sh run --model <model>  # Specify AI model
 ```
+**End this skill** — do not proceed to Phase 2. The user will run the command themselves.
+
+**If "Resume interactively"** → Continue to Phase 2 below (execute remaining steps in this session).
 
-If the user declines, suggest alternatives:
-- "Use `/bug-fix-workflow` to start fresh"
-- "Use `/feature-workflow` to start fresh"
-- "Use `/refactor-workflow` to start fresh"
+**If "Start fresh"** → Suggest the appropriate original workflow skill:
+- bug-fix-workflow → `/bug-fix-workflow`
+- feature-workflow → `/feature-workflow`
+- refactor-workflow → `/refactor-workflow`
+End this skill.
 
-**CHECKPOINT CP-REC-1**: User confirmed recovery.
+**NEVER proceed to Phase 2 without explicit user selection via `AskUserQuestion`. Do NOT render options as plain text — the user must be able to click/select.**
+
+**CHECKPOINT CP-REC-1**: User chose recovery approach.
 
 ---
 
@@ -181,6 +241,8 @@ Phase inference table:
 | All docs + review passed | Phase 6: User Verification | Ask user to verify the fix works |
 | All docs + committed | Phase 7: Merge Decision | Ask merge vs keep branch |
 
+**Note**: Bug-fix Phases 1-3 (Diagnosis, Triage, Reproduce) collapse to Phase 1 for detection purposes because these phases don't produce persistent artifacts. If interrupted during these phases, recovery restarts from Phase 1 (diagnosis), which re-derives understanding from available inputs (bug description, code) without interactive Q&A.
+
 **Execution for each remaining phase**: Follow the bug-fix-workflow SKILL.md instructions exactly. Call the same prizmkit sub-commands (`/prizmkit-code-review`, `/prizmkit-committer`) at the same points.
 
 **Special handling**:
@@ -259,6 +321,7 @@ Recovery complete.
 | `feature-pipeline-launcher` | **Called in Phase 2.2** — launches or checks pipeline status for feature recovery |
 | `reset-feature.sh --clean --run` | **Alternative** — full clean retry for pipeline failures; this skill is the smart interactive alternative |
 | `reset-bug.sh --clean --run` | **Alternative** — full clean retry for bugfix pipeline failures |
+| `run-recovery.sh` | **Pipeline counterpart** — shell-driven recovery that generates bootstrap prompt and spawns AI CLI session for autonomous completion |
 | `/prizmkit-code-review` | **Called in Phase 2.1** — reviews recovered bug-fix code |
 | `/prizmkit-committer` | **Called in Phase 2.1** — commits the recovered result |
 

package/bundled/skills/recovery-workflow/scripts/detect-recovery-state.py

@@ -114,6 +114,58 @@ def detect_workflow_type(project_root):
     return (None, None)
 
 
+def detect_other_workflows(project_root, primary_type):
+    """Scan for other interrupted workflow signals beyond the primary match.
+
+    Returns a list of workflow type strings that also have signals present,
+    excluding the primary_type already detected.
+    """
+    others = []
+    branch = run_git(["branch", "--show-current"], cwd=project_root)
+
+    # Bug-fix signals
+    if primary_type != "bug-fix-workflow":
+        if branch.startswith("fix/"):
+            others.append("bug-fix-workflow")
+        else:
+            bugfix_dir = os.path.join(project_root, ".prizmkit", "bugfix")
+            if os.path.isdir(bugfix_dir):
+                bug_ids = [
+                    d for d in os.listdir(bugfix_dir)
+                    if os.path.isdir(os.path.join(bugfix_dir, d))
+                ]
+                if bug_ids:
+                    others.append("bug-fix-workflow")
+
+    # Refactor signals
+    if primary_type != "refactor-workflow":
+        if branch.startswith("refactor/"):
+            others.append("refactor-workflow")
+        else:
+            for path in [
+                os.path.join(project_root, ".prizmkit", "plans", "refactor-list.json"),
+                os.path.join(project_root, "refactor-list.json"),
+            ]:
+                if os.path.isfile(path):
+                    others.append("refactor-workflow")
+                    break
+
+    # Feature signals
+    if primary_type != "feature-workflow":
+        if branch.startswith("feat/"):
+            others.append("feature-workflow")
+        else:
+            for path in [
+                os.path.join(project_root, ".prizmkit", "plans", "feature-list.json"),
+                os.path.join(project_root, "feature-list.json"),
+            ]:
+                if os.path.isfile(path):
+                    others.append("feature-workflow")
+                    break
+
+    return others
+
+
 # ---------------------------------------------------------------------------
 # Phase inference — one function per workflow
 # ---------------------------------------------------------------------------
@@ -285,18 +337,21 @@ def detect_code_changes(project_root, main_branch="main"):
 
     Filters out pipeline/config files that aren't source code — only counts
     files that represent actual implementation work.
+
+    Uses a file_statuses dict keyed by filepath to avoid double-counting
+    files that appear in both committed diff and uncommitted changes.
     """
     IGNORED_FILES = {
-        ".prizmkit/plans/feature-list.json",
-        ".prizmkit/plans/bug-fix-list.json",
-        ".prizmkit/plans/refactor-list.json",
+        # Basename-matched list files (root-level legacy paths)
         "feature-list.json",
         "bug-fix-list.json",
         "refactor-list.json",
+        # Lock files
         "package-lock.json",
         "yarn.lock",
         "pnpm-lock.yaml",
     }
+    # Note: .prizmkit/plans/*.json paths are caught by IGNORED_PREFIXES below
     IGNORED_PREFIXES = (
         ".prizmkit/",
         ".prizm-docs/",
@@ -314,29 +369,16 @@ def detect_code_changes(project_root, main_branch="main"):
                 return False
         return True
 
-    result = {
-        "files_modified": 0,
-        "files_added": 0,
-        "files_deleted": 0,
-        "test_files_touched": 0,
-        "directories_touched": [],
-        "has_changes": False,
-    }
+    # Track unique file → status to avoid double-counting.
+    # Later sources (uncommitted, untracked) update the status if the file
+    # was already seen in a committed diff.
+    file_statuses = {}  # filepath → "M" | "A" | "D"
 
-    # Diff relative to main
+    # Diff relative to main (committed changes on branch)
     diff_output = run_git(
         ["diff", main_branch, "--name-status"], cwd=project_root
     )
 
-    # Also include uncommitted changes
-    uncommitted = run_git(["diff", "--name-status"], cwd=project_root)
-    untracked = run_git(
-        ["ls-files", "--others", "--exclude-standard"], cwd=project_root
-    )
-
-    all_files = set()
-    dirs = set()
-
     if diff_output:
         for line in diff_output.strip().split("\n"):
             if not line.strip():
@@ -344,40 +386,61 @@ def detect_code_changes(project_root, main_branch="main"):
             parts = line.split("\t", 1)
             if len(parts) < 2:
                 continue
-            status, filepath = parts[0], parts[1]
+            status, filepath = parts[0][0], parts[1]  # first char of status
             if not is_source_file(filepath):
                 continue
-            all_files.add(filepath)
-            if status.startswith("M"):
-                result["files_modified"] += 1
-            elif status.startswith("A"):
-                result["files_added"] += 1
-            elif status.startswith("D"):
-                result["files_deleted"] += 1
+            file_statuses[filepath] = status
 
+    # Uncommitted working tree changes — update status for already-seen files
+    uncommitted = run_git(["diff", "--name-status"], cwd=project_root)
     if uncommitted:
         for line in uncommitted.strip().split("\n"):
             if not line.strip():
                 continue
             parts = line.split("\t", 1)
-            if len(parts) >= 2:
-                filepath = parts[1]
-                if not is_source_file(filepath):
-                    continue
-                all_files.add(filepath)
-                result["files_modified"] += 1
+            if len(parts) < 2:
+                continue
+            status, filepath = parts[0][0], parts[1]
+            if not is_source_file(filepath):
+                continue
+            if filepath not in file_statuses:
+                file_statuses[filepath] = "M"  # uncommitted change = modified
+            # If already tracked from branch diff, keep the branch-level status
 
+    # Untracked files
+    untracked = run_git(
+        ["ls-files", "--others", "--exclude-standard"], cwd=project_root
+    )
     if untracked:
         for filepath in untracked.strip().split("\n"):
-            if filepath.strip() and is_source_file(filepath.strip()):
-                all_files.add(filepath.strip())
-                result["files_added"] += 1
+            filepath = filepath.strip()
+            if filepath and is_source_file(filepath):
+                if filepath not in file_statuses:
+                    file_statuses[filepath] = "A"  # untracked = added
+
+    # Count by status
+    result = {
+        "files_modified": 0,
+        "files_added": 0,
+        "files_deleted": 0,
+        "test_files_touched": 0,
+        "directories_touched": [],
+        "has_changes": False,
+    }
 
-    # Analyze file set
     test_patterns = re.compile(
         r"(test|spec|__tests__|\.test\.|\.spec\.)", re.IGNORECASE
     )
-    for filepath in all_files:
+    dirs = set()
+
+    for filepath, status in file_statuses.items():
+        if status == "M":
+            result["files_modified"] += 1
+        elif status == "A":
+            result["files_added"] += 1
+        elif status == "D":
+            result["files_deleted"] += 1
+
         if test_patterns.search(filepath):
             result["test_files_touched"] += 1
         parent = os.path.dirname(filepath)
@@ -386,7 +449,7 @@ def detect_code_changes(project_root, main_branch="main"):
             dirs.add(os.sep.join(parts[:2]) + "/")
 
     result["directories_touched"] = sorted(dirs)
-    result["has_changes"] = len(all_files) > 0
+    result["has_changes"] = len(file_statuses) > 0
 
     return result
 
@@ -428,7 +491,10 @@ def main():
             ),
         }
         print(json.dumps(report, indent=2))
-        sys.exit(1)
+        sys.exit(0)
+
+    # Check for other interrupted workflows (informational)
+    other_workflows = detect_other_workflows(project_root, workflow_type)
 
     # Step 2: Collect git state and code changes once (shared across phase inference + report)
     cached_branch = context.get("branch")
@@ -467,6 +533,9 @@ def main():
         },
     }
 
+    if other_workflows:
+        report["other_interrupted_workflows"] = other_workflows
+
     print(json.dumps(report, indent=2))
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.1.27",
+  "version": "1.1.30",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {