prizmkit 1.1.111 → 1.1.113

package/bundled/dev-pipeline/scripts/init-bugfix-pipeline.py

@@ -15,6 +15,8 @@ import re
 import sys
 from datetime import datetime, timezone
 
+from utils import stable_topological_order
+
 
 EXPECTED_SCHEMA = "dev-pipeline-bug-fix-list-v1"
 BUG_ID_PATTERN = re.compile(r"^B-\d{3}$")
@@ -198,6 +200,38 @@ def validate_bugs(bugs):
                 )
             )
 
+        # Validate dependencies
+        deps = bug.get("dependencies")
+        if deps is not None and not isinstance(deps, list):
+            errors.append(
+                "Bug '{}' dependencies must be an array".format(
+                    bid or "index {}".format(i)
+                )
+            )
+        elif isinstance(deps, list):
+            for dep in deps:
+                if not isinstance(dep, str) or not BUG_ID_PATTERN.match(dep):
+                    errors.append(
+                        "Bug '{}' has invalid dependency '{}' "
+                        "(must match B-NNN pattern)".format(
+                            bid or "index {}".format(i), dep
+                        )
+                    )
+                elif dep == bid:
+                    errors.append(
+                        "Bug '{}' cannot depend on itself".format(
+                            bid or "index {}".format(i)
+                        )
+                    )
+
+    topo_errors = stable_topological_order(
+        bugs,
+        id_key="id",
+        dependencies_key="dependencies",
+        item_label="Bug",
+    )[1]
+    errors.extend(topo_errors)
+
     return errors, seen_ids
 
 

package/bundled/dev-pipeline/scripts/init-pipeline.py

@@ -16,6 +16,8 @@ import sys
 from collections import deque
 from datetime import datetime, timezone
 
+from utils import stable_topological_order
+
 
 EXPECTED_SCHEMA = "dev-pipeline-feature-list-v1"
 FEATURE_ID_PATTERN = re.compile(r"^F-\d{3}(-[A-Z])?$")
@@ -168,6 +170,16 @@ def validate_features(features):
                 errors.append(
                     "Feature '{}' depends on unknown feature '{}'".format(fid, dep)
                 )
+            elif dep == fid:
+                errors.append("Feature '{}' cannot depend on itself".format(fid))
+
+    topo_errors = stable_topological_order(
+        features,
+        id_key="id",
+        dependencies_key="dependencies",
+        item_label="Feature",
+    )[1]
+    errors.extend(topo_errors)
 
     return errors, feature_ids
 

package/bundled/dev-pipeline/scripts/init-refactor-pipeline.py

@@ -16,7 +16,7 @@ import re
 import sys
 from datetime import datetime, timezone
 
-from utils import load_json_file
+from utils import load_json_file, stable_topological_order
 
 
 EXPECTED_SCHEMA = "dev-pipeline-refactor-list-v1"
@@ -215,6 +215,29 @@ def validate_refactors(refactors):
                     rid or "index {}".format(i)
                 )
             )
+        elif isinstance(deps, list):
+            for dep in deps:
+                if not isinstance(dep, str) or not REFACTOR_ID_PATTERN.match(dep):
+                    errors.append(
+                        "Refactor '{}' has invalid dependency '{}' "
+                        "(must match R-NNN pattern)".format(
+                            rid or "index {}".format(i), dep
+                        )
+                    )
+                elif dep == rid:
+                    errors.append(
+                        "Refactor '{}' cannot depend on itself".format(
+                            rid or "index {}".format(i)
+                        )
+                    )
+
+    topo_errors = stable_topological_order(
+        refactors,
+        id_key="id",
+        dependencies_key="dependencies",
+        item_label="Refactor",
+    )[1]
+    errors.extend(topo_errors)
 
     return errors, seen_ids
 

package/bundled/dev-pipeline/scripts/prompt_framework.py

