prizmkit 1.1.110 → 1.1.112

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

@@ -2,11 +2,12 @@
 """
 detect-recovery-state.py — Universal workflow recovery detector.
 
-Auto-detects which interactive workflow (feature-workflow, bug-fix-workflow,
-refactor-workflow) was interrupted and what phase it reached, by inspecting
-the workspace: git branch names, characteristic artifacts, and pipeline state.
+Auto-detects which interactive workflow or pipeline session was interrupted
+by inspecting git branch names, durable planning artifacts, pipeline state,
+current-workspace plans, review artifacts, and code changes.
 
-Does NOT run tests — that's left to the skill so the user sees output in real time.
+Does NOT run tests — the skill controls test execution so the user can see
+real-time output.
 
 Usage:
   python3 detect-recovery-state.py [--project-root .]
@@ -18,12 +19,9 @@ import os
 import re
 import subprocess
 import sys
+from pathlib import Path
 
 
-# ---------------------------------------------------------------------------
-# Git helper
-# ---------------------------------------------------------------------------
-
 def run_git(args, cwd=None):
     """Run a git command and return stdout, or empty string on failure."""
     try:
@@ -48,16 +46,37 @@ def detect_main_branch(project_root):
     return "main"
 
 
-# ---------------------------------------------------------------------------
-# Workflow signature detection (priority-ordered)
-# ---------------------------------------------------------------------------
+def relpath(path, project_root):
+    return os.path.relpath(path, project_root)
+
+
+def file_exists(project_root, *parts):
+    path = os.path.join(project_root, *parts)
+    return path if os.path.isfile(path) else None
+
+
+def dir_has_content(project_root, *parts):
+    path = os.path.join(project_root, *parts)
+    return os.path.isdir(path) and bool(os.listdir(path))
+
 
 def extract_bug_id_from_branch(branch):
-    """Extract bug ID from branch name like fix/B-001-login-crash → B-001."""
-    match = re.match(r"fix/(B-\d+)", branch)
+    """Extract bug ID from branch name like fix/B-001-login-crash -> B-001."""
+    match = re.match(r"fix/(B-\d+)", branch or "")
     return match.group(1) if match else None
 
 
+def latest_bugfix_artifact_id(project_root):
+    bugfix_dir = os.path.join(project_root, ".prizmkit", "bugfix")
+    if not os.path.isdir(bugfix_dir):
+        return None
+    bug_ids = sorted(
+        d for d in os.listdir(bugfix_dir)
+        if os.path.isdir(os.path.join(bugfix_dir, d))
+    )
+    return bug_ids[-1] if bug_ids else None
+
+
 def detect_workflow_type(project_root):
     """Priority-ordered signature matching.
 
