prizmkit 1.1.8 → 1.1.9

package/bundled/dev-pipeline/scripts/check-session-status.py

@@ -16,7 +16,9 @@ import sys
 from utils import setup_logging
 
 
-REQUIRED_FIELDS = ["session_id", "feature_id", "status", "timestamp"]
+REQUIRED_FIELDS = ["session_id", "status", "timestamp"]
+# At least one of these ID fields must be present (depends on pipeline type)
+ID_FIELDS = ["feature_id", "bug_id", "refactor_id"]
 
 LOGGER = setup_logging("check-session-status")
 
@@ -52,6 +54,8 @@ def validate_required_fields(data):
     """Check that all required fields are present and non-empty.
 
     Returns a list of missing/invalid field names.
+    In addition to the always-required fields, at least one of
+    feature_id / bug_id / refactor_id must be present.
     """
     missing = []
     for field in REQUIRED_FIELDS:
@@ -59,6 +63,15 @@ def validate_required_fields(data):
             missing.append(field)
         elif not isinstance(data[field], str) or not data[field].strip():
             missing.append(field)
+
+    # Check that at least one ID field is present and non-empty
+    has_id = any(
+        field in data and isinstance(data[field], str) and data[field].strip()
+        for field in ID_FIELDS
+    )
+    if not has_id:
+        missing.append("feature_id|bug_id|refactor_id")
+
     return missing
 
 
@@ -78,8 +91,16 @@ def determine_status(data):
             return "partial_resumable"
         else:
             return "partial_not_resumable"
+    elif status == "partial_resumable":
+        return "partial_resumable"
+    elif status == "partial_not_resumable":
+        return "partial_not_resumable"
     elif status == "failed":
         return "failed"
+    elif status == "crashed":
+        return "crashed"
+    elif status == "timed_out":
+        return "timed_out"
     elif status == "commit_missing":
         return "commit_missing"
     elif status == "docs_missing":