@@ -0,0 +1,312 @@
+"""Shared prompt rendering and checkpoint helpers for dev-pipeline generators.
+
+This module intentionally stays small: prompt phase ordering remains explicit in
+family-specific generators, while common rendering/checkpoint mechanics live here
+so feature, bugfix, and refactor prompts do not drift.
+"""
+
+import glob
+import os
+import re
+
+
+def read_text_file(path):
+    """Read and return the text content of a file, plus an error string."""
+    abs_path = os.path.abspath(path)
+    if not os.path.isfile(abs_path):
+        return None, "File not found: {}".format(abs_path)
+    try:
+        with open(abs_path, "r", encoding="utf-8") as f:
+            return f.read(), None
+    except IOError as exc:
+        return None, "Cannot read file: {}".format(str(exc))
+
+
+def load_section(sections_dir, name):
+    """Load a section file from the sections directory."""
+    path = os.path.join(sections_dir, name)
+    if not os.path.isfile(path):
+        raise FileNotFoundError("Section file not found: {}".format(path))
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def render_from_sections(sections, replacements):
+    """Join assembled sections and replace placeholders with two passes."""
+    content = "\n".join(text for _, text in sections if text is not None)
+    for _pass in range(2):
+        for placeholder, value in replacements.items():
+            content = content.replace(placeholder, str(value))
+    return content
+
+
+def replace_placeholders(content, replacements):
+    """Replace placeholders in arbitrary content with two passes."""
+    for _pass in range(2):
+        for placeholder, value in replacements.items():
+            content = content.replace(placeholder, str(value))
+    return content
+
+
+def validate_rendered(content, required_markers=None, logger=None):
+    """Validate rendered prompt content for placeholder and section drift."""
+    warnings = []
+    errors = []
+
+    unreplaced = re.findall(r"\{\{[A-Z][A-Z_0-9]+\}\}", content)
+    if unreplaced:
+        warnings.append(
+            "Unreplaced placeholders: {}".format(", ".join(sorted(set(unreplaced))))
+        )
+
+    unclosed_if = re.findall(r"\{\{(?:IF|END_IF)_[A-Z_]+\}\}", content)
+    if unclosed_if:
+        errors.append(
+            "Unclosed conditional blocks: {}".format(", ".join(sorted(set(unclosed_if))))
+        )
+
+    for marker, label in required_markers or []:
+        if marker not in content:
+            errors.append("Missing required section: {}".format(label))
+
+    if logger is not None:
+        for warning in warnings:
+            logger.warning("VALIDATE: %s", warning)
+        for error in errors:
+            logger.error("VALIDATE: %s", error)
+
+    return len(errors) == 0, warnings, errors
+
+
+def write_output(output_path, content):
+    """Write rendered prompt content to output_path."""
+    abs_path = os.path.abspath(output_path)
+    output_dir = os.path.dirname(abs_path)
+    if output_dir and not os.path.isdir(output_dir):
+        try:
+            os.makedirs(output_dir, exist_ok=True)
+        except OSError as exc:
+            return "Cannot create output directory: {}".format(str(exc))
+    try:
+        with open(abs_path, "w", encoding="utf-8") as f:
+            f.write(content)
+    except IOError as exc:
+        return "Cannot write output file: {}".format(str(exc))
+    return None
+
+
+def resolve_artifacts(artifact_templates, slug):
+    """Replace {slug} placeholders in checkpoint artifact templates."""
+    return [artifact.replace("{slug}", slug) for artifact in artifact_templates]
+
+
+def artifact_exists(project_root, artifact):
+    """Return whether an artifact path or glob exists under project_root."""
+    full_path = os.path.join(project_root, artifact)
+    if glob.has_magic(full_path):
+        return bool(glob.glob(full_path))
+    return os.path.exists(full_path)
+
+
+def completed_step_artifacts_valid(project_root, artifacts):
+    """Return whether generic completed-step artifacts are present."""
+    return all(artifact_exists(project_root, artifact) for artifact in artifacts)
+
+
+def generate_checkpoint_from_sections(
+    sections,
+    step_mapping,
+    pipeline_mode,
+    workflow_type,
+    item_id,
+    item_slug,
+    session_id,
+    *,
+    init_done=False,
+    split_steps=None,
+):
+    """Generate a linear checkpoint definition from assembled prompt sections."""
+    steps = []
+    step_counter = 1
+    prev_step_id = None
+    split_steps = split_steps or {}
+
+    for section_name, _content in sections:
+        if section_name not in step_mapping:
+            continue
+
+        mapping = step_mapping[section_name]
+        if mapping is None:
+            for skill, name, artifacts in split_steps.get(section_name, []):
+                step_id = "S{:02d}".format(step_counter)
+                steps.append({
+                    "id": step_id,
+                    "skill": skill,
+                    "name": name,
+                    "status": "pending",
+                    "required_artifacts": resolve_artifacts(artifacts, item_slug),
+                    "depends_on": prev_step_id,
+                })
+                prev_step_id = step_id
+                step_counter += 1
+            continue
+
+        skill, name, artifacts = mapping
+        step_id = "S{:02d}".format(step_counter)
+        status = "pending"
+        if init_done and section_name in ("phase0-init", "phase0-test-baseline"):
+            status = "skipped"
+
+        steps.append({
+            "id": step_id,
+            "skill": skill,
+            "name": name,
+            "status": status,
+            "required_artifacts": resolve_artifacts(artifacts, item_slug),
+            "depends_on": prev_step_id,
+        })
+        prev_step_id = step_id
+        step_counter += 1
+
+    return {
+        "version": 1,
+        "workflow_type": workflow_type,
+        "pipeline_mode": pipeline_mode,
+        "item_id": item_id,
+        "item_slug": item_slug,
+        "session_id": session_id,
+        "steps": steps,
+    }
+
+
+def merge_checkpoint_state(existing, fresh, project_root, validator=None, logger=None):
+    """Merge existing checkpoint state into a freshly generated definition."""
+    validator = validator or (lambda _skill, artifacts: completed_step_artifacts_valid(project_root, artifacts))
+    existing_status = {}
+    existing_artifacts = {}
+    fresh_artifacts = {
+        step["skill"]: step.get("required_artifacts", [])
+        for step in fresh.get("steps", [])
+    }
+
+    for step in existing.get("steps", []):
+        existing_status[step["skill"]] = step.get("status", "pending")
+        existing_artifacts[step["skill"]] = step.get("required_artifacts", [])
+
+    valid_completed = set()
+    for skill_key, status in existing_status.items():
+        if status == "completed":
+            artifacts = fresh_artifacts.get(skill_key, existing_artifacts.get(skill_key, []))
+            if validator(skill_key, artifacts):
+                valid_completed.add(skill_key)
+            elif logger is not None:
+                logger.warning(
+                    "Step '%s' was completed but artifacts missing — resetting to pending",
+                    skill_key,
+                )
+        elif status == "skipped":
+            valid_completed.add(skill_key)
+
+    chain_broken = False
+    for step in fresh.get("steps", []):
+        if chain_broken:
+            step["status"] = "pending"
+            continue
+        previous = existing_status.get(step["skill"])
+        if step["skill"] in valid_completed:
+            step["status"] = previous
+        else:
+            chain_broken = True
+            step["status"] = "pending"
+
+    return fresh
+
+
+def determine_mode_from_complexity(value):
+    """Map a coarse complexity/severity value to lite/standard/full."""
+    mapping = {
+        "low": "lite",
+        "medium": "lite",
+        "minor": "lite",
+        "high": "standard",
+        "major": "standard",
+        "critical": "full",
+    }
+    return mapping.get(str(value or "").lower(), "lite")
+
+
+def normalize_mode(value, default="lite"):
+    """Normalize a mode string to lite/standard/full."""
+    value = str(value or "").lower()
+    return value if value in {"lite", "standard", "full"} else default
+
+
+def mode_agent_count(pipeline_mode, critic_enabled=False, critic_count=1):
+    """Return the prompt metadata agent count for a mode."""
+    base = {"lite": 1, "standard": 3, "full": 3}.get(pipeline_mode, 1)
+    return base + (int(critic_count or 1) if critic_enabled else 0)
+
+
+def detect_dev_server_port(project_root):
+    """Return a detected dev-server port string, or an unknown placeholder."""
+    unknown = "<UNKNOWN_DETECT_FROM_PROJECT_CONFIG>"
+    pkg_path = os.path.join(project_root, "package.json")
+    try:
+        if os.path.isfile(pkg_path):
+            import json
+            with open(pkg_path, "r", encoding="utf-8") as f:
+                pkg = json.load(f)
+            scripts = pkg.get("scripts", {}) if isinstance(pkg, dict) else {}
+            dev_script = scripts.get("dev", "")
+            port_match = re.search(r"(?:-p|--port)\s+([0-9]+)", dev_script)
+            if port_match:
+                return port_match.group(1)
+        for env_file in [".env.local", ".env"]:
+            env_path = os.path.join(project_root, env_file)
+            if not os.path.isfile(env_path):
+                continue
+            with open(env_path, "r", encoding="utf-8") as env:
+                for line in env:
+                    match = re.match(r"[A-Z0-9_]*(?:URL|ORIGIN|HOST)\s*=\s*.*?:([0-9]+)", line.strip())
+                    if match:
+                        return match.group(1)
+    except Exception:
+        return unknown
+    return unknown
+
+
+def browser_enabled_from_item(item):
+    """Return browser enabled/tool/steps with mandatory-attempt defaults."""
+    browser_interaction = item.get("browser_interaction") if isinstance(item, dict) else None
+    env_value = os.environ.get("BROWSER_VERIFY", "").lower()
+    if env_value == "false":
+        return False, "auto", "", False
+
+    enabled = True
+    tool = "auto"
+    blocking = False
+    steps = []
+
+    if isinstance(browser_interaction, bool):
+        enabled = browser_interaction
+    elif isinstance(browser_interaction, dict):
+        enabled = browser_interaction.get("enabled", True)
+        tool = browser_interaction.get("tool", "auto")
+        blocking = bool(browser_interaction.get("blocking", False))
+        steps = browser_interaction.get("verify_steps", []) or []
+
+    if tool not in ("playwright-cli", "opencli", "auto"):
+        tool = "auto"
+
+    if steps:
+        rendered_steps = "\n".join(
+            "   # Goal {}: {}".format(index + 1, step)
+            for index, step in enumerate(steps)
+        )
+    else:
+        rendered_steps = (
+            "   # (mandatory attempt: discover whether this project exposes "
+            "a browser-verifiable app; verify relevant behavior if applicable)"
+        )
+
+    return enabled, tool, rendered_steps, blocking

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