@@ -65,294 +84,273 @@ def detect_workflow_type(project_root):
     """
     branch = run_git(["branch", "--show-current"], cwd=project_root)
 
-    # Priority 1: fix/* branch → bug-fix-workflow
     if branch.startswith("fix/"):
-        bug_id = extract_bug_id_from_branch(branch)
-        return ("bug-fix-workflow", {"bug_id": bug_id, "branch": branch})
+        return ("bug-fix-workflow", {
+            "bug_id": extract_bug_id_from_branch(branch),
+            "branch": branch,
+            "signal": "fix branch",
+        })
+
+    if dir_has_content(project_root, ".prizmkit", "state", "bugfix"):
+        return ("bug-fix-workflow", {
+            "bug_id": extract_bug_id_from_branch(branch) or latest_bugfix_artifact_id(project_root),
+            "branch": branch,
+            "signal": "bugfix pipeline state",
+        })
+
+    if file_exists(project_root, ".prizmkit", "plans", "bug-fix-list.json"):
+        return ("bug-fix-workflow", {
+            "bug_id": extract_bug_id_from_branch(branch) or latest_bugfix_artifact_id(project_root),
+            "branch": branch,
+            "signal": "bug-fix-list.json",
+        })
+
+    bug_id = latest_bugfix_artifact_id(project_root)
+    if bug_id:
+        return ("bug-fix-workflow", {
+            "bug_id": bug_id,
+            "branch": branch,
+            "signal": "optional bugfix artifacts",
+        })
 
-    # Priority 2: .prizmkit/bugfix/ has content → bug-fix-workflow
-    bugfix_dir = os.path.join(project_root, ".prizmkit", "bugfix")
-    if os.path.isdir(bugfix_dir):
-        bug_ids = sorted(
-            d for d in os.listdir(bugfix_dir)
-            if os.path.isdir(os.path.join(bugfix_dir, d))
-        )
-        if bug_ids:
-            return ("bug-fix-workflow", {"bug_id": bug_ids[-1], "branch": branch})
-
-    # Priority 3: refactor/* branch → refactor-workflow
     if branch.startswith("refactor/"):
-        return ("refactor-workflow", {"branch": branch})
-
-    # Priority 4: refactor-list.json exists → refactor-workflow
-    # Check both new and old paths for backward compatibility
-    new_refactor = os.path.join(project_root, ".prizmkit", "plans", "refactor-list.json")
-    old_refactor = os.path.join(project_root, "refactor-list.json")
-    if os.path.isfile(new_refactor):
-        return ("refactor-workflow", {"branch": branch})
-    elif os.path.isfile(old_refactor):
-        print(f"⚠️  Migration notice: refactor-list.json found in root. "
-              f"Please move to .prizmkit/plans/refactor-list.json", file=sys.stderr)
-        return ("refactor-workflow", {"branch": branch})
-
-    # Priority 5: feat/* branch → feature-workflow
+        return ("refactor-workflow", {"branch": branch, "signal": "refactor branch"})
+
+    if file_exists(project_root, ".prizmkit", "plans", "refactor-list.json"):
+        return ("refactor-workflow", {"branch": branch, "signal": "refactor-list.json"})
+
+    if dir_has_content(project_root, ".prizmkit", "state", "refactor"):
+        return ("refactor-workflow", {"branch": branch, "signal": "refactor pipeline state"})
+
     if branch.startswith("feat/"):
-        return ("feature-workflow", {"branch": branch})
-
-    # Priority 6: feature-list.json exists → feature-workflow
-    # Check both new and old paths for backward compatibility
-    new_feature = os.path.join(project_root, ".prizmkit", "plans", "feature-list.json")
-    old_feature = os.path.join(project_root, "feature-list.json")
-    if os.path.isfile(new_feature):
-        return ("feature-workflow", {"branch": branch})
-    elif os.path.isfile(old_feature):
-        print(f"⚠️  Migration notice: feature-list.json found in root. "
-              f"Please move to .prizmkit/plans/feature-list.json", file=sys.stderr)
-        return ("feature-workflow", {"branch": branch})
-
-    # No match
+        return ("feature-workflow", {"branch": branch, "signal": "feature branch"})
+
+    if file_exists(project_root, ".prizmkit", "plans", "feature-list.json"):
+        return ("feature-workflow", {"branch": branch, "signal": "feature-list.json"})
+
+    if dir_has_content(project_root, ".prizmkit", "state", "features"):
+        return ("feature-workflow", {"branch": branch, "signal": "feature pipeline state"})
+
+    if file_exists(project_root, "spec.md") or file_exists(project_root, "plan.md"):
+        return ("unknown-fast-path", {"branch": branch, "signal": "spec.md or plan.md"})
+
     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.
-    """
+    """Scan for secondary workflow signals beyond the primary match."""
     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
-
+    signals = [
+        ("bug-fix-workflow", [
+            branch.startswith("fix/"),
+            file_exists(project_root, ".prizmkit", "plans", "bug-fix-list.json"),
+            dir_has_content(project_root, ".prizmkit", "state", "bugfix"),
+            latest_bugfix_artifact_id(project_root),
+        ]),
+        ("refactor-workflow", [
+            branch.startswith("refactor/"),
+            file_exists(project_root, ".prizmkit", "plans", "refactor-list.json"),
+            dir_has_content(project_root, ".prizmkit", "state", "refactor"),
+        ]),
+        ("feature-workflow", [
+            branch.startswith("feat/"),
+            file_exists(project_root, ".prizmkit", "plans", "feature-list.json"),
+            dir_has_content(project_root, ".prizmkit", "state", "features"),
+        ]),
+    ]
+
+    for workflow, checks in signals:
+        if workflow != primary_type and any(checks):
+            others.append(workflow)
     return others
 
 