@@ -99,6 +120,8 @@ def build_detail_report(data, resolved_status):
     return {
         "status": resolved_status,
         "feature_id": data.get("feature_id"),
+        "bug_id": data.get("bug_id"),
+        "refactor_id": data.get("refactor_id"),
         "completed_phases": data.get("completed_phases", []),
         "checkpoint_reached": data.get("checkpoint_reached"),
         "tasks_completed": data.get("tasks_completed", 0),

package/bundled/dev-pipeline/scripts/detect-stuck.py

@@ -1,18 +1,22 @@
 #!/usr/bin/env python3
-"""Detect stuck features in the dev-pipeline.
+"""Detect stuck items in the dev-pipeline (features, bugs, or refactors).
 
-Checks each feature for conditions that indicate it is stuck:
+Checks each item for conditions that indicate it is stuck:
   1. Max retries exceeded
   2. Same checkpoint for consecutive sessions
-  3. Stale or missing heartbeat (for in_progress features)
-  4. Dependency deadlock (depends on a failed feature)
+  3. Stale or missing heartbeat (for in_progress items)
+  4. Dependency deadlock (depends on a failed item)
 
 Outputs a JSON report to stdout and exits with code 1 if any stuck
-features are found, 0 otherwise.
+items are found, 0 otherwise.
 
 Usage:
-    python3 detect-stuck.py --state-dir <path> [--feature-id <id>]
+    python3 detect-stuck.py --state-dir <path> --pipeline-type feature [--item-id <id>]
                             [--max-retries <n>] [--stale-threshold <seconds>]
+                            [--task-list <path>]
+
+    # Legacy feature-only args still supported:
+    python3 detect-stuck.py --state-dir <path> [--feature-id <id>]
                             [--feature-list <path>]
 """
 
@@ -30,23 +34,45 @@ LOGGER = setup_logging("detect-stuck")
 
 def parse_args():
     parser = argparse.ArgumentParser(
-        description="Detect stuck features in the dev-pipeline."
+        description="Detect stuck items in the dev-pipeline."
     )
     parser.add_argument(
         "--state-dir",
         required=True,
-        help="Path to the state directory (default: .prizmkit/state/features)",
+        help="Path to the state directory (e.g. .prizmkit/state/features)",
+    )
+    parser.add_argument(
+        "--pipeline-type",
+        choices=["feature", "bugfix", "refactor"],
+        default=None,
+        help="Pipeline type (auto-detected from --feature-id/--bug-id/--refactor-id if omitted)",
+    )
+    parser.add_argument(
+        "--item-id",
+        default=None,
+        help="Check a specific item ID, or check all if omitted",
     )
+    # Legacy feature-only args (still supported for backward compat)
     parser.add_argument(
         "--feature-id",
         default=None,
-        help="Check a specific feature ID, or check all if omitted",
+        help="(Legacy) Feature ID — equivalent to --pipeline-type feature --item-id <id>",
+    )
+    parser.add_argument(
+        "--bug-id",
+        default=None,
+        help="Bug ID — equivalent to --pipeline-type bugfix --item-id <id>",
+    )
+    parser.add_argument(
+        "--refactor-id",
+        default=None,
+        help="Refactor ID — equivalent to --pipeline-type refactor --item-id <id>",
     )
     parser.add_argument(
         "--max-retries",
         type=int,
         default=3,
-        help="Maximum allowed retries before a feature is considered stuck (default: 3)",
+        help="Maximum allowed retries before an item is considered stuck (default: 3)",
     )
     parser.add_argument(
         "--stale-threshold",
@@ -57,7 +83,22 @@ def parse_args():
     parser.add_argument(
         "--feature-list",
         default=None,
-        help="Path to .prizmkit/plans/feature-list.json (overrides pipeline.json reference)",
+        help="(Legacy) Path to feature-list.json — use --task-list instead",
+    )
+    parser.add_argument(
+        "--bug-list",
+        default=None,
+        help="Path to bug-fix-list.json",
+    )
+    parser.add_argument(
+        "--refactor-list",
+        default=None,
+        help="Path to refactor-list.json",
+    )
+    parser.add_argument(
+        "--task-list",
+        default=None,
+        help="Path to the task list JSON (feature-list, bug-fix-list, or refactor-list)",
     )
     return parser.parse_args()
 
@@ -71,25 +112,25 @@ def load_json(path):
         return None
 
 
-def discover_feature_ids(state_dir):
-    """Return a sorted list of feature IDs found in state/features/."""
-    features_dir = os.path.join(state_dir, "features")
-    if not os.path.isdir(features_dir):
+def discover_item_ids(state_dir, subdir):
+    """Return a sorted list of item IDs found in state/{subdir}/."""
+    items_dir = os.path.join(state_dir, subdir)
+    if not os.path.isdir(items_dir):
         return []
     ids = []
-    for name in os.listdir(features_dir):
-        feature_path = os.path.join(features_dir, name)
-        if os.path.isdir(feature_path):
+    for name in os.listdir(items_dir):
+        item_path = os.path.join(items_dir, name)
+        if os.path.isdir(item_path):
             ids.append(name)
     return sorted(ids)
 
 
-def get_session_statuses(feature_dir):
-    """Return session-status.json data for all sessions of a feature, sorted by session ID.
+def get_session_statuses(item_dir):
+    """Return session-status.json data for all sessions of an item, sorted by session ID.
 
     Returns a list of (session_id, data) tuples.
     """
-    sessions_dir = os.path.join(feature_dir, "sessions")
+    sessions_dir = os.path.join(item_dir, "sessions")
     if not os.path.isdir(sessions_dir):
         return []
     results = []
@@ -138,12 +179,12 @@ def parse_iso_timestamp(ts_str):
     return None
 
 
-def check_max_retries(feature_status, max_retries):
-    """Check 1: Has the feature exceeded the maximum retry count?
+def check_max_retries(item_status, max_retries):
+    """Check 1: Has the item exceeded the maximum retry count?
 
     Returns a stuck-report dict or None.
     """
-    retry_count = feature_status.get("retry_count", 0)
+    retry_count = item_status.get("retry_count", 0)
     if not isinstance(retry_count, int):
         return None
     if retry_count >= max_retries:
@@ -152,17 +193,17 @@ def check_max_retries(feature_status, max_retries):
             "details": "Retry count {} has reached or exceeded max retries {}".format(
                 retry_count, max_retries
             ),
-            "suggestion": "Investigate recurring failures and consider resetting the feature or adjusting the approach",
+            "suggestion": "Investigate recurring failures and consider resetting the item or adjusting the approach",
         }
     return None
 
 
-def check_stuck_checkpoint(feature_dir):
-    """Check 2: Is the feature stuck at the same checkpoint for 3 consecutive sessions?
+def check_stuck_checkpoint(item_dir):
+    """Check 2: Is the item stuck at the same checkpoint for 3 consecutive sessions?
 
     Returns a stuck-report dict or None.
     """
-    session_statuses = get_session_statuses(feature_dir)
+    session_statuses = get_session_statuses(item_dir)
     if len(session_statuses) < 3:
         return None
 
@@ -185,34 +226,36 @@ def check_stuck_checkpoint(feature_dir):
     return None
 
 
-def check_stale_heartbeat(feature_id, feature_status, state_dir, stale_threshold):
-    """Check 3: Is the heartbeat stale or missing for an in_progress feature?
+def check_stale_heartbeat(item_id, item_status, state_dir, items_subdir, stale_threshold):
+    """Check 3: Is the heartbeat stale or missing for an in_progress item?
 
-    Only applies to features whose status is 'in_progress'.
-    Uses last_session_id from the feature's own status to find the active session.
+    Only applies to items whose status indicates active work.
+    Uses last_session_id from the item's own status to find the active session.
 
     Returns a stuck-report dict or None.
     """
-    status = feature_status.get("status")
-    if status != "in_progress":
+    status = item_status.get("status")
+    # All pipelines now use "in_progress" as the active status
+    in_progress_statuses = {"in_progress"}
+    if status not in in_progress_statuses:
         return None
 
-    # Use last_session_id from the feature's own status
-    session_id = feature_status.get("last_session_id")
+    # Use last_session_id from the item's own status
+    session_id = item_status.get("last_session_id")
     if not session_id:
         return None
 
     # Check heartbeat file
     heartbeat_path = os.path.join(
-        state_dir, "features", feature_id, "sessions", session_id, "heartbeat.json"
+        state_dir, items_subdir, item_id, "sessions", session_id, "heartbeat.json"
     )
     heartbeat = load_json(heartbeat_path)
 
     if heartbeat is None:
         return {
             "reason": "no_heartbeat",
-            "details": "Feature is in_progress but no heartbeat.json found for session {}".format(
-                session_id
+            "details": "Item is {} but no heartbeat.json found for session {}".format(
+                status, session_id
             ),
             "suggestion": "The agent session may have crashed without writing a heartbeat - check session logs",
         }
@@ -241,25 +284,25 @@ def check_stale_heartbeat(feature_id, feature_status, state_dir, stale_threshold
     return None
 
 
-def check_dependency_deadlock(feature_id, feature_list_data, state_dir):
-    """Check 4: Does this feature depend on a failed feature?
+def check_dependency_deadlock(item_id, task_list_data, state_dir, items_subdir, items_key):
+    """Check 4: Does this item depend on a failed item?
 
     Returns a stuck-report dict or None.
     """
-    if feature_list_data is None:
+    if task_list_data is None:
         return None
 
-    features = feature_list_data.get("features", [])
-    if not isinstance(features, list):
+    items = task_list_data.get(items_key, [])
+    if not isinstance(items, list):
         return None
 
-    # Find this feature in the feature list to get its dependencies
+    # Find this item in the list to get its dependencies
     deps = None
-    for f in features:
-        if not isinstance(f, dict):
+    for item in items:
+        if not isinstance(item, dict):
             continue
-        if f.get("id") == feature_id:
-            deps = f.get("dependencies", [])
+        if item.get("id") == item_id:
+            deps = item.get("dependencies", [])
             break
 
     if not deps or not isinstance(deps, list):
@@ -268,7 +311,7 @@ def check_dependency_deadlock(feature_id, feature_list_data, state_dir):
     # Check each dependency's status in state
     for dep_id in deps:
         dep_status_path = os.path.join(
-            state_dir, "features", dep_id, "status.json"
+            state_dir, items_subdir, dep_id, "status.json"
         )
         dep_status = load_json(dep_status_path)
         if dep_status is None:
@@ -278,16 +321,16 @@ def check_dependency_deadlock(feature_id, feature_list_data, state_dir):
             return {
                 "reason": "dependency_failed",
                 "details": "Depends on {} which has status 'failed'".format(dep_id),
-                "suggestion": "Fix or skip {} to unblock {}".format(dep_id, feature_id),
+                "suggestion": "Fix or skip {} to unblock {}".format(dep_id, item_id),
             }
 
     return None
 
 
-def find_feature_list(state_dir):
-    """Attempt to locate and load .prizmkit/plans/feature-list.json via pipeline.json reference.
+def find_task_list(state_dir):
+    """Attempt to locate and load the task list JSON via pipeline.json reference.
 
-    Resolves feature_list_path relative to state_dir when it is a relative path,
+    Resolves the list path relative to state_dir when it is a relative path,
     so that pipeline.json is portable across machines and directory structures.
     """
     pipeline_path = os.path.join(state_dir, "pipeline.json")
@@ -295,7 +338,12 @@ def find_feature_list(state_dir):
     if pipeline is None:
         return None
 
-    fl_path = pipeline.get("feature_list_path")
+    # Try various path keys used by different pipeline types
+    fl_path = (
+        pipeline.get("feature_list_path")
+        or pipeline.get("bug_list_path")
+        or pipeline.get("refactor_list_path")
+    )
     if not fl_path:
         return None
 
@@ -310,44 +358,98 @@ def find_feature_list(state_dir):
     return None
 
 
-def check_feature(feature_id, state_dir, feature_list_data, max_retries, stale_threshold):
-    """Run all stuck-detection checks on a single feature.
+# Pipeline type configurations
+PIPELINE_CONFIG = {
+    "feature": {"subdir": "features", "items_key": "features", "id_label": "feature_id"},
+    "bugfix": {"subdir": "bugs", "items_key": "bugs", "id_label": "bug_id"},
+    "refactor": {"subdir": "refactors", "items_key": "refactors", "id_label": "refactor_id"},
+}
+
 
-    Returns a list of stuck-report dicts (may be empty if feature is not stuck).
+def check_item(item_id, state_dir, items_subdir, items_key, task_list_data, max_retries, stale_threshold):
+    """Run all stuck-detection checks on a single item.
+
+    Returns a list of stuck-report dicts (may be empty if item is not stuck).
     """
-    feature_dir = os.path.join(state_dir, "features", feature_id)
-    status_path = os.path.join(feature_dir, "status.json")
-    feature_status = load_json(status_path)
+    item_dir = os.path.join(state_dir, items_subdir, item_id)
+    status_path = os.path.join(item_dir, "status.json")
+    item_status = load_json(status_path)
 
-    if feature_status is None:
+    if item_status is None:
         # Cannot read status — skip silently
         return []
 
     reports = []
 
     # Check 1: Max retries exceeded
-    result = check_max_retries(feature_status, max_retries)
+    result = check_max_retries(item_status, max_retries)
     if result is not None:
         reports.append(result)
 
     # Check 2: Stuck at same checkpoint
-    result = check_stuck_checkpoint(feature_dir)
+    result = check_stuck_checkpoint(item_dir)
     if result is not None:
         reports.append(result)
 
     # Check 3: Stale heartbeat
-    result = check_stale_heartbeat(feature_id, feature_status, state_dir, stale_threshold)
+    result = check_stale_heartbeat(item_id, item_status, state_dir, items_subdir, stale_threshold)
     if result is not None:
         reports.append(result)
 
     # Check 4: Dependency deadlock
-    result = check_dependency_deadlock(feature_id, feature_list_data, state_dir)
+    result = check_dependency_deadlock(item_id, task_list_data, state_dir, items_subdir, items_key)
     if result is not None:
         reports.append(result)
 
     return reports
 
 
+def resolve_pipeline_type(args):
+    """Resolve pipeline type, item ID, and task list path from args.
+
+    Supports both new generic args and legacy feature-only args.
+    Returns (pipeline_type, item_id, task_list_path).
+    """
+    # Explicit --pipeline-type takes precedence
+    if args.pipeline_type:
+        ptype = args.pipeline_type
+        item_id = args.item_id
+        task_list = args.task_list
+    # Legacy / shorthand: --feature-id, --bug-id, --refactor-id
+    elif args.feature_id:
+        ptype = "feature"
+        item_id = args.feature_id
+        task_list = args.feature_list or args.task_list
+    elif args.bug_id:
+        ptype = "bugfix"
+        item_id = args.bug_id
+        task_list = args.bug_list or args.task_list
+    elif args.refactor_id:
+        ptype = "refactor"
+        item_id = args.refactor_id
+        task_list = args.refactor_list or args.task_list
+    # Legacy: --feature-list without --feature-id means check all features
+    elif args.feature_list:
+        ptype = "feature"
+        item_id = None
+        task_list = args.feature_list
+    elif args.bug_list:
+        ptype = "bugfix"
+        item_id = None
+        task_list = args.bug_list
+    elif args.refactor_list:
+        ptype = "refactor"
+        item_id = None
+        task_list = args.refactor_list
+    else:
+        # Default to feature for backward compat
+        ptype = "feature"
+        item_id = None
+        task_list = args.task_list
+
+    return ptype, item_id, task_list
+
+
 def main():
     args = parse_args()
     state_dir = os.path.abspath(args.state_dir)
@@ -355,28 +457,35 @@ def main():
     if not os.path.isdir(state_dir):
         error_out("State directory not found: {}".format(state_dir), code=2)
 
-    # Determine which features to check
-    if args.feature_id:
-        feature_ids = [args.feature_id]
+    # Resolve pipeline type and parameters
+    ptype, item_id, task_list_path = resolve_pipeline_type(args)
+    config = PIPELINE_CONFIG[ptype]
+    items_subdir = config["subdir"]
+    items_key = config["items_key"]
+    id_label = config["id_label"]
+
+    # Determine which items to check
+    if item_id:
+        item_ids = [item_id]
     else:
-        feature_ids = discover_feature_ids(state_dir)
+        item_ids = discover_item_ids(state_dir, items_subdir)
 
-    # Load feature list for dependency checks
-    # Prefer CLI-provided path; fall back to pipeline.json reference
-    if args.feature_list:
-        feature_list_data = load_json(os.path.abspath(args.feature_list))
+    # Load task list for dependency checks
+    if task_list_path:
+        task_list_data = load_json(os.path.abspath(task_list_path))
     else:
-        feature_list_data = find_feature_list(state_dir)
+        task_list_data = find_task_list(state_dir)
 
-    stuck_features = []
-    for fid in feature_ids:
-        reports = check_feature(
-            fid, state_dir, feature_list_data, args.max_retries, args.stale_threshold
+    stuck_items = []
+    for iid in item_ids:
+        reports = check_item(
+            iid, state_dir, items_subdir, items_key,
+            task_list_data, args.max_retries, args.stale_threshold
         )
         for report in reports:
-            stuck_features.append(
+            stuck_items.append(
                 {
-                    "feature_id": fid,
+                    id_label: iid,
                     "reason": report["reason"],
                     "details": report["details"],
                     "suggestion": report["suggestion"],
@@ -384,14 +493,15 @@ def main():
             )
 
     output = {
-        "stuck_features": stuck_features,
-        "total_checked": len(feature_ids),
-        "stuck_count": len(stuck_features),
+        "pipeline_type": ptype,
+        "stuck_items": stuck_items,
+        "total_checked": len(item_ids),
+        "stuck_count": len(stuck_items),
     }
 
     print(json.dumps(output, indent=2, ensure_ascii=False))
 
-    if stuck_features:
+    if stuck_items:
         sys.exit(1)
     else:
         sys.exit(0)

package/bundled/dev-pipeline/scripts/generate-bootstrap-prompt.py

@@ -274,7 +274,12 @@ def format_global_context(global_context, project_root=None):
 
 
 def get_completed_dependencies(features, feature):
-    """Look up dependency features and list those with status=completed."""
+    """Look up dependency features and list those with status=completed.
+
+    When a completed dependency has completion_notes (written by the AI
+    session and propagated by the pipeline runner), include them as rich
+    context so the downstream session knows what was built.
+    """
     deps = feature.get("dependencies", [])
     if not deps:
         return "- (no dependencies)"
@@ -285,17 +290,26 @@ def get_completed_dependencies(features, feature):
         if isinstance(f, dict) and "id" in f:
             feature_map[f["id"]] = f
 
-    completed = []
+    sections = []
     for dep_id in deps:
         dep = feature_map.get(dep_id)
         if dep and dep.get("status") == "completed":
-            completed.append("- {} - {} (completed)".format(
+            header = "- **{}** — {} (completed)".format(
                 dep_id, dep.get("title", "Untitled")
-            ))
+            )
+            notes = dep.get("completion_notes", [])
+            if notes and isinstance(notes, list):
+                note_lines = "\n".join(
+                    "  - {}".format(n) for n in notes
+                    if isinstance(n, str) and n.strip()
+                )
+                if note_lines:
+                    header += "\n" + note_lines
+            sections.append(header)
 
-    if not completed:
+    if not sections:
         return "- (no completed dependencies yet)"
-    return "\n".join(completed)
+    return "\n".join(sections)
 
 
 def get_prev_session_status(state_dir, feature_id):
@@ -561,7 +575,6 @@ SECTION_TO_SKILL = {
                             ".prizmkit/specs/{slug}/plan.md"]),
     "phase-plan": ("prizmkit-plan", "Plan & Tasks",
                    [".prizmkit/specs/{slug}/plan.md"]),
-    "phase-analyze": ("prizmkit-analyze", "Analyze", []),
     "phase-critic-plan": ("critic-plan-review", "Critic: Plan Review", []),
     "phase-implement": ("prizmkit-implement", "Implement + Test", []),
     "phase-critic-code": ("critic-code-review", "Critic: Code Review", []),
@@ -957,16 +970,6 @@ def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
                               load_section(sections_dir,
                                            "phase-plan-agent.md")))
 
-    # --- Analyze (only for agent tiers) ---
-    if pipeline_mode == "standard":
-        sections.append(("phase-analyze",
-                          load_section(sections_dir,
-                                       "phase-analyze-agent.md")))
-    elif pipeline_mode == "full":
-        sections.append(("phase-analyze",
-                          load_section(sections_dir,
-                                       "phase-analyze-full.md")))
-
     # --- Critic: Plan Challenge (only if critic enabled) ---
     if critic_enabled:
         if pipeline_mode == "full":
@@ -992,12 +995,23 @@ def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
                           load_section(sections_dir,
                                        "phase-implement-agent.md")))
 