@@ -3,7 +3,7 @@
 
 Handles eight actions:
   - get_next: Find the next bug to process based on priority and severity
-  - start: Mark a bug as fixing when a session starts
+  - start: Mark a bug as in_progress when a session starts
   - update: Update a bug's status based on session outcome
   - status: Print a formatted overview of all bugs
   - pause: Save pipeline state for graceful shutdown
@@ -31,6 +31,8 @@ from utils import (
     error_out,
     pad_right,
     _build_progress_bar,
+    read_checkpoint_cursor,
+    dependency_rank_map,
 )
 
 
@@ -215,6 +217,36 @@ def reset_continuation_metadata(status_data):
 STALL_REASON = "context_overflow_without_git_checkpoint_or_artifact_progress"
 
 
+def _read_bugfix_checkpoint_phase(project_root, bug_id):
+    """Read the phase index from the bugfix checkpoint file.
+
+    Returns an integer step index (e.g., 3 for S03) or None if the checkpoint
+    is not available. The value is consumed by the terminal status display as
+    ``CP-BF-<n>``.
+    """
+    checkpoint_path = os.path.join(
+        os.path.abspath(project_root) if project_root else _default_project_root(),
+        ".prizmkit", "bugfix", bug_id, "workflow-checkpoint.json",
+    )
+    return read_checkpoint_cursor(checkpoint_path)
+
+
+def _checkpoint_phase_or_cached(project_root, bug_id, status_data):
+    """Return live checkpoint phase, falling back to cached status data."""
+    checkpoint_phase = _read_bugfix_checkpoint_phase(project_root, bug_id)
+    if checkpoint_phase is not None:
+        return checkpoint_phase
+    return status_data.get("resume_from_phase")
+
+
+def _sync_checkpoint_phase(project_root, bug_id, status_data):
+    """Cache live checkpoint phase in status.json runtime data."""
+    status_data["resume_from_phase"] = _read_bugfix_checkpoint_phase(
+        project_root, bug_id,
+    )
+    return status_data.get("resume_from_phase")
+
+
 def _load_progress_fingerprint(raw):
     if not raw:
         return None