-# ---------------------------------------------------------------------------
-# Phase inference — one function per workflow
-# ---------------------------------------------------------------------------
+def find_first_existing(project_root, candidates):
+    for parts in candidates:
+        path = os.path.join(project_root, *parts)
+        if os.path.isfile(path) or os.path.isdir(path):
+            return relpath(path, project_root)
+    return None
 
-def infer_bugfix_phase(project_root, bug_id, code_changes, commits_ahead):
-    """Infer bug-fix-workflow phase from artifacts and git state.
 
-    Detection table (from bug-fix-workflow SKILL.md):
-      (nothing)                              → Phase 1: Deep Bug Diagnosis
-      fix-plan.md only                       → Phase 4: Fix
-      fix-plan.md + code changes             → Phase 5: Review
-      all docs + review passed               → Phase 6: User Verification
-      all docs + committed                   → Phase 7: Merge Decision
-    """
+def find_review_artifact(project_root):
+    candidates = [
+        ("review-report.md",),
+        ("code-review-report.md",),
+        (".prizmkit", "review-report.md"),
+        (".prizmkit", "code-review", "review-report.md"),
+        (".prizmkit", "reviews"),
+    ]
+    return find_first_existing(project_root, candidates)
+
+
+def find_session_artifact(project_root):
+    candidates = [
+        ("context-snapshot.md",),
+        ("session-summary.md",),
+        (".prizmkit", "context-snapshot.md"),
+        (".prizmkit", "session-summary.md"),
+    ]
+    return find_first_existing(project_root, candidates)
+
+
+def detect_fast_path_artifacts(project_root):
+    artifacts = {}
+    for name in ["spec.md", "plan.md"]:
+        path = file_exists(project_root, name)
+        artifacts[f"{name.replace('.', '_')}_exists"] = bool(path)
+        if path:
+            artifacts[f"{name.replace('.', '_')}_path"] = relpath(path, project_root)
+
+    review = find_review_artifact(project_root)
+    artifacts["review_artifact_exists"] = bool(review)
+    if review:
+        artifacts["review_artifact_path"] = review
+
+    session = find_session_artifact(project_root)
+    artifacts["session_artifact_exists"] = bool(session)
+    if session:
+        artifacts["session_artifact_path"] = session
+
+    return artifacts
+
+
+def infer_bugfix_phase(project_root, context, code_changes, commits_ahead):
+    """Infer bug-fix recovery phase from optional signals and git state."""
+    bug_id = context.get("bug_id") if context else None
     bugfix_dir = os.path.join(project_root, ".prizmkit", "bugfix", bug_id) if bug_id else ""
-    has_fix_plan = bugfix_dir and os.path.isfile(os.path.join(bugfix_dir, "fix-plan.md"))
-    has_fix_report = bugfix_dir and os.path.isfile(os.path.join(bugfix_dir, "fix-report.md"))
+    has_fix_plan = bool(bugfix_dir and os.path.isfile(os.path.join(bugfix_dir, "fix-plan.md")))
+    has_fix_report = bool(bugfix_dir and os.path.isfile(os.path.join(bugfix_dir, "fix-report.md")))
 
-    artifacts = {
+    artifacts = detect_fast_path_artifacts(project_root)
+    artifacts.update({
         "fix_plan_exists": has_fix_plan,
         "fix_report_exists": has_fix_report,
-    }
+    })
     if has_fix_plan:
-        artifacts["fix_plan_path"] = os.path.relpath(
-            os.path.join(bugfix_dir, "fix-plan.md"), project_root
-        )
+        artifacts["fix_plan_path"] = relpath(os.path.join(bugfix_dir, "fix-plan.md"), project_root)
     if has_fix_report:
-        artifacts["fix_report_path"] = os.path.relpath(
-            os.path.join(bugfix_dir, "fix-report.md"), project_root
-        )
+        artifacts["fix_report_path"] = relpath(os.path.join(bugfix_dir, "fix-report.md"), project_root)
+
+    has_plan_artifact = artifacts.get("spec_md_exists") or artifacts.get("plan_md_exists") or has_fix_plan
+    has_review_artifact = artifacts.get("review_artifact_exists") or has_fix_report
 
     if commits_ahead > 0:
         return 7, "Merge Decision", artifacts, \
-            f"{commits_ahead} commit(s) ahead — fix likely committed", \
-            "merge decision only"
+            f"{commits_ahead} commit(s) ahead — fix may already be committed", \
+            "merge decision or branch handoff"
 
-    if has_fix_report:
+    if has_review_artifact and code_changes["has_changes"]:
         return 6, "User Verification", artifacts, \
-            "fix-report.md exists — review completed", \
-            "user verification → commit & merge"
+            "review artifact found with code changes", \
+            "user verification -> commit -> merge decision"
 
-    if has_fix_plan and code_changes["has_changes"]:
+    if code_changes["has_changes"]:
         return 5, "Review", artifacts, \
-            "fix-plan.md exists + code changes present", \
-            "code review → user verification → commit & merge"
+            "code/test changes present without review artifact", \
+            "run tests if safe -> code review -> verification -> commit"
 
-    if has_fix_plan:
+    if has_plan_artifact:
         return 4, "Fix", artifacts, \
-            "fix-plan.md exists, no code changes yet", \
-            "implement fix → review → user verification → commit & merge"
+            "plan artifact found but no implementation changes", \
+            "implement fix -> review -> verification -> commit"
 
-    # On fix branch but no artifacts
-    return 1, "Deep Bug Diagnosis", artifacts, \
-        "on fix branch but no artifacts found", \
-        "diagnosis → triage → reproduce → fix → review → commit & merge"
+    return 1, "Diagnosis / Triage", artifacts, \
+        "bug-fix signal found but no durable implementation artifacts", \
+        "restore bug context -> diagnose -> choose recovery action"
 
 
-def _infer_pipeline_workflow_phase(project_root, list_filename, state_subdir, workflow_label):
-    """Infer phase for pipeline-driven workflows (feature-workflow, refactor-workflow).
-
-    Both follow the same structure:
-      No list file                → Phase 1: Brainstorm
-      List file, no pipeline state → Phase 3: Launch
-      List file + pipeline state   → Phase 4: Monitor
-
-    Checks new path (.prizmkit/plans/<list_filename>) first, then falls back
-    to old root-level path with a migration warning.
-    """
-    # Check new path first, then old path with fallback warning
-    new_list_path = os.path.join(project_root, ".prizmkit", "plans", list_filename)
-    old_list_path = os.path.join(project_root, list_filename)
-    has_list = os.path.isfile(new_list_path)
-    if not has_list and os.path.isfile(old_list_path):
-        has_list = True
-        print(f"⚠️  Migration notice: {list_filename} found in root. "
-              f"Please move to .prizmkit/plans/{list_filename}", file=sys.stderr)
-
-    # Check new state path first, then old path with fallback warning
-    new_state_dir = os.path.join(project_root, ".prizmkit", "state", state_subdir)
-    old_state_dir = os.path.join(project_root, "dev-pipeline", "state", state_subdir)
-    has_pipeline_state = os.path.isdir(new_state_dir) and bool(os.listdir(new_state_dir))
-    if not has_pipeline_state and os.path.isdir(old_state_dir) and bool(os.listdir(old_state_dir)):
-        has_pipeline_state = True
-        print(f"⚠️  Migration notice: pipeline state found at dev-pipeline/state/{state_subdir}. "
-              f"Please move to .prizmkit/state/{state_subdir}", file=sys.stderr)
+def infer_pipeline_workflow_phase(project_root, list_filename, state_subdir, workflow_label):
+    list_path = file_exists(project_root, ".prizmkit", "plans", list_filename)
+    has_state = dir_has_content(project_root, ".prizmkit", "state", state_subdir)
+    fast_path = detect_fast_path_artifacts(project_root)
 
     artifacts = {
-        f"{workflow_label}_list_exists": has_list,
-        "pipeline_state_exists": has_pipeline_state,
+        f"{workflow_label}_list_exists": bool(list_path),
+        "pipeline_state_exists": bool(has_state),
+        **fast_path,
     }
