prizmkit 1.1.99 → 1.1.101

package/bundled/skills-windows/bug-planner/scripts/validate-bug-list.py

@@ -1,322 +0,0 @@
-#!/usr/bin/env python3
-"""
-Validate and generate .prizmkit/plans/bug-fix-list.json files
-for the dev-pipeline system.
-
-Commands:
-  validate    Validate an existing bug-fix-list.json
-  generate    Validate a draft JSON and generate final bug-fix-list.json with defaults
-
-Usage:
-  python3 validate-bug-list.py validate .prizmkit/plans/bug-fix-list.json [--feature-list .prizmkit/plans/feature-list.json]
-  python3 validate-bug-list.py generate --input draft.json --output .prizmkit/plans/bug-fix-list.json
-
-Exit codes:
-  0 = valid / generated
-  1 = validation errors found
-  2 = file not found or JSON parse error
-
-Python 3.6+ required. No external dependencies.
-"""
-
-import argparse
-import json
-import sys
-import os
-import re
-from datetime import datetime, timezone
-
-VALID_SEVERITIES = {"critical", "high", "medium", "low"}
-VALID_SOURCE_TYPES = {"stack_trace", "user_report", "failed_test", "log_pattern", "monitoring_alert"}
-VALID_VERIFICATION_TYPES = {"automated", "manual", "hybrid"}
-VALID_STATUSES = {"pending", "triaging", "reproducing", "fixing", "verifying", "completed", "failed", "needs_info", "skipped"}
-BUG_ID_PATTERN = re.compile(r"^B-\d{3}$")
-SCHEMA_VERSION = "dev-pipeline-bug-fix-list-v1"
-
-
-def _err(msg):
-    """Print an error message to stderr."""
-    print("ERROR: {}".format(msg), file=sys.stderr)
-
-
-def _warn(msg):
-    """Print a warning message to stderr."""
-    print("WARN: {}".format(msg), file=sys.stderr)
-
-
-def _info(msg):
-    """Print an informational message to stderr."""
-    print("INFO: {}".format(msg), file=sys.stderr)
-
-
-def _load_json(path):
-    """Load and return parsed JSON from a file. Returns (data, error_string)."""
-    if not os.path.isfile(path):
-        return None, "File not found: {}".format(path)
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            data = json.load(f)
-        return data, None
-    except json.JSONDecodeError as e:
-        return None, "Invalid JSON in {}: {}".format(path, e)
-    except Exception as e:
-        return None, "Cannot read {}: {}".format(path, e)
-
-
-def _write_json(path, data):
-    """Write data as pretty-printed JSON to path. Creates parent dirs if needed."""
-    parent = os.path.dirname(os.path.abspath(path))
-    if parent and not os.path.isdir(parent):
-        os.makedirs(parent, exist_ok=True)
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(data, f, indent=2, ensure_ascii=False)
-        f.write("\n")
-
-
-def validate(data, feature_ids=None):
-    """Validate a parsed bug-fix-list data structure.
-
-    Returns a dict with keys: valid, errors, warnings, stats.
-    """
-    errors = []
-    warnings = []
-
-    # Top-level required fields
-    if "$schema" not in data:
-        errors.append("Missing required field: $schema")
-    elif data["$schema"] != SCHEMA_VERSION:
-        errors.append("Invalid $schema: expected '{}', got '{}'".format(SCHEMA_VERSION, data["$schema"]))
-
-    if not data.get("project_name"):
-        errors.append("Missing or empty required field: project_name")
-
-    bugs = data.get("bugs", [])
-    if not bugs or not isinstance(bugs, list):
-        errors.append("Missing or empty required field: bugs")
-        return {
-            "valid": False,
-            "errors": errors,
-            "warnings": warnings,
-            "stats": {"total_bugs": 0, "severity_distribution": {}},
-        }
-
-    # Per-bug validation
-    seen_ids = set()
-    severity_counts = {}
-
-    for i, bug in enumerate(bugs):
-        prefix = "bugs[{}]".format(i)
-
-        # Required fields
-        bug_id = bug.get("id", "")
-        if not bug_id:
-            errors.append("{}: missing required field 'id'".format(prefix))
-        elif not BUG_ID_PATTERN.match(bug_id):
-            errors.append("{}: id '{}' does not match pattern B-NNN".format(prefix, bug_id))
-
-        if bug_id in seen_ids:
-            errors.append("{}: duplicate bug id '{}'".format(prefix, bug_id))
-        seen_ids.add(bug_id)
-
-        if not bug.get("title"):
-            errors.append("{} ({}): missing required field 'title'".format(prefix, bug_id))
-
-        if not bug.get("description"):
-            errors.append("{} ({}): missing required field 'description'".format(prefix, bug_id))
-
-        severity = bug.get("severity", "")
-        if severity not in VALID_SEVERITIES:
-            errors.append("{} ({}): invalid severity '{}' — must be one of {}".format(
-                prefix, bug_id, severity, sorted(VALID_SEVERITIES)))
-        else:
-            severity_counts[severity] = severity_counts.get(severity, 0) + 1
-
-        # error_source
-        error_source = bug.get("error_source", {})
-        source_type = error_source.get("type", "") if isinstance(error_source, dict) else ""
-        if source_type not in VALID_SOURCE_TYPES:
-            errors.append("{} ({}): invalid error_source.type '{}' — must be one of {}".format(
-                prefix, bug_id, source_type, sorted(VALID_SOURCE_TYPES)))
-
-        # verification_type
-        vtype = bug.get("verification_type", "")
-        if vtype not in VALID_VERIFICATION_TYPES:
-            errors.append("{} ({}): invalid verification_type '{}' — must be one of {}".format(
-                prefix, bug_id, vtype, sorted(VALID_VERIFICATION_TYPES)))
-
-        # acceptance_criteria
-        ac = bug.get("acceptance_criteria", [])
-        if not ac or not isinstance(ac, list):
-            errors.append("{} ({}): missing or empty acceptance_criteria array".format(prefix, bug_id))
-
-        # status
-        status = bug.get("status", "")
-        if status not in VALID_STATUSES:
-            errors.append("{} ({}): invalid status '{}' — must be one of {}".format(
-                prefix, bug_id, status, sorted(VALID_STATUSES)))
-
-        # Priority validation (optional field)
-        priority = bug.get("priority")
-        if priority is not None:
-            if priority not in ("high", "medium", "low"):
-                errors.append("{} ({}): invalid priority '{}' — must be one of 'high', 'medium', 'low'".format(
-                    prefix, bug_id, priority))
-
-    return {
-        "valid": len(errors) == 0,
-        "errors": errors,
-        "warnings": warnings,
-        "stats": {
-            "total_bugs": len(bugs),
-            "severity_distribution": severity_counts,
-        },
-    }
-
-
-def cmd_validate(args):
-    """Handle the 'validate' command."""
-    bug_list = args.input
-    feature_list = args.feature_list
-
-    data, load_err = _load_json(bug_list)
-    if load_err:
-        _err(load_err)
-        return 2
-
-    # Load feature-list.json (optional, for cross-reference)
-    if feature_list:
-        fl_data, fl_err = _load_json(feature_list)
-        if not fl_data:
-            _warn("Could not load feature-list.json at {}: {}".format(feature_list, fl_err))
-
-    result = validate(data)
-
-    # Print results to stdout
-    print(json.dumps(result, indent=2, ensure_ascii=False))
-
-    if result["valid"]:
-        bug_count = result["stats"]["total_bugs"]
-        sev = result["stats"]["severity_distribution"]
-        sev_str = ", ".join("{}={}".format(k, v) for k, v in sorted(sev.items()))
-        _info("VALIDATION PASSED — {} bugs ({})".format(bug_count, sev_str))
-        return 0
-    else:
-        _err("VALIDATION FAILED — {} error(s), {} warning(s)".format(
-            len(result["errors"]), len(result["warnings"])))
-        for e in result["errors"]:
-            _err("  ERROR: {}".format(e))
-        for w in result["warnings"]:
-            _warn("  WARN: {}".format(w))
-        return 1
-
-
-def cmd_generate(args):
-    """Handle the 'generate' command.
-
-    Loads a draft JSON (produced by AI), fills in defaults, validates,
-    and writes the final bug-fix-list.json.
-    """
-    # Load draft (supports stdin via '-')
-    if args.input == "-":
-        try:
-            data = json.load(sys.stdin)
-        except json.JSONDecodeError as exc:
-            _err("Invalid JSON from stdin: {}".format(exc))
-            return 2
-    else:
-        data, load_err = _load_json(args.input)
-        if load_err:
-            _err(load_err)
-            return 2
-
-    # Fill in defaults
-    now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-    data.setdefault("$schema", SCHEMA_VERSION)
-    data.setdefault("created_at", now)
-    data.setdefault("created_by", "bug-planner")
-
-    # Set default status for bugs without one
-    for bug in data.get("bugs", []):
-        bug.setdefault("status", "pending")
-
-    # Validate
-    result = validate(data)
-
-    # Output validation result
-    print(json.dumps(result, indent=2, ensure_ascii=False))
-
-    if result["valid"]:
-        _write_json(args.output, data)
-        _info("Generated bug-fix-list written to {}".format(args.output))
-        return 0
-    else:
-        _err("Validation failed with {} error(s)".format(len(result["errors"])))
-        for e in result["errors"]:
-            _err("  ERROR: {}".format(e))
-        return 1
-
-
-def main():
-    # Backward compatibility: if first arg is a file path (not a subcommand),
-    # treat it as 'validate' command
-    if len(sys.argv) > 1 and not sys.argv[1].startswith("-") and sys.argv[1] not in ("validate", "generate"):
-        sys.argv.insert(1, "validate")
-
-    parser = argparse.ArgumentParser(
-        description="Validate and generate .prizmkit/plans/bug-fix-list.json files.",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=(
-            "Examples:\n"
-            "  %(prog)s validate .prizmkit/plans/bug-fix-list.json\n"
-            "  %(prog)s validate .prizmkit/plans/bug-fix-list.json --feature-list .prizmkit/plans/feature-list.json\n"
-            "  %(prog)s generate --input draft.json --output .prizmkit/plans/bug-fix-list.json\n"
-        ),
-    )
-
-    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
-
-    # -- validate --
-    p_validate = subparsers.add_parser(
-        "validate",
-        help="Validate an existing bug-fix-list.json",
-    )
-    p_validate.add_argument(
-        "input", help="Path to bug-fix-list.json"
-    )
-    p_validate.add_argument(
-        "--feature-list", default=None, help="Path to feature-list.json for cross-reference"
-    )
-
-    # -- generate --
-    p_generate = subparsers.add_parser(
-        "generate",
-        help="Validate a draft and generate final bug-fix-list.json with defaults",
-    )
-    p_generate.add_argument(
-        "--input", required=True, help="Path to draft JSON (or '-' for stdin)"
-    )
-    p_generate.add_argument(
-        "--output", required=True, help="Path to write final bug-fix-list.json"
-    )
-
-    args = parser.parse_args()
-
-    if not args.command:
-        parser.print_help(sys.stderr)
-        return 2
-
-    dispatch = {
-        "validate": cmd_validate,
-        "generate": cmd_generate,
-    }
-
-    handler = dispatch.get(args.command)
-    if handler is None:
-        _err("Unknown command: {}".format(args.command))
-        return 2
-
-    return handler(args)
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/bundled/skills-windows/bugfix-pipeline-launcher/SKILL.md