+    # --- Test Failure Recovery Protocol (all tiers) ---
+    sections.append(("test-failure-recovery",
+                      load_section(sections_dir, "test-failure-recovery.md")))
+
     # --- Critic: Code Challenge (only if critic enabled, agent tiers) ---
     if critic_enabled and pipeline_mode in ("standard", "full"):
         sections.append(("phase-critic-code",
                           load_section(sections_dir,
                                        "phase-critic-code.md")))
 
+    # --- AC Verification Checklist (all tiers) ---
+    ac_checklist_path = os.path.join(sections_dir, "ac-verification-checklist.md")
+    if os.path.isfile(ac_checklist_path):
+        sections.append(("ac-verification-checklist",
+                          load_section(sections_dir,
+                                       "ac-verification-checklist.md")))
+
     # --- Review (only for agent tiers) ---
     if pipeline_mode == "full":
         sections.append(("phase-review",
@@ -1321,7 +1335,6 @@ def build_replacements(args, feature, features, global_context, script_dir):
         "{{DEV_SUBAGENT_PATH}}": dev_subagent,
         "{{REVIEWER_SUBAGENT_PATH}}": reviewer_subagent,
         "{{CRITIC_SUBAGENT_PATH}}": critic_subagent,
-        "{{VALIDATOR_SCRIPTS_DIR}}": validator_scripts_dir,
         "{{INIT_SCRIPT_PATH}}": init_script_path,
         "{{SESSION_STATUS_PATH}}": session_status_abs,
         "{{PROJECT_ROOT}}": project_root,
@@ -1336,7 +1349,6 @@ def build_replacements(args, feature, features, global_context, script_dir):
         "{{INIT_DONE}}": "true" if init_done else "false",
         "{{HAS_SPEC}}": "true" if artifacts["has_spec"] else "false",
         "{{HAS_PLAN}}": "true" if artifacts["has_plan"] else "false",
-        "{{ARTIFACTS_COMPLETE}}": "true" if artifacts["all_complete"] else "false",
         "{{BROWSER_URL}}": browser_url,
         "{{BROWSER_SETUP_COMMAND}}": browser_setup_command,
         "{{BROWSER_VERIFY_STEPS}}": browser_verify_steps,