+    if list_path:
+        artifacts[f"{workflow_label}_list_path"] = relpath(list_path, project_root)
 
-    if has_list and has_pipeline_state:
-        return 4, "Monitor", artifacts, \
-            f".prizmkit/plans/{list_filename} + pipeline state exist", \
-            "check pipeline status and report results"
+    if list_path and has_state:
+        return 4, "Monitor / Recover Pipeline", artifacts, \
+            f"{list_filename} and pipeline state both exist", \
+            "check launcher status or run recovery script"
 
-    if has_list:
+    if list_path:
         return 3, "Launch", artifacts, \
-            f".prizmkit/plans/{list_filename} exists, no pipeline state", \
-            "launch pipeline → monitor progress"
+            f"{list_filename} exists without pipeline state", \
+            "launch pipeline or inspect/update list"
+
+    if fast_path.get("spec_md_exists") or fast_path.get("plan_md_exists"):
+        return 2, "Fast Path Continuation", artifacts, \
+            "current-workspace spec/plan artifact found", \
+            "continue implementation/review/commit based on diff"
 
-    return 1, "Brainstorm", artifacts, \
-        f"no .prizmkit/plans/{list_filename} found", \
-        f"{workflow_label} goal clarification → plan → launch → monitor"
+    return 1, "Route Selection", artifacts, \
+        f"no {list_filename} or pipeline state found", \
+        f"clarify {workflow_label} intent and choose path"
 
 
 def infer_feature_phase(project_root):
-    """Infer feature-workflow phase from artifacts and pipeline state."""
-    return _infer_pipeline_workflow_phase(
-        project_root, "feature-list.json", "features", "feature"
-    )
+    return infer_pipeline_workflow_phase(project_root, "feature-list.json", "features", "feature")
 
 
 def infer_refactor_phase(project_root):
-    """Infer refactor-workflow phase from artifacts and pipeline state."""
-    return _infer_pipeline_workflow_phase(
-        project_root, "refactor-list.json", "refactor", "refactor"
-    )
+    return infer_pipeline_workflow_phase(project_root, "refactor-list.json", "refactor", "refactor")
+
 
+def infer_unknown_fast_path_phase(project_root, code_changes):
+    artifacts = detect_fast_path_artifacts(project_root)
+    if code_changes["has_changes"]:
+        return 5, "Review", artifacts, \
+            "spec/plan plus code changes found, but workflow family is unknown", \
+            "ask workflow family -> run tests/review -> continue"
+    return 2, "Fast Path Continuation", artifacts, \
+        "spec/plan found, but workflow family is unknown", \
+        "ask whether this is feature, bug fix, or refactor work"
 
-# ---------------------------------------------------------------------------
-# Git state helpers
-# ---------------------------------------------------------------------------
 
 def detect_commits_ahead(project_root, main_branch="main"):
-    """Count commits ahead of main branch."""
-    log_output = run_git(
-        ["log", f"{main_branch}..HEAD", "--oneline"], cwd=project_root
-    )
+    log_output = run_git(["log", f"{main_branch}..HEAD", "--oneline"], cwd=project_root)
     if log_output:
         return len(log_output.strip().split("\n"))
     return 0
 
 
 def detect_git_state(project_root, main_branch="main", cached_branch=None):
-    """Detect git branch and change state."""
     current = cached_branch or run_git(["branch", "--show-current"], cwd=project_root)
 