@@ -298,13 +330,14 @@ def continuation_metadata_summary(status_data):
 # Action: get_next
 # ---------------------------------------------------------------------------
 
-def action_get_next(bug_list_data, state_dir):
+def action_get_next(bug_list_data, state_dir, project_root=None):
     """Find the next bug to process.
 
     Priority logic:
     1. Skip terminal statuses (completed, failed, skipped, needs_info)
-    2. Prefer in_progress bugs (interrupted session resume) over pending
-    3. Sort by: severity (critical > high > medium > low), then by priority (high > medium > low)
+    2. Only consider bugs whose dependencies are all completed
+    3. Prefer in_progress bugs (interrupted session resume) over pending
+    4. Within each status class, use stable topological list order
     """
     bugs = bug_list_data.get("bugs", [])
     if not bugs:
@@ -324,6 +357,16 @@ def action_get_next(bug_list_data, state_dir):
         bs = load_bug_status(state_dir, bid)
         status_data_map[bid] = bs
 
+    topo_rank, topo_errors = dependency_rank_map(
+        bugs,
+        id_key="id",
+        dependencies_key="dependencies",
+        item_label="Bug",
+    )
+    if topo_errors:
+        print("PIPELINE_BLOCKED")
+        return
+
     # Check if all bugs are terminal
     non_terminal = [
         b for b in bugs
@@ -334,10 +377,22 @@ def action_get_next(bug_list_data, state_dir):
         print("PIPELINE_COMPLETE")
         return
 
+    eligible = []
+    for bug in non_terminal:
+        deps = bug.get("dependencies", [])
+        if not isinstance(deps, list):
+            continue
+        if all(status_map.get(dep_id, "pending") == "completed" for dep_id in deps):
+            eligible.append(bug)
+
+    if not eligible:
+        print("PIPELINE_BLOCKED")
+        return
+
     # Separate in_progress from pending
     in_progress_bugs = []
     pending_bugs = []
-    for bug in non_terminal:
+    for bug in eligible:
         bid = bug.get("id")
         bstatus = status_map.get(bid, "pending")
         if bstatus == "in_progress":
@@ -345,18 +400,16 @@ def action_get_next(bug_list_data, state_dir):
         elif bstatus == "pending":
             pending_bugs.append(bug)
 
-    _PRIORITY_ORDER = {"high": 0, "medium": 1, "low": 2}
-
-    def sort_key(b):
-        severity = b.get("severity", "medium")
-        sev_order = SEVERITY_PRIORITY.get(severity, 2)
-        priority = _PRIORITY_ORDER.get(b.get("priority", "low"), 2)
-        return (sev_order, priority)
-
     if in_progress_bugs:
-        candidates = sorted(in_progress_bugs, key=sort_key)
+        candidates = sorted(
+            in_progress_bugs,
+            key=lambda b: topo_rank.get(b.get("id"), len(bugs))
+        )
     elif pending_bugs:
-        candidates = sorted(pending_bugs, key=sort_key)
+        candidates = sorted(
+            pending_bugs,
+            key=lambda b: topo_rank.get(b.get("id"), len(bugs))
+        )
     else:
         # All remaining bugs are in non-terminal but also non-pending/in_progress states
         print("PIPELINE_BLOCKED")
@@ -365,6 +418,10 @@ def action_get_next(bug_list_data, state_dir):
     chosen = candidates[0]
     chosen_id = chosen["id"]
     chosen_status_data = status_data_map.get(chosen_id, {})
+    project_root = os.path.abspath(project_root) if project_root else _default_project_root()
+    resume_phase = _checkpoint_phase_or_cached(
+        project_root, chosen_id, chosen_status_data,
+    )
 
     result = {
         "bug_id": chosen_id,
@@ -372,7 +429,7 @@ def action_get_next(bug_list_data, state_dir):
         "severity": chosen.get("severity", "medium"),
         "retry_count": chosen_status_data.get("retry_count", 0),
         "infra_error_count": chosen_status_data.get("infra_error_count", 0),
-        "resume_from_phase": chosen_status_data.get("resume_from_phase", None),
+        "resume_from_phase": resume_phase,
     }
     result.update(continuation_metadata_summary(chosen_status_data))
     print(json.dumps(result, indent=2, ensure_ascii=False))
@@ -502,6 +559,10 @@ def action_update(args, bug_list_path, state_dir):
         bs["last_session_id"] = session_id
 
     bs["updated_at"] = now_iso()
+    # Sync resume_from_phase from checkpoint (single source of truth)
+    _sync_checkpoint_phase(
+        args.project_root or _default_project_root(), bug_id, bs,
+    )
 
     err = save_bug_status(state_dir, bug_id, bs)
     if err:
@@ -676,9 +737,10 @@ SEVERITY_ICONS = {
 }
 
 
-def action_status(bug_list_data, state_dir):
+def action_status(bug_list_data, state_dir, project_root=None):
     bugs = bug_list_data.get("bugs", [])
     project_name = bug_list_data.get("project_name", "Unknown")
+    project_root = os.path.abspath(project_root) if project_root else _default_project_root()
 
     counts = {"completed": 0, "in_progress": 0, "failed": 0, "pending": 0, "needs_info": 0, "skipped": 0}
     bug_lines = []
@@ -696,7 +758,12 @@ def action_status(bug_list_data, state_dir):
         bs = load_bug_status(state_dir, bid)
         retry_count = bs.get("retry_count", 0)
         max_retries_val = bs.get("max_retries", 3)
-        resume_phase = bs.get("resume_from_phase")
+        # Read phase cursor from checkpoint (single source of truth). The
+        # status.json field is only a cache/fallback for missing checkpoints.
+        resume_phase = _checkpoint_phase_or_cached(project_root, bid, bs)
+        if resume_phase != bs.get("resume_from_phase"):
+            bs["resume_from_phase"] = resume_phase
+            save_bug_status(state_dir, bid, bs)
 
         if bstatus in counts:
             counts[bstatus] += 1
@@ -1096,13 +1163,13 @@ def main():
         error_out("Cannot load bug fix list: {}".format(err))
 
     if args.action == "get_next":
-        action_get_next(bug_list_data, args.state_dir)
+        action_get_next(bug_list_data, args.state_dir, args.project_root)
     elif args.action == "start":
         action_start(args, args.bug_list, args.state_dir)
     elif args.action == "update":
         action_update(args, args.bug_list, args.state_dir)
     elif args.action == "status":
-        action_status(bug_list_data, args.state_dir)
+        action_status(bug_list_data, args.state_dir, args.project_root)
     elif args.action == "reset":
         action_reset(args, args.bug_list, args.state_dir)
     elif args.action == "clean":