prizmkit 1.1.26 → 1.1.29

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.26",
+  "version": "1.1.29",
   "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,38 @@ 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)
+
+For reliable recovery that completes ALL remaining phases autonomously, use the shell-driven pipeline:
+
+```bash
+# Auto-detect and recover (with confirmation)
+./dev-pipeline/run-recovery.sh
+
+# Detection report only (no execution)
+./dev-pipeline/run-recovery.sh detect
+
+# Generate prompt without executing (inspect it)
+./dev-pipeline/run-recovery.sh run --dry-run
+
+# Skip confirmation (for scripted/daemon use)
+./dev-pipeline/run-recovery.sh run --yes
+
+# Override AI model
+./dev-pipeline/run-recovery.sh run --model claude-opus-4.6
+```
+
+The pipeline approach 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.
+
+### 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 |
@@ -181,6 +213,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 +293,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.26",
+  "version": "1.1.29",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {

package/src/upgrade.js

@@ -198,17 +198,24 @@ export async function runUpgrade(directory, options = {}) {
   const rulesPreset = oldManifest?.options?.rules || 'recommended';
   const aiCli = userConfig.ai_cli || oldManifest?.options?.aiCli || '';
 
-  // Filesystem-based platform detection (overrides manifest if dirs exist)
-  const hasClaude = await fs.pathExists(path.join(projectRoot, '.claude', 'commands'))
-                    || await fs.pathExists(path.join(projectRoot, '.claude', 'agents'));
-  const hasCodeBuddy = await fs.pathExists(path.join(projectRoot, '.codebuddy', 'skills'))
-                       || await fs.pathExists(path.join(projectRoot, '.codebuddy', 'agents'));
-
+  // Platform detection: manifest is the source of truth (set by install/config).
+  // Filesystem detection is only used as fallback when manifest has no platform field
+  // (e.g. legacy installs before manifest tracked platform).
   let platform;
-  if (hasClaude && hasCodeBuddy) platform = 'both';
-  else if (hasCodeBuddy) platform = 'codebuddy';
-  else if (hasClaude) platform = 'claude';
-  else platform = oldManifestPlatform; // fallback to manifest
+  if (oldManifest?.platform) {
+    platform = oldManifest.platform;
+  } else {
+    // Fallback: detect from filesystem for legacy manifests without platform field
+    const hasClaude = await fs.pathExists(path.join(projectRoot, '.claude', 'commands'))
+                      || await fs.pathExists(path.join(projectRoot, '.claude', 'agents'));
+    const hasCodeBuddy = await fs.pathExists(path.join(projectRoot, '.codebuddy', 'skills'))
+                         || await fs.pathExists(path.join(projectRoot, '.codebuddy', 'agents'));
+
+    if (hasClaude && hasCodeBuddy) platform = 'both';
+    else if (hasCodeBuddy) platform = 'codebuddy';
+    else if (hasClaude) platform = 'claude';
+    else platform = 'claude'; // ultimate fallback
+  }
 
   const newSkillList = await resolveSkillList(suite);
   const agentsDir = getAgentsDir();
@@ -253,7 +260,7 @@ export async function runUpgrade(directory, options = {}) {
   const oldVersion = oldManifest?.version || 'unknown';
   console.log(chalk.bold('  Upgrade Summary:'));
   console.log(`    Version: ${chalk.gray(oldVersion)} → ${chalk.cyan(pkg.version)}`);
-  console.log(`    Platform: ${platform}${platform !== oldManifestPlatform ? chalk.yellow(` (detected from filesystem, manifest had: ${oldManifestPlatform})`) : ''}`);
+  console.log(`    Platform: ${platform}${!oldManifest?.platform ? chalk.yellow(' (detected from filesystem — no platform in manifest)') : ''}`);
   console.log(`    Suite: ${suite}`);
   console.log('');