@@ -1,304 +0,0 @@
----
-name: "bugfix-pipeline-launcher"
-description: "Launch and manage the bugfix pipeline from within an AI CLI session. Start pipeline in background, monitor logs, check status, stop pipeline. Use this skill whenever the user wants to start fixing bugs, run the bugfix pipeline, check bugfix progress, or stop the bugfix pipeline. Trigger on: 'start fixing bugs', 'run bugfix pipeline', 'bugfix status', 'stop bug fix', 'launch bug fix', 'fix progress', 'stop fixing'. (project)"
----
-
-# Bugfix-Pipeline Launcher
-
-Launch the autonomous bug fix pipeline from within an AI CLI conversation. Supports foreground and background execution modes.
-
-### Execution Mode
-
-Three execution modes are available. The user chooses one before configuring other options:
-
-1. **Foreground** (recommended) — `.\.prizmkit\dev-pipeline\run-bugfix.ps1 run`. Visible output, direct error feedback, no orphaned processes.
-2. **Background daemon** — `.\.prizmkit\dev-pipeline\launch-bugfix-daemon.ps1`. Runs fully detached, survives AI CLI session closure.
-3. **Manual** — Display the assembled command(s) only. Do not execute anything. User runs them on their own.
-
-**Background mode documentation**: When the user chooses background/daemon mode, record the choice and PID in `.prizmkit/bugfix-pipeline-run.log` (append-only) with timestamp, so the decision is traceable:
-```
-[2026-03-26T10:30:00] MODE=daemon PID=12345 BUG_LIST=.prizmkit/plans/bug-fix-list.json BUGS=3
-```
-
-### When to Use
-
-**Start bugfix pipeline** -- User says:
-- "start fixing bugs", "run bugfix pipeline", "launch bug fixes", "fix all bugs"
-- "start bug fix", "execute bug list", "begin fixing", "batch fix"
-- After bug-planner completes: "fix them", "start fixing"
-
-**Check status** -- User says:
-- "bugfix status", "check bug fixes", "how's the fixing going", "bug fix progress"
-- "fix progress", "bug fix status", "check fix progress", "how far along are the fixes"
-
-**Stop bugfix pipeline** -- User says:
-- "stop bug fix", "stop fixing", "halt bugfix", "pause bug fix", "stop fix pipeline"
-
-**Show logs** -- User says:
-- "bugfix logs", "show fix logs", "what's being fixed"
-- "view fix logs", "fix logs"
-
-**Do NOT use this skill when:**
-- User wants to plan/collect bugs (use `bug-planner` instead)
-- User wants to fix a single bug interactively in current session (use `bug-fix-workflow`)
-- User wants to launch the feature pipeline (use `feature-pipeline-launcher`)
-
-### Prerequisites
-
-Before any action, validate:
-
-1. **bugfix pipeline exists**: Confirm `.\.prizmkit\dev-pipeline\launch-bugfix-daemon.ps1` and `.\.prizmkit\dev-pipeline\run-bugfix.ps1` are present and executable
-2. **For start**: `.prizmkit/plans/bug-fix-list.json` must exist in `.prizmkit/plans/` (or user-specified path)
-3. **Dependencies**: `python` or the Windows `py` launcher, `git`, and one AI CLI (`codex`, `claude`, or `cbc`) must be in PATH
-4. **Browser tools** (optional): If any bug has `browser_interaction` field, check the corresponding tool is available. Bugs may specify `tool: "playwright-cli"`, `tool: "opencli"`, or `tool: "auto"` (AI chooses at runtime).
-
-Quick check:
-```powershell
-function Invoke-PrizmPython {
-  param([Parameter(ValueFromRemainingArguments = $true)][string[]]$Arguments)
-  $python = Get-Command python -ErrorAction SilentlyContinue
-  if ($python) {
-    & $python.Source -c 'import sys; raise SystemExit(0 if sys.version_info[0] == 3 else 1)' *> $null
-    if ($LASTEXITCODE -eq 0) {
-      & $python.Source @Arguments
-      return
-    }
-  }
-  $py = Get-Command py -ErrorAction SilentlyContinue
-  if ($py) {
-    & $py.Source -3 -c 'import sys; raise SystemExit(0 if sys.version_info[0] == 3 else 1)' *> $null
-    if ($LASTEXITCODE -eq 0) {
-      & $py.Source -3 @Arguments
-      return
-    }
-  }
-  throw "Python 3 is required. Install Python and ensure python or py is in PATH."
-}
-try {
-  $prizmPythonPath = Invoke-PrizmPython -c "import sys; print(sys.executable)"
-  "Python OK: $prizmPythonPath"
-} catch {
-  "Missing Python: install Python 3 and ensure python or py is in PATH"
-}
-Get-Command git
-$aiCli = @("codex", "claude", "cbc") | Where-Object { Get-Command $_ -ErrorAction SilentlyContinue } | Select-Object -First 1
-if ($aiCli) { "AI CLI OK: $aiCli" } else { "Missing AI CLI: install codex, claude, or cbc" }
-# Optional: browser interaction support (check both tools — bugs may use either)
-if (Get-Command playwright-cli -ErrorAction SilentlyContinue) { "playwright-cli OK" } else { "playwright-cli not found (playwright browser verification will be skipped)" }
-if (Get-Command opencli -ErrorAction SilentlyContinue) { "opencli OK" } else { "opencli not found (opencli browser verification will be skipped)" }
-```
-
-If `.prizmkit/plans/bug-fix-list.json` is missing, inform user:
-> "No .prizmkit/plans/bug-fix-list.json found. Run the `bug-planner` skill first to generate one, or provide a path to your bug fix list."
-
-### Workflow
-
-Detect user intent from their message, then follow the corresponding workflow:
-
----
-
-#### Intent A: Start Bugfix Pipeline
-
-> **Execution model**: The pipeline processes bugs **sequentially** (one at a time, in severity/priority order). The `dependencies` field in bug-fix-list.json is reserved for future parallel execution support and does NOT affect current execution order.
-
-1. **Check prerequisites**:
-   ```powershell
-   if (Test-Path .prizmkit/plans/bug-fix-list.json) { "Found" } else { "Missing" }
-   ```
-
-2. **Check not already running**:
-   ```powershell
-   .\.prizmkit\dev-pipeline\launch-bugfix-daemon.ps1 status
-   ```
-   If running, inform user and ask: "Bugfix pipeline is already running. Want to restart it, check status, or view logs?"
-
-3. **Show bug summary** (so user knows what will be fixed):
-   ```powershell
-   $data = Get-Content .prizmkit\plans\bug-fix-list.json -Raw | ConvertFrom-Json
-   $bugs = @($data.bugs)
-   $severityOrder = @{ critical = 0; high = 1; medium = 2; low = 3 }
-   "Total bugs: $($bugs.Count)"
-   $bugs | Group-Object severity | ForEach-Object { "  $($_.Name): $($_.Count)" }
-   ""
-   $bugsSorted = $bugs | Sort-Object `
-     @{ Expression = { if ($severityOrder.ContainsKey($_.severity)) { $severityOrder[$_.severity] } else { 2 } } }, `
-     @{ Expression = { if ($_.priority) { [int]$_.priority } else { 99 } } }
-   foreach ($bug in $bugsSorted) {
-     $severity = if ($bug.severity) { $bug.severity.ToUpperInvariant() } else { "?" }
-     $title = if ($bug.title) { $bug.title } else { "untitled" }
-     "  $($bug.id): [$severity] $title"
-   }
-   ```
-   If pipeline state already exists, use the status command instead:
-   ```powershell
-   Invoke-PrizmPython .prizmkit/dev-pipeline/scripts/update-bug-status.py `
-     --bug-list .prizmkit/plans/bug-fix-list.json `
-     --state-dir .prizmkit/state/bugfix `
-     --action status
-   ```
-
-4. **Ask execution mode** (first user decision — SEPARATE `AskUserQuestion` call with exactly 1 question):
-
-   Present the three execution modes from the **Execution Mode** section above (Foreground / Background daemon / Manual), multiSelect: false. Then STOP and wait for the user's response before continuing to step 5.
-
-5. **Ask configuration options** — applies to ALL execution modes (Foreground, Background, AND Manual). This is a SEPARATE `AskUserQuestion` call from step 4.
-
-   RULE: Execution mode (step 4) and configuration (step 5) are two distinct `AskUserQuestion` calls, asked in order, each followed by waiting for the user's answer. Merging them, assuming defaults, or showing the final command before the user has answered both rounds produces a misconfigured pipeline that runs autonomously for a long time — so it MUST NOT happen. If you find yourself writing the final command before the user has answered, STOP.
-
-   The step-5 questions (4 round-1 questions, plus a round 2 if the user picks "Yes" to Advanced config) and their env-var mappings are enumerated in `${SKILL_DIR}/references/configuration.md` under "Interactive Configuration Options". Present round 1 as one `AskUserQuestion` call; run round 2 only if Advanced config = Yes. Then STOP and wait for the user's response before continuing to step 6.
-
-6. **Show final command**: Assemble the complete command from execution mode + confirmed configuration, and present it to the user.
-
-   **Foreground command:**
-   ```powershell
-   $env:VERBOSE = "1"; .\.prizmkit\dev-pipeline\run-bugfix.ps1 run .prizmkit/plans/bug-fix-list.json
-   ```
-   With all options:
-   ```powershell
-   $env:VERBOSE = "1"; $env:MAX_RETRIES = "5"; $env:PRIZMKIT_EFFORT = "high"
-   .\.prizmkit\dev-pipeline\run-bugfix.ps1 run .prizmkit/plans/bug-fix-list.json
-   ```
-
-   **Background daemon command:**
-   ```powershell
-   .\.prizmkit\dev-pipeline\launch-bugfix-daemon.ps1 start .prizmkit/plans/bug-fix-list.json --env "VERBOSE=1"
-   ```
-   With all options:
-   ```powershell
-   .\.prizmkit\dev-pipeline\launch-bugfix-daemon.ps1 start .prizmkit/plans/bug-fix-list.json `
-     --env "VERBOSE=1 MAX_RETRIES=5 PRIZMKIT_EFFORT=high"
-   ```
-
-   **Manual mode**: Print the assembled command(s) and **stop here**. Do not execute anything. Do not proceed to step 7.
-   ```
-   # To run in foreground:
-   $env:VERBOSE = "1"; .\.prizmkit\dev-pipeline\run-bugfix.ps1 run .prizmkit/plans/bug-fix-list.json
-
-   # To run in background (detached):
-   .\.prizmkit\dev-pipeline\launch-bugfix-daemon.ps1 start .prizmkit/plans/bug-fix-list.json --env "VERBOSE=1"
-
-   # To check status:
-   .\.prizmkit\dev-pipeline\run-bugfix.ps1 status .prizmkit/plans/bug-fix-list.json
-   ```
-
-7. **Confirm and launch** (Foreground and Background only — Manual mode ends at step 6):
-
-   Ask: "Ready to launch the bugfix pipeline with the above command?"
-
-   After user confirms, execute the command from step 6.
-
-8. **Post-launch** (depends on execution mode):
-
-   **If foreground**: Pipeline runs to completion in the terminal. After it finishes:
-   - Summarize results: total bugs, fixed, failed, skipped
-   - If all fixed: each bug session has already run `prizmkit-retrospective` internally (structural sync by default; full retrospective when the fix changed interfaces, dependencies, or observable behavior). Ask user what's next.
-   - If some failed: show failed bug IDs and suggest `.\.prizmkit\dev-pipeline\reset-bug.ps1 <B-XXX> --clean --run` for a fresh retry
-
-   **If background daemon**:
-   1. Verify launch:
-      ```powershell
-      .\.prizmkit\dev-pipeline\launch-bugfix-daemon.ps1 status
-      ```
-   2. Start log monitoring — Use the PowerShell terminal with `run_in_background: true`:
-      ```powershell
-      Get-Content -Wait -Tail 50 .prizmkit/state/daemon/bugfix-daemon.log
-      ```
-   3. Report to user:
-      - Pipeline PID
-      - Log file location
-      - "You can ask me 'bugfix status' or 'show fix logs' at any time"
-      - "Closing this session will NOT stop the pipeline"
-
----
-
-#### Intent B: Check Status
-
-1. **Check daemon status**:
-   ```powershell
-   .\.prizmkit\dev-pipeline\launch-bugfix-daemon.ps1 status
-   ```
-
-2. **Show bug-level progress**:
-   ```powershell
-   Invoke-PrizmPython .prizmkit/dev-pipeline/scripts/update-bug-status.py `
-     --bug-list .prizmkit/plans/bug-fix-list.json `
-     --state-dir .prizmkit/state/bugfix `
-     --action status
-   ```
-
-3. **Show recent log activity** (last 20 lines):
-   ```powershell
-   Get-Content -Tail 20 .prizmkit/state/daemon/bugfix-daemon.log
-   ```
-
-4. **Summarize** to user: total bugs, completed, in-progress, failed, pending, needs-info.
-
----
-
-#### Intent C: Stop Bugfix Pipeline
-
-1. **Stop the daemon**:
-   ```powershell
-   .\.prizmkit\dev-pipeline\launch-bugfix-daemon.ps1 stop
-   ```
-
-2. **Verify stopped**:
-   ```powershell
-   .\.prizmkit\dev-pipeline\launch-bugfix-daemon.ps1 status
-   ```
-
-3. **Inform user**: "Bugfix pipeline stopped. State is preserved -- you can resume later with 'start bug fix' and it will pick up where it left off."
-
----
-
-#### Intent D: Show Logs
-
-1. **Check if running**:
-   ```powershell
-   .\.prizmkit\dev-pipeline\launch-bugfix-daemon.ps1 status
-   ```
-
-2. **If running** -- Start live tail with PowerShell terminal `run_in_background: true`:
-   ```powershell
-   Get-Content -Wait -Tail 50 .prizmkit/state/daemon/bugfix-daemon.log
-   ```
-
-3. **If not running** -- Show last 50 lines:
-   ```powershell
-   Get-Content -Tail 50 .prizmkit/state/daemon/bugfix-daemon.log
-   ```
-
-4. **For per-bug session logs** (when user asks about a specific bug):
-   ```powershell
-   # Check bug status for last session ID
-   Get-Content .prizmkit/state/bugfix/<BUG_ID>/status.json -ErrorAction SilentlyContinue
-   # Then tail that bug's session log
-   Get-Content -Tail 100 .prizmkit/state/bugfix/<BUG_ID>/sessions/<SESSION_ID>/logs/session.log
-   ```
-
----
-
-#### Intent E: Retry Single Bug
-
-When user says "retry B-001":
-
-```powershell
-.\.prizmkit\dev-pipeline\reset-bug.ps1 B-001 --clean --run .prizmkit/plans/bug-fix-list.json
-```
-
-**Note:** `reset-bug.ps1 B-001 --clean --run` performs a clean reset for `B-001` before retrying that bug — this gives a fresh start.
-
-### Error Handling
-
-Read `${SKILL_DIR}/references/configuration.md` for the full error handling table (11 entries).
-
-### Integration Notes
-
-- **After bug-planner**: This is the natural next step. When user finishes bug planning and has `.prizmkit/plans/bug-fix-list.json`, suggest launching the bugfix pipeline.
-- **Session independence**: In daemon mode, the bugfix pipeline runs completely detached. User can close the AI CLI, open a new session later, and use this skill to check progress or stop the pipeline.
-- **Single instance**: Only one bugfix pipeline can run at a time. The PID file prevents duplicates.
-- **Feature pipeline coexistence**: Bugfix and feature pipelines use separate state directories (`.prizmkit/state/bugfix/` vs `.prizmkit/state/features/`), so they can run simultaneously without conflict.
-- **State preservation**: Stopping and restarting the bugfix pipeline resumes from where it left off -- completed bugs are not re-fixed.
-- **Bug ordering**: Bugs are processed by severity (critical → high → medium → low), then by priority number within the same severity.
-- **Background mode traceability**: When daemon mode is chosen, the decision is logged to `.prizmkit/bugfix-pipeline-run.log` with timestamp, PID, and bug count for auditability.
-- **HANDOFF**: After pipeline completes all bugs, suggest running `prizmkit-retrospective` to capture lessons learned, or checking the fix reports in `.prizmkit/bugfix/`.