-    # Uncommitted changes (working tree)
-    uncommitted = 0
-    diff_stat = run_git(["diff", "--stat"], cwd=project_root)
-    if diff_stat:
-        lines = diff_stat.strip().split("\n")
-        uncommitted = max(0, len(lines) - 1)
-
-    # Staged changes
-    staged = 0
-    staged_stat = run_git(["diff", "--cached", "--stat"], cwd=project_root)
-    if staged_stat:
-        lines = staged_stat.strip().split("\n")
-        staged = max(0, len(lines) - 1)
-
+    uncommitted = run_git(["status", "--porcelain"], cwd=project_root)
     commits_ahead = detect_commits_ahead(project_root, main_branch)
 
     return {
         "current_branch": current,
-        "uncommitted_files": uncommitted,
-        "staged_files": staged,
+        "changed_paths": len([line for line in uncommitted.splitlines() if line.strip()]),
         "commits_ahead_of_main": commits_ahead,
     }
 
 
-# ---------------------------------------------------------------------------
-# Code change detection (reused from original, workflow-agnostic)
-# ---------------------------------------------------------------------------
-
 def detect_code_changes(project_root, main_branch="main"):
-    """Analyze code changes relative to main branch.
-
-    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 = {
-        # Basename-matched list files (root-level legacy paths)
+    """Analyze implementation changes relative to main and working tree."""
+    ignored_files = {
         "feature-list.json",
         "bug-fix-list.json",
         "refactor-list.json",
-        # Lock files
+        "spec.md",
+        "plan.md",
+        "review-report.md",
+        "code-review-report.md",
+        "session-summary.md",
+        "context-snapshot.md",
         "package-lock.json",
         "yarn.lock",
         "pnpm-lock.yaml",
     }
-    # Note: .prizmkit/plans/*.json paths are caught by IGNORED_PREFIXES below
-    IGNORED_PREFIXES = (
+    ignored_prefixes = (
         ".prizmkit/",
         ".agents/",
         ".codex/",
@@ -360,80 +358,46 @@ def detect_code_changes(project_root, main_branch="main"):
         ".codebuddy/",
     )
 
-    def is_source_file(filepath):
-        """Return True if this file represents implementation code."""
+    def is_implementation_file(filepath):
         basename = os.path.basename(filepath)
-        if basename in IGNORED_FILES:
+        if basename in ignored_files:
+            return False
+        if any(filepath.startswith(prefix) for prefix in ignored_prefixes):
             return False
-        for prefix in IGNORED_PREFIXES:
-            if filepath.startswith(prefix):
-                return False
         return True
 
-    # 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 (committed changes on branch)
-    diff_output = run_git(
-        ["diff", main_branch, "--name-status"], cwd=project_root
-    )
+    file_statuses = {}
 
-    if diff_output:
-        for line in diff_output.strip().split("\n"):
-            if not line.strip():
-                continue
-            parts = line.split("\t", 1)
-            if len(parts) < 2:
-                continue
-            status, filepath = parts[0][0], parts[1]  # first char of status
-            if not is_source_file(filepath):
-                continue
-            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
+    for command in (["diff", main_branch, "--name-status"], ["diff", "--name-status"]):
+        output = run_git(command, cwd=project_root)
+        if not output:
+            continue
+        for line in output.splitlines():
             parts = line.split("\t", 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
+            if is_implementation_file(filepath):
+                file_statuses.setdefault(filepath, status)
 
-    # Untracked files
-    untracked = run_git(
-        ["ls-files", "--others", "--exclude-standard"], cwd=project_root
-    )
+    untracked = run_git(["ls-files", "--others", "--exclude-standard"], cwd=project_root)
     if untracked:
-        for filepath in untracked.strip().split("\n"):
+        for filepath in untracked.splitlines():
             filepath = filepath.strip()
-            if filepath and is_source_file(filepath):
-                if filepath not in file_statuses:
-                    file_statuses[filepath] = "A"  # untracked = added
+            if filepath and is_implementation_file(filepath):
+                file_statuses.setdefault(filepath, "A")
 
-    # Count by status
+    test_pattern = re.compile(r"(test|spec|__tests__|\.test\.|\.spec\.)", re.IGNORECASE)
+    dirs = set()
     result = {
         "files_modified": 0,
         "files_added": 0,
         "files_deleted": 0,
         "test_files_touched": 0,
         "directories_touched": [],
-        "has_changes": False,
+        "has_changes": bool(file_statuses),
     }
 
-    test_patterns = re.compile(
-        r"(test|spec|__tests__|\.test\.|\.spec\.)", re.IGNORECASE
-    )
-    dirs = set()
-
     for filepath, status in file_statuses.items():
         if status == "M":
             result["files_modified"] += 1
@@ -441,8 +405,7 @@ def detect_code_changes(project_root, main_branch="main"):
             result["files_added"] += 1
         elif status == "D":
             result["files_deleted"] += 1
-
-        if test_patterns.search(filepath):
+        if test_pattern.search(filepath):
             result["test_files_touched"] += 1
         parent = os.path.dirname(filepath)
         if parent:
@@ -450,28 +413,14 @@ 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(file_statuses) > 0
-
     return result
 
 
-# ---------------------------------------------------------------------------
-# Main
-# ---------------------------------------------------------------------------
-
 def main():
-    parser = argparse.ArgumentParser(
-        description="Auto-detect interrupted workflow state for recovery"
-    )
-    parser.add_argument(
-        "--project-root",
-        default=None,
-        help="Project root directory (default: auto-detect from git)",
-    )
-
+    parser = argparse.ArgumentParser(description="Auto-detect interrupted workflow state for recovery")
+    parser.add_argument("--project-root", default=None, help="Project root directory (default: auto-detect from git)")
     args = parser.parse_args()
 
-    # Resolve project root
     if args.project_root:
         project_root = os.path.abspath(args.project_root)
     else:
@@ -479,46 +428,34 @@ def main():
         project_root = git_root if git_root else os.getcwd()
 
     main_branch = detect_main_branch(project_root)
-
-    # Step 1: Detect workflow type (also caches branch name)
     workflow_type, context = detect_workflow_type(project_root)
 
     if workflow_type is None:
-        report = {
+        print(json.dumps({
             "detected": False,
-            "message": (
-                "No interrupted workflow detected. "
-                "Use /feature-workflow, /bug-fix-workflow, or /refactor-workflow to start."
-            ),
-        }
-        print(json.dumps(report, indent=2))
+            "message": "No interrupted workflow detected. Use /feature-workflow, /bug-fix-workflow, or /refactor-workflow to start.",
+        }, indent=2))
         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")
+    cached_branch = context.get("branch") if context else None
     git_state = detect_git_state(project_root, main_branch, cached_branch=cached_branch)
     code_changes = detect_code_changes(project_root, main_branch)
+    other_workflows = detect_other_workflows(project_root, workflow_type)
 
-    # Step 3: Infer phase within the detected workflow
     if workflow_type == "bug-fix-workflow":
-        phase, phase_name, artifacts, reason, remaining = \
-            infer_bugfix_phase(project_root, context.get("bug_id"),
-                               code_changes, git_state["commits_ahead_of_main"])
+        phase, phase_name, artifacts, reason, remaining = infer_bugfix_phase(
+            project_root, context, code_changes, git_state["commits_ahead_of_main"]
+        )
     elif workflow_type == "feature-workflow":
-        phase, phase_name, artifacts, reason, remaining = \
-            infer_feature_phase(project_root)
+        phase, phase_name, artifacts, reason, remaining = infer_feature_phase(project_root)
     elif workflow_type == "refactor-workflow":
-        phase, phase_name, artifacts, reason, remaining = \
-            infer_refactor_phase(project_root)
+        phase, phase_name, artifacts, reason, remaining = infer_refactor_phase(project_root)
+    elif workflow_type == "unknown-fast-path":
+        phase, phase_name, artifacts, reason, remaining = infer_unknown_fast_path_phase(project_root, code_changes)
     else:
-        # Should never reach here
         print(json.dumps({"detected": False, "message": "Unknown workflow type"}), file=sys.stderr)
         sys.exit(1)
 
-    # Step 4: Build report
     report = {
         "detected": True,
         "workflow_type": workflow_type,
@@ -533,7 +470,6 @@ def main():
             "remaining_work": remaining,
         },
     }
-
     if other_workflows:
         report["other_interrupted_workflows"] = other_workflows