prizmkit 1.0.6 → 1.0.8

package/bundled/VERSION.json

@@ -1,5 +1,5 @@
 {
-  "frameworkVersion": "1.0.6",
-  "bundledAt": "2026-03-11T13:45:52.858Z",
-  "bundledFrom": "34eeda9"
+  "frameworkVersion": "1.0.8",
+  "bundledAt": "2026-03-11T17:33:39.633Z",
+  "bundledFrom": "66dd874"
 }

package/bundled/dev-pipeline/README.md

@@ -468,15 +468,17 @@ dev-pipeline/bugfix-state/        # Runtime state (gitignored)
                     └── session.log      # Full session output
 ```
 
-### Differences from Feature Pipeline
-
-| Aspect | Feature Pipeline | Bug Fix Pipeline |
-|--------|-----------------|-----------------|
-| Input file | `feature-list.json` | `bug-fix-list.json` |
-| ID format | `F-NNN` | `B-NNN` |
-| State dir | `state/` | `bugfix-state/` |
-| Ordering | Dependencies DAG → priority | Severity → priority (no dependencies) |
-| Phases | 10-phase (specify → plan → tasks → implement → review) | 5-phase (triage → reproduce → fix → verify → commit) |
-| Agents | Coordinator + PM + Dev + Reviewer | Dev + Reviewer only |
-| Artifacts | spec.md, plan.md, tasks.md, REGISTRY.md | fix-plan.md, fix-report.md only |
-| Commit prefix | `feat(<scope>):` | `fix(<scope>):` |
+### Differences Between Pipelines
+
+| Aspect | Feature Pipeline | Refactor Workflow | Bug Fix Pipeline |
+|--------|-----------------|-------------------|------------------|
+| Input file | `feature-list.json` | N/A (conversation trigger) | `bug-fix-list.json` |
+| ID format | `F-NNN` | `<refactor-slug>` | `B-NNN` |
+| State dir | `state/` | N/A (in-session) | `bugfix-state/` |
+| Ordering | Dependencies DAG → priority | N/A (single refactor per session) | Severity → priority (no dependencies) |
+| Phases | 10-phase (specify → plan → tasks → implement → review) | 6-phase (analyze → plan → tasks → implement → review → commit) | 5-phase (triage → reproduce → fix → verify → commit) |
+| Agents | Coordinator + PM + Dev + Reviewer | Dev + Reviewer only | Dev + Reviewer only |
+| Artifacts | spec.md, plan.md, tasks.md, REGISTRY.md | refactor-analysis.md, plan.md, tasks.md | fix-plan.md, fix-report.md only |
+| Commit prefix | `feat(<scope>):` | `refactor(<scope>):` | `fix(<scope>):` |
+| Scope Guard | N/A | ✅ (behavior change → STOP) | N/A |
+| Test Strategy | TDD per task | Full suite after EVERY task | Reproduction test |

package/bundled/dev-pipeline/launch-bugfix-daemon.sh

@@ -14,6 +14,10 @@ set -euo pipefail
 #   ./launch-bugfix-daemon.sh logs [--lines N] [--follow]
 #   ./launch-bugfix-daemon.sh restart [bug-fix-list.json] [--env "KEY=VAL ..."]
 #
+# NOTE:
+#   In AI skill sessions, always use this daemon wrapper.
+#   Do NOT call `run-bugfix.sh run ...` directly, because foreground sessions may be killed by CLI timeout.
+#
 # Files managed:
 #   bugfix-state/.pipeline.pid          - PID of the background run-bugfix.sh process
 #   bugfix-state/pipeline-daemon.log    - Consolidated stdout+stderr

package/bundled/dev-pipeline/launch-daemon.sh

@@ -14,6 +14,10 @@ set -euo pipefail
 #   ./launch-daemon.sh logs [--lines N] [--follow]
 #   ./launch-daemon.sh restart [feature-list.json] [--env "KEY=VAL ..."]
 #
+# NOTE:
+#   In AI skill sessions, always use this daemon wrapper.
+#   Do NOT call `run.sh run ...` directly, because foreground sessions may be killed by CLI timeout.
+#
 # Files managed:
 #   state/.pipeline.pid          - PID of the background run.sh process
 #   state/pipeline-daemon.log    - Consolidated stdout+stderr from run.sh

package/bundled/dev-pipeline/retry-bug.sh

@@ -48,6 +48,12 @@ else
 fi
 export PRIZMKIT_PLATFORM="$PLATFORM"
 
+# Source shared heartbeat library
+source "$SCRIPT_DIR/lib/heartbeat.sh"
+
+# Detect stream-json support
+detect_stream_json_support "$CLI_CMD"
+
 # Colors
 RED='\033[0;31m'
 GREEN='\033[0;32m'
@@ -194,6 +200,13 @@ echo -e "${BOLD}═════════════════════
 echo ""
 
 SESSION_LOG="$SESSION_DIR/logs/session.log"
+PROGRESS_JSON="$SESSION_DIR/logs/progress.json"
+
+# Build stream-json flag
+STREAM_JSON_FLAG=""
+if [[ "$USE_STREAM_JSON" == "true" ]]; then
+    STREAM_JSON_FLAG="--output-format stream-json"
+fi
 
 # Spawn AI CLI session
 case "$CLI_CMD" in
@@ -202,18 +215,24 @@ case "$CLI_CMD" in
             --print \
             -p "$(cat "$BOOTSTRAP_PROMPT")" \
             --yes \
+            $STREAM_JSON_FLAG \
             > "$SESSION_LOG" 2>&1 &
         ;;
     *)
         "$CLI_CMD" \
             --print \
             -y \
+            $STREAM_JSON_FLAG \
             < "$BOOTSTRAP_PROMPT" \
             > "$SESSION_LOG" 2>&1 &
         ;;
 esac
 CLI_PID=$!
 
+# Start progress parser (no-op if stream-json not supported)
+start_progress_parser "$SESSION_LOG" "$PROGRESS_JSON" "$SCRIPTS_DIR"
+PARSER_PID="${_PARSER_PID:-}"
+
 # Timeout watchdog
 WATCHER_PID=""
 if [[ $SESSION_TIMEOUT -gt 0 ]]; then
@@ -222,49 +241,8 @@ if [[ $SESSION_TIMEOUT -gt 0 ]]; then
 fi
 
 # Heartbeat
-(
-    elapsed=0
-    prev_size=0
-    while kill -0 "$CLI_PID" 2>/dev/null; do
-        sleep "$HEARTBEAT_INTERVAL"
-        elapsed=$((elapsed + HEARTBEAT_INTERVAL))
-        kill -0 "$CLI_PID" 2>/dev/null || break
-
-        cur_size=0
-        if [[ -f "$SESSION_LOG" ]]; then
-            cur_size=$(wc -c < "$SESSION_LOG" 2>/dev/null || echo 0)
-            cur_size=$(echo "$cur_size" | tr -d ' ')
-        fi
-
-        growth=$((cur_size - prev_size))
-        prev_size=$cur_size
-
-        if [[ $cur_size -gt 1048576 ]]; then
-            size_display="$((cur_size / 1048576))MB"
-        elif [[ $cur_size -gt 1024 ]]; then
-            size_display="$((cur_size / 1024))KB"
-        else
-            size_display="${cur_size}B"
-        fi
-
-        mins=$((elapsed / 60))
-        secs=$((elapsed % 60))
-
-        last_activity=""
-        if [[ -f "$SESSION_LOG" ]]; then
-            last_activity=$(tail -20 "$SESSION_LOG" 2>/dev/null | grep -v '^$' | tail -1 | cut -c1-80 || echo "")
-        fi
-
-        if [[ $growth -gt 0 ]]; then
-            icon="${GREEN}▶${NC}"
-        else
-            icon="${YELLOW}⏸${NC}"
-        fi
-
-        echo -e "  ${icon} ${BLUE}[HEARTBEAT]${NC} ${mins}m${secs}s | log: ${size_display} (+${growth}B) | ${last_activity}"
-    done
-) &
-HEARTBEAT_PID=$!
+start_heartbeat "$CLI_PID" "$SESSION_LOG" "$PROGRESS_JSON" "$HEARTBEAT_INTERVAL"
+HEARTBEAT_PID="${_HEARTBEAT_PID:-}"
 
 # Ctrl+C cleanup
 cleanup() {
@@ -272,10 +250,10 @@ cleanup() {
     log_warn "Interrupted. Killing session..."
     kill "$CLI_PID" 2>/dev/null || true
     [[ -n "$WATCHER_PID" ]] && kill "$WATCHER_PID" 2>/dev/null || true
-    kill "$HEARTBEAT_PID" 2>/dev/null || true
+    stop_heartbeat "$HEARTBEAT_PID"
+    stop_progress_parser "$PARSER_PID"
     wait "$CLI_PID" 2>/dev/null || true
     [[ -n "$WATCHER_PID" ]] && wait "$WATCHER_PID" 2>/dev/null || true
-    wait "$HEARTBEAT_PID" 2>/dev/null || true
     log_info "Session log: $SESSION_LOG"
     exit 130
 }
@@ -291,9 +269,9 @@ fi
 
 # Cleanup background processes
 [[ -n "$WATCHER_PID" ]] && kill "$WATCHER_PID" 2>/dev/null || true
-kill "$HEARTBEAT_PID" 2>/dev/null || true
+stop_heartbeat "$HEARTBEAT_PID"
+stop_progress_parser "$PARSER_PID"
 [[ -n "$WATCHER_PID" ]] && wait "$WATCHER_PID" 2>/dev/null || true
-wait "$HEARTBEAT_PID" 2>/dev/null || true
 
 [[ $EXIT_CODE -eq 143 ]] && EXIT_CODE=124
 

package/bundled/dev-pipeline/retry-feature.sh

@@ -48,6 +48,12 @@ else
 fi
 export PRIZMKIT_PLATFORM="$PLATFORM"
 
+# Source shared heartbeat library
+source "$SCRIPT_DIR/lib/heartbeat.sh"
+
+# Detect stream-json support
+detect_stream_json_support "$CLI_CMD"
+
 # Colors
 RED='\033[0;31m'
 GREEN='\033[0;32m'
@@ -188,6 +194,13 @@ echo -e "${BOLD}═════════════════════
 echo ""
 
 SESSION_LOG="$SESSION_DIR/logs/session.log"
+PROGRESS_JSON="$SESSION_DIR/logs/progress.json"
+
+# Build stream-json flag
+STREAM_JSON_FLAG=""
+if [[ "$USE_STREAM_JSON" == "true" ]]; then
+    STREAM_JSON_FLAG="--output-format stream-json"
+fi
 
 # Spawn AI CLI session
 case "$CLI_CMD" in
@@ -196,18 +209,24 @@ case "$CLI_CMD" in
             --print \
             -p "$(cat "$BOOTSTRAP_PROMPT")" \
             --yes \
+            $STREAM_JSON_FLAG \
             > "$SESSION_LOG" 2>&1 &
         ;;
     *)
         "$CLI_CMD" \
             --print \
             -y \
+            $STREAM_JSON_FLAG \
             < "$BOOTSTRAP_PROMPT" \
             > "$SESSION_LOG" 2>&1 &
         ;;
 esac
 CBC_PID=$!
 
+# Start progress parser (no-op if stream-json not supported)
+start_progress_parser "$SESSION_LOG" "$PROGRESS_JSON" "$SCRIPTS_DIR"
+PARSER_PID="${_PARSER_PID:-}"
+
 # Timeout watchdog (only if SESSION_TIMEOUT > 0)
 WATCHER_PID=""
 if [[ $SESSION_TIMEOUT -gt 0 ]]; then
@@ -216,49 +235,8 @@ if [[ $SESSION_TIMEOUT -gt 0 ]]; then
 fi
 
 # Heartbeat
-(
-    elapsed=0
-    prev_size=0
-    while kill -0 "$CBC_PID" 2>/dev/null; do
-        sleep "$HEARTBEAT_INTERVAL"
-        elapsed=$((elapsed + HEARTBEAT_INTERVAL))
-        kill -0 "$CBC_PID" 2>/dev/null || break
-
-        cur_size=0
-        if [[ -f "$SESSION_LOG" ]]; then
-            cur_size=$(wc -c < "$SESSION_LOG" 2>/dev/null || echo 0)
-            cur_size=$(echo "$cur_size" | tr -d ' ')
-        fi
-
-        growth=$((cur_size - prev_size))
-        prev_size=$cur_size
-
-        if [[ $cur_size -gt 1048576 ]]; then
-            size_display="$((cur_size / 1048576))MB"
-        elif [[ $cur_size -gt 1024 ]]; then
-            size_display="$((cur_size / 1024))KB"
-        else
-            size_display="${cur_size}B"
-        fi
-
-        mins=$((elapsed / 60))
-        secs=$((elapsed % 60))
-
-        last_activity=""
-        if [[ -f "$SESSION_LOG" ]]; then
-            last_activity=$(tail -20 "$SESSION_LOG" 2>/dev/null | grep -v '^$' | tail -1 | cut -c1-80 || echo "")
-        fi
-
-        if [[ $growth -gt 0 ]]; then
-            icon="${GREEN}▶${NC}"
-        else
-            icon="${YELLOW}⏸${NC}"
-        fi
-
-        echo -e "  ${icon} ${BLUE}[HEARTBEAT]${NC} ${mins}m${secs}s | log: ${size_display} (+${growth}B) | ${last_activity}"
-    done
-) &
-HEARTBEAT_PID=$!
+start_heartbeat "$CBC_PID" "$SESSION_LOG" "$PROGRESS_JSON" "$HEARTBEAT_INTERVAL"
+HEARTBEAT_PID="${_HEARTBEAT_PID:-}"
 
 # Ctrl+C cleanup
 cleanup() {
@@ -266,10 +244,10 @@ cleanup() {
     log_warn "Interrupted. Killing session..."
     kill "$CBC_PID" 2>/dev/null || true
     [[ -n "$WATCHER_PID" ]] && kill "$WATCHER_PID" 2>/dev/null || true
-    kill "$HEARTBEAT_PID" 2>/dev/null || true
+    stop_heartbeat "$HEARTBEAT_PID"
+    stop_progress_parser "$PARSER_PID"
     wait "$CBC_PID" 2>/dev/null || true
     [[ -n "$WATCHER_PID" ]] && wait "$WATCHER_PID" 2>/dev/null || true
-    wait "$HEARTBEAT_PID" 2>/dev/null || true
     log_info "Session log: $SESSION_LOG"
     exit 130
 }
@@ -285,9 +263,9 @@ fi
 
 # Cleanup background processes
 [[ -n "$WATCHER_PID" ]] && kill "$WATCHER_PID" 2>/dev/null || true
-kill "$HEARTBEAT_PID" 2>/dev/null || true
+stop_heartbeat "$HEARTBEAT_PID"
+stop_progress_parser "$PARSER_PID"
 [[ -n "$WATCHER_PID" ]] && wait "$WATCHER_PID" 2>/dev/null || true
-wait "$HEARTBEAT_PID" 2>/dev/null || true
 
 [[ $EXIT_CODE -eq 143 ]] && EXIT_CODE=124
 

package/bundled/dev-pipeline/run-bugfix.sh

@@ -57,6 +57,12 @@ else
 fi
 export PRIZMKIT_PLATFORM="$PLATFORM"
 
+# Source shared heartbeat library
+source "$SCRIPT_DIR/lib/heartbeat.sh"
+
+# Detect stream-json support
+detect_stream_json_support "$CLI_CMD"
+
 # Bug list path (set in main, used by cleanup trap)
 BUG_LIST=""
 
@@ -87,12 +93,18 @@ spawn_and_wait_session() {
     local max_retries="$6"
 
     local session_log="$session_dir/logs/session.log"
+    local progress_json="$session_dir/logs/progress.json"
 
     local verbose_flag=""
     if [[ "$VERBOSE" == "1" ]]; then
         verbose_flag="--verbose"
     fi
 
+    local stream_json_flag=""
+    if [[ "$USE_STREAM_JSON" == "true" ]]; then
+        stream_json_flag="--output-format stream-json"
+    fi
+
     case "$CLI_CMD" in
         *claude*)
             "$CLI_CMD" \
@@ -100,6 +112,7 @@ spawn_and_wait_session() {
                 -p "$(cat "$bootstrap_prompt")" \
                 --yes \
                 $verbose_flag \
+                $stream_json_flag \
                 > "$session_log" 2>&1 &
             ;;
         *)
@@ -107,12 +120,17 @@ spawn_and_wait_session() {
                 --print \
                 -y \
                 $verbose_flag \
+                $stream_json_flag \
                 < "$bootstrap_prompt" \
                 > "$session_log" 2>&1 &
             ;;
     esac
     local cli_pid=$!
 
+    # Start progress parser (no-op if stream-json not supported)
+    start_progress_parser "$session_log" "$progress_json" "$SCRIPTS_DIR"
+    local parser_pid="${_PARSER_PID:-}"
+
     # Timeout watchdog
     local watcher_pid=""
     if [[ $SESSION_TIMEOUT -gt 0 ]]; then
@@ -121,52 +139,8 @@ spawn_and_wait_session() {
     fi
 
     # Heartbeat monitor
-    local heartbeat_interval=$HEARTBEAT_INTERVAL
-    (
-        local elapsed=0
-        local prev_size=0
-        while kill -0 "$cli_pid" 2>/dev/null; do
-            sleep "$heartbeat_interval"
-            elapsed=$((elapsed + heartbeat_interval))
-            kill -0 "$cli_pid" 2>/dev/null || break
-
-            local cur_size=0
-            if [[ -f "$session_log" ]]; then
-                cur_size=$(wc -c < "$session_log" 2>/dev/null || echo 0)
-                cur_size=$(echo "$cur_size" | tr -d ' ')
-            fi
-
-            local growth=$((cur_size - prev_size))
-            prev_size=$cur_size
-
-            local size_display
-            if [[ $cur_size -gt 1048576 ]]; then
-                size_display="$((cur_size / 1048576))MB"
-            elif [[ $cur_size -gt 1024 ]]; then
-                size_display="$((cur_size / 1024))KB"
-            else
-                size_display="${cur_size}B"
-            fi
-
-            local mins=$((elapsed / 60))
-            local secs=$((elapsed % 60))
-
-            local last_activity=""
-            if [[ -f "$session_log" ]]; then
-                last_activity=$(tail -20 "$session_log" 2>/dev/null | grep -v '^$' | tail -1 | cut -c1-80 || echo "")
-            fi
-
-            local status_icon
-            if [[ $growth -gt 0 ]]; then
-                status_icon="${GREEN}▶${NC}"
-            else
-                status_icon="${YELLOW}⏸${NC}"
-            fi
-
-            echo -e "  ${status_icon} ${BLUE}[HEARTBEAT]${NC} ${mins}m${secs}s elapsed | log: ${size_display} (+${growth}B) | ${last_activity}"
-        done
-    ) &
-    local heartbeat_pid=$!
+    start_heartbeat "$cli_pid" "$session_log" "$progress_json" "$HEARTBEAT_INTERVAL"
+    local heartbeat_pid="${_HEARTBEAT_PID:-}"
 
     # Wait for AI CLI to finish
     local exit_code=0
@@ -178,9 +152,9 @@ spawn_and_wait_session() {
 
     # Cleanup
     [[ -n "$watcher_pid" ]] && kill "$watcher_pid" 2>/dev/null || true
-    kill "$heartbeat_pid" 2>/dev/null || true
+    stop_heartbeat "$heartbeat_pid"
+    stop_progress_parser "$parser_pid"
     [[ -n "$watcher_pid" ]] && wait "$watcher_pid" 2>/dev/null || true
-    wait "$heartbeat_pid" 2>/dev/null || true
 
     [[ $exit_code -eq 143 ]] && exit_code=124
 

package/bundled/dev-pipeline/run.sh

@@ -61,6 +61,12 @@ fi
 
 export PRIZMKIT_PLATFORM="$PLATFORM"
 
+# Source shared heartbeat library
+source "$SCRIPT_DIR/lib/heartbeat.sh"
+
+# Detect stream-json support
+detect_stream_json_support "$CLI_CMD"
+
 # Feature list path (set in main, used by cleanup trap)
 FEATURE_LIST=""
 
@@ -100,6 +106,7 @@ spawn_and_wait_session() {
     local max_retries="$6"
 
     local session_log="$session_dir/logs/session.log"
+    local progress_json="$session_dir/logs/progress.json"
 
     # Spawn AI CLI session
     local verbose_flag=""
@@ -107,6 +114,11 @@ spawn_and_wait_session() {
         verbose_flag="--verbose"
     fi
 
+    local stream_json_flag=""
+    if [[ "$USE_STREAM_JSON" == "true" ]]; then
+        stream_json_flag="--output-format stream-json"
+    fi
+
     case "$CLI_CMD" in
         *claude*)
             # Claude Code: prompt via -p argument, --yes for auto-accept
@@ -115,6 +127,7 @@ spawn_and_wait_session() {
                 -p "$(cat "$bootstrap_prompt")" \
                 --yes \
                 $verbose_flag \
+                $stream_json_flag \
                 > "$session_log" 2>&1 &
             ;;
         *)
@@ -123,12 +136,17 @@ spawn_and_wait_session() {
                 --print \
                 -y \
                 $verbose_flag \
+                $stream_json_flag \
                 < "$bootstrap_prompt" \
                 > "$session_log" 2>&1 &
             ;;
     esac
     local cbc_pid=$!
 
+    # Start progress parser (no-op if stream-json not supported)
+    start_progress_parser "$session_log" "$progress_json" "$SCRIPTS_DIR"
+    local parser_pid="${_PARSER_PID:-}"
+
     # Timeout watchdog (only if SESSION_TIMEOUT > 0)
     local watcher_pid=""
     if [[ $SESSION_TIMEOUT -gt 0 ]]; then
@@ -136,53 +154,9 @@ spawn_and_wait_session() {
         watcher_pid=$!
     fi
 
-    # Heartbeat monitor
-    local heartbeat_interval=$HEARTBEAT_INTERVAL
-    (
-        local elapsed=0
-        local prev_size=0
-        while kill -0 "$cbc_pid" 2>/dev/null; do
-            sleep "$heartbeat_interval"
-            elapsed=$((elapsed + heartbeat_interval))
-            kill -0 "$cbc_pid" 2>/dev/null || break
-
-            local cur_size=0
-            if [[ -f "$session_log" ]]; then
-                cur_size=$(wc -c < "$session_log" 2>/dev/null || echo 0)
-                cur_size=$(echo "$cur_size" | tr -d ' ')
-            fi
-
-            local growth=$((cur_size - prev_size))
-            prev_size=$cur_size
-
-            local size_display
-            if [[ $cur_size -gt 1048576 ]]; then
-                size_display="$((cur_size / 1048576))MB"
-            elif [[ $cur_size -gt 1024 ]]; then
-                size_display="$((cur_size / 1024))KB"
-            else
-                size_display="${cur_size}B"
-            fi
-
-            local mins=$((elapsed / 60))
-            local secs=$((elapsed % 60))
-
-            local last_activity=""
-            if [[ -f "$session_log" ]]; then
-                last_activity=$(tail -20 "$session_log" 2>/dev/null | grep -v '^$' | tail -1 | cut -c1-80 || echo "")
-            fi
-
-            local status_icon
-            if [[ $growth -gt 0 ]]; then
-                status_icon="${GREEN}▶${NC}"
-            else
-                status_icon="${YELLOW}⏸${NC}"
-            fi
-
-            echo -e "  ${status_icon} ${BLUE}[HEARTBEAT]${NC} ${mins}m${secs}s elapsed | log: ${size_display} (+${growth}B) | ${last_activity}"
-        done
-    ) &
-    local heartbeat_pid=$!
+    # Heartbeat monitor (reads progress.json when available, falls back to tail)
+    start_heartbeat "$cbc_pid" "$session_log" "$progress_json" "$HEARTBEAT_INTERVAL"
+    local heartbeat_pid="${_HEARTBEAT_PID:-}"
 
     # Wait for AI CLI to finish
     local exit_code=0
@@ -192,11 +166,11 @@ spawn_and_wait_session() {
         exit_code=$?
     fi
 
-    # Clean up watcher and heartbeat
+    # Clean up watcher, heartbeat, and parser
     [[ -n "$watcher_pid" ]] && kill "$watcher_pid" 2>/dev/null || true
-    kill "$heartbeat_pid" 2>/dev/null || true
+    stop_heartbeat "$heartbeat_pid"
+    stop_progress_parser "$parser_pid"
     [[ -n "$watcher_pid" ]] && wait "$watcher_pid" 2>/dev/null || true
-    wait "$heartbeat_pid" 2>/dev/null || true
 
     # Map SIGTERM (143) to timeout code 124
     if [[ $exit_code -eq 143 ]]; then

package/bundled/dev-pipeline/scripts/parse-stream-progress.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""
+parse-stream-progress.py - Real-time stream-json progress parser
+
+Continuously reads an AI CLI session log (JSONL from --output-format stream-json),
+extracts tool calls, phase changes, and activity metrics, and writes structured
+progress to a progress.json file for heartbeat monitoring.
+
+Usage:
+    python3 parse-stream-progress.py --session-log <path> --progress-file <path>
+
+The script runs until:
+  - The session log stops growing and the CLI process exits
+  - It receives SIGTERM/SIGINT
+"""
+
+import argparse
+import json
+import os
+import signal
+import sys
+import tempfile
+import time
+from collections import Counter
+from datetime import datetime, timezone
+
+
+# Phase keywords for detection
+PHASE_KEYWORDS = {
+    "specify": ["prizmkit-specify", "spec.md", "specification", "gathering requirements"],
+    "plan": ["prizmkit-plan", "plan.md", "architecture", "design plan"],
+    "tasks": ["prizmkit-tasks", "tasks.md", "task checklist", "task breakdown"],
+    "analyze": ["prizmkit-analyze", "cross-check", "consistency", "analyzing"],
+    "implement": ["prizmkit-implement", "implement", "TDD", "coding", "writing code"],
+    "code-review": ["prizmkit-code-review", "code review", "review verdict", "reviewing"],
+    "summarize": ["prizmkit-summarize", "REGISTRY.md", "summarize", "summary"],
+    "commit": ["prizmkit-committer", "git commit", "feat(", "fix(", "committing"],
+}
+
+
+class ProgressTracker:
+    """Tracks progress state from stream-json events."""
+
+    def __init__(self):
+        self.message_count = 0
+        self.current_tool = None
+        self.current_tool_input_summary = ""
+        self.current_phase = None
+        self.detected_phases = []
+        self.tool_call_counts = Counter()
+        self.total_tool_calls = 0
+        self.last_text_snippet = ""
+        self.is_active = True
+        self.errors = []
+        self._text_buffer = ""
+        self._in_tool_use = False
+        self._current_tool_input_parts = []
+
+    def process_event(self, event):
+        """Process a single stream-json event and update state."""
+        event_type = event.get("type", "")
+
+        if event_type == "message_start":
+            self.message_count += 1
+            self.is_active = True
+
+        elif event_type == "message_stop":
+            self.current_tool = None
+            self.current_tool_input_summary = ""
+            self._in_tool_use = False
+            self._current_tool_input_parts = []
+
+        elif event_type == "content_block_start":
+            content_block = event.get("content_block", {})
+            block_type = content_block.get("type", "")
+
+            if block_type == "tool_use":
+                tool_name = content_block.get("name", "unknown")
+                self.current_tool = tool_name
+                self.current_tool_input_summary = ""
+                self.tool_call_counts[tool_name] += 1
+                self.total_tool_calls += 1
+                self._in_tool_use = True
+                self._current_tool_input_parts = []
+
+            elif block_type == "text":
+                self._text_buffer = ""
+                self._in_tool_use = False
+
+        elif event_type == "content_block_delta":
+            delta = event.get("delta", {})
+            delta_type = delta.get("type", "")
+
+            if delta_type == "text_delta":
+                text = delta.get("text", "")
+                self._text_buffer += text
+                # Keep last meaningful snippet
+                stripped = text.strip()
+                if stripped:
+                    self.last_text_snippet = stripped[:120]
+                # Try to detect phase from text
+                self._detect_phase(text)
+
+            elif delta_type == "input_json_delta":
+                partial = delta.get("partial_json", "")
+                self._current_tool_input_parts.append(partial)
+                # Build a summary from accumulated input
+                accumulated = "".join(self._current_tool_input_parts)
+                self.current_tool_input_summary = accumulated[:150]
+
+        elif event_type == "content_block_stop":
+            if self._in_tool_use:
+                # Try to extract a better summary from complete tool input
+                full_input = "".join(self._current_tool_input_parts)
+                self._extract_tool_summary(full_input)
+                self._detect_phase(full_input)
+            else:
+                # Text block finished - detect phase from accumulated text
+                if self._text_buffer:
+                    self._detect_phase(self._text_buffer)
+            self._in_tool_use = False
+            self._current_tool_input_parts = []
+
+        elif event_type == "error":
+            error_msg = event.get("error", {}).get("message", "Unknown error")
+            self.errors.append(error_msg)
+
+        # Check for subagent indicator
+        if event.get("parent_tool_use_id"):
+            # This is a sub-agent event; tool name is still tracked normally
+            pass
+
+    def _detect_phase(self, text):
+        """Detect pipeline phase from text content."""
+        text_lower = text.lower()
+        for phase, keywords in PHASE_KEYWORDS.items():
+            for keyword in keywords:
+                if keyword.lower() in text_lower:
+                    self.current_phase = phase
+                    if phase not in self.detected_phases:
+                        self.detected_phases.append(phase)
+                    return
+
+    def _extract_tool_summary(self, raw_input):
+        """Extract a human-readable summary from tool input JSON."""
+        try:
+            data = json.loads(raw_input)
+            # Common patterns in tool inputs
+            if isinstance(data, dict):
+                # Agent tool - look for description or prompt
+                if "description" in data:
+                    self.current_tool_input_summary = str(data["description"])[:100]
+                elif "command" in data:
+                    self.current_tool_input_summary = str(data["command"])[:100]
+                elif "file_path" in data:
+                    self.current_tool_input_summary = str(data["file_path"])[:100]
+                elif "pattern" in data:
+                    self.current_tool_input_summary = str(data["pattern"])[:100]
+                elif "query" in data:
+                    self.current_tool_input_summary = str(data["query"])[:100]
+                elif "prompt" in data:
+                    self.current_tool_input_summary = str(data["prompt"])[:100]
+        except (json.JSONDecodeError, TypeError):
+            # Keep whatever partial summary we had
+            pass
+
+    def to_dict(self):
+        """Export current state as a dictionary for JSON serialization."""
+        tool_calls = [
+            {"name": name, "count": count}
+            for name, count in self.tool_call_counts.most_common()
+        ]
+        return {
+            "updated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "message_count": self.message_count,
+            "current_tool": self.current_tool,
+            "current_tool_input_summary": self.current_tool_input_summary,
+            "current_phase": self.current_phase,
+            "detected_phases": self.detected_phases,
+            "tool_calls": tool_calls,
+            "total_tool_calls": self.total_tool_calls,
+            "last_text_snippet": self.last_text_snippet,
+            "is_active": self.is_active,
+            "errors": self.errors[-10:],  # Keep last 10 errors
+        }
+
+
+def atomic_write_json(data, filepath):
+    """Write JSON data atomically using tmp file + rename."""
+    dir_path = os.path.dirname(filepath)
+    tmp_path = None
+    try:
+        fd, tmp_path = tempfile.mkstemp(dir=dir_path, suffix=".tmp")
+        with os.fdopen(fd, "w") as f:
+            json.dump(data, f, indent=2)
+            f.write("\n")
+        os.rename(tmp_path, filepath)
+    except OSError:
+        # Best effort - remove tmp file if rename failed
+        if tmp_path:
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+
+
+def tail_and_parse(session_log, progress_file, poll_interval=0.5):
+    """Tail session log and parse stream-json events."""
+    tracker = ProgressTracker()
+    last_write_state = None
+
+    # Wait for log file to appear
+    wait_count = 0
+    while not os.path.exists(session_log):
+        time.sleep(poll_interval)
+        wait_count += 1
+        if wait_count > 120:  # 60 seconds max wait
+            sys.stderr.write(f"Timeout waiting for {session_log}\n")
+            sys.exit(1)
+
+    with open(session_log, "r") as f:
+        idle_count = 0
+        while True:
+            line = f.readline()
+            if line:
+                idle_count = 0
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    event = json.loads(line)
+                    tracker.process_event(event)
+                except json.JSONDecodeError:
+                    # Not a JSON line (could be stderr mixed in)
+                    # Use it as a text snippet if meaningful
+                    stripped = line.strip()
+                    if stripped and len(stripped) > 5:
+                        tracker.last_text_snippet = stripped[:120]
+                    continue
+
+                # Write progress if state changed
+                current_state = tracker.to_dict()
+                state_key = (
+                    current_state["message_count"],
+                    current_state["current_tool"],
+                    current_state["current_phase"],
+                    current_state["total_tool_calls"],
+                )
+                if state_key != last_write_state:
+                    atomic_write_json(current_state, progress_file)
+                    last_write_state = state_key
+            else:
+                idle_count += 1
+                # After 2 seconds of no new data, write current state anyway
+                # (ensures progress.json stays fresh)
+                if idle_count == 4:
+                    current_state = tracker.to_dict()
+                    atomic_write_json(current_state, progress_file)
+
+                # After 3600 idle cycles (30 min), mark inactive and exit
+                if idle_count > 3600:
+                    tracker.is_active = False
+                    atomic_write_json(tracker.to_dict(), progress_file)
+                    break
+
+                time.sleep(poll_interval)
+
+    # Final write
+    tracker.is_active = False
+    atomic_write_json(tracker.to_dict(), progress_file)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Parse stream-json progress")
+    parser.add_argument("--session-log", required=True, help="Path to session.log (JSONL)")
+    parser.add_argument("--progress-file", required=True, help="Path to write progress.json")
+    args = parser.parse_args()
+
+    # Handle graceful shutdown
+    def handle_signal(signum, frame):
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, handle_signal)
+    signal.signal(signal.SIGINT, handle_signal)
+
+    try:
+        tail_and_parse(args.session_log, args.progress_file)
+    except SystemExit:
+        pass
+    except Exception as e:
+        sys.stderr.write(f"parse-stream-progress.py error: {e}\n")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -7,6 +7,12 @@ description: "Launch and manage the bugfix pipeline from within a cbc session. S
 
 Launch the autonomous bug fix pipeline from within a cbc conversation. The pipeline runs as a fully detached background process -- closing the cbc session does NOT stop the pipeline.
 
+### Mandatory Execution Mode (MUST)
+
+- Always use daemon mode via `dev-pipeline/launch-bugfix-daemon.sh` for start/stop/status/log actions.
+- NEVER run `dev-pipeline/run-bugfix.sh run ...` directly from this skill.
+- Reason: foreground `run-bugfix.sh` can be terminated by AI CLI command timeout (e.g. cbc 120s), while daemon mode survives session timeout.
+
 ### When to Use
 
 **Start bugfix pipeline** -- User says:
@@ -14,7 +20,7 @@ Launch the autonomous bug fix pipeline from within a cbc conversation. The pipel
 - "start bug fix", "run bug fix", "execute bug list", "begin fixing"
 - "启动 bug 修复", "开始修复 bug", "运行 bug 修复流水线", "开始修 bug"
 - "修复所有 bug", "批量修复", "启动修复流水线"
-- After bug-planner completes: "go", "start", "fix them", "开始吧", "开始修复"
+- After bug-planner completes: "fix them", "开始修复"
 
 **Check status** -- User says:
 - "bugfix status", "check bug fixes", "how's the fixing going", "bug fix progress"

package/bundled/skills/dev-pipeline-launcher/SKILL.md

@@ -7,6 +7,12 @@ description: "Launch and manage the dev-pipeline from within a cbc session. Star
 
 Launch the autonomous development pipeline from within a cbc conversation. The pipeline runs as a fully detached background process -- closing the cbc session does NOT stop the pipeline.
 
+### Mandatory Execution Mode (MUST)
+
+- Always use daemon mode via `dev-pipeline/launch-daemon.sh` for start/stop/status/log actions.
+- NEVER run `dev-pipeline/run.sh run ...` directly from this skill.
+- Reason: foreground `run.sh` can be terminated by AI CLI command timeout (e.g. cbc 120s), while daemon mode survives session timeout.
+
 ### When to Use
 
 **Start pipeline** -- User says:
@@ -14,7 +20,7 @@ Launch the autonomous development pipeline from within a cbc conversation. The p
 - "run the features", "execute feature list", "start implementing"
 - "启动流水线", "开始实现", "运行流水线", "开始自动开发"
 - "实现接下来的步骤", "执行 feature list", "开始构建"
-- After app-planner completes: "go", "start", "build it", "开始吧"
+- After app-planner completes: "build it", "按 feature list 开始开发"
 
 **Check status** -- User says:
 - "pipeline status", "check pipeline", "how's it going", "progress"
@@ -28,6 +34,10 @@ Launch the autonomous development pipeline from within a cbc conversation. The p
 - "show logs", "pipeline logs", "tail logs", "what's happening"
 - "查看日志", "流水线日志", "看看日志"
 
+**Retry single feature node** -- User says:
+- "retry F-003", "retry this feature", "retry this node"
+- "重试 F-003", "重试这个节点", "重跑这个 feature"
+
 **Do NOT use this skill when:**
 - User wants to plan features (use `app-planner` instead)
 - User wants to implement a single feature manually within current session (use `prizmkit-implement`)
@@ -201,6 +211,26 @@ Pass via `--env`:
 dev-pipeline/launch-daemon.sh start feature-list.json --env "SESSION_TIMEOUT=7200 MAX_RETRIES=5 VERBOSE=1"
 ```
 
+---
+
+#### Intent F: Retry Single Feature Node
+
+When user says "retry F-003" or "重试 F-003":
+
+```bash
+dev-pipeline/retry-feature.sh F-003 feature-list.json
+```
+
+When user says "从头重试 F-003" or "clean retry F-003":
+
+```bash
+dev-pipeline/reset-feature.sh F-003 --clean --run feature-list.json
+```
+
+Notes:
+- `retry-feature.sh` runs exactly one feature session and exits.
+- Keep pipeline daemon mode for main run management (`launch-daemon.sh`).
+
 ### Error Handling
 
 | Error | Action |
@@ -211,7 +241,7 @@ dev-pipeline/launch-daemon.sh start feature-list.json --env "SESSION_TIMEOUT=720
 | Pipeline already running | Show status, ask if user wants to stop and restart |
 | PID file stale (process dead) | `launch-daemon.sh` auto-cleans, retry start |
 | Launch failed (process died immediately) | Show last 20 lines of log: `tail -20 dev-pipeline/state/pipeline-daemon.log` |
-| All features blocked/failed | Show status, suggest resetting failed features: `dev-pipeline/run.sh run <F-XXX> --clean` |
+| All features blocked/failed | Show status, suggest daemon-safe recovery: `dev-pipeline/reset-feature.sh <F-XXX> --clean --run feature-list.json` |
 | Permission denied on script | Run `chmod +x dev-pipeline/launch-daemon.sh dev-pipeline/run.sh` |
 
 ### Integration Notes

package/bundled/skills/feature-workflow/SKILL.md

@@ -283,22 +283,27 @@ The pipeline supports resuming from the last completed phase by detecting existi
 | `prizmkit-summarize` | Phase 7: archive to REGISTRY |
 | `prizmkit-retrospective` | Optional: post-feature lessons learned |
 | `prizmkit-bug-fix-workflow` | NOT used (separate pipeline for bugs) |
+| `refactor-workflow` | NOT used (separate pipeline for refactoring) |
 | `app-planner` | Pre-pipeline: interactive feature planning |
 
 ---
 
-## Comparison with Bug Fix Pipeline
-
-| Dimension | Feature Workflow | Bug Fix Pipeline |
-|-----------|-----------------|-----------------|
-| Input | Natural language requirement | Bug description / stack trace |
-| Pipeline Phases | 7 (Fast Path: 5) | 5 (Fast Path: 3) |
-| Artifact Docs | 3: spec.md + plan.md + tasks.md | 2: fix-plan.md + fix-report.md |
-| Artifact Path | `.prizmkit/specs/<feature-slug>/` | `.prizmkit/bugfix/<bug-id>/` |
-| Skills Chain | specify → plan → tasks → analyze → implement → review → commit + summarize | error-triage → bug-reproduce → implement → code-review → commit |
-| Commit Prefix | `feat(<scope>):` | `fix(<scope>):` |
-| REGISTRY Update | ✅ via summarize | ❌ not applicable |
-| Resume Support | ✅ artifact-based detection | ❌ |
+## Comparison with Refactor and Bug Fix Pipelines
+
+| Dimension | Feature Workflow | Refactor Workflow | Bug Fix Pipeline |
+|-----------|-----------------|-------------------|------------------|
+| Input | Natural language requirement | Module/code target | Bug description / stack trace |
+| Pipeline Phases | 7 (Fast Path: 5) | 6 (Fast Path: 4) | 5 (Fast Path: 3) |
+| Phase 1 | Specify (spec.md) | Analyze (refactor-analysis.md) | Triage (fix-plan.md) |
+| Artifact Docs | 3: spec.md + plan.md + tasks.md | 3: refactor-analysis.md + plan.md + tasks.md | 2: fix-plan.md + fix-report.md |
+| Artifact Path | `.prizmkit/specs/<feature-slug>/` | `.prizmkit/refactor/<slug>/` | `.prizmkit/bugfix/<bug-id>/` |
+| Skills Chain | specify → plan → tasks → analyze → implement → review → commit + summarize | tech-debt-tracker → plan → tasks → implement → review → commit | error-triage → bug-reproduce → implement → code-review → commit |
+| Commit Prefix | `feat(<scope>):` | `refactor(<scope>):` | `fix(<scope>):` |
+| REGISTRY Update | ✅ via summarize | ❌ not applicable | ❌ not applicable |
+| Test Strategy | TDD per task | Full suite after EVERY task | Reproduction test |
+| Scope Guard | N/A | ✅ (enforced) | N/A |
+| Behavior Change | ✅ Expected | ❌ Forbidden | ✅ Fix behavior |
+| Resume Support | ✅ artifact-based detection | ✅ artifact-based detection | ❌ |
 
 ## Path References
 

package/bundled/skills/prizmkit-bug-fix-workflow/SKILL.md

@@ -315,26 +315,31 @@ When `affected_feature` is non-empty:
 | `prizmkit-specify` | NOT used (no spec.md for bugs) |
 | `prizmkit-plan` | NOT used (no plan.md for bugs) |
 | `prizmkit-tasks` | NOT used (no tasks.md for bugs) |
+| `refactor-workflow` | NOT used (separate pipeline for refactoring) |
 
 ---
 
-## Comparison with Feature Pipeline
-
-| Dimension | Feature Pipeline | Bug Fix Pipeline |
-|-----------|-----------------|-----------------|
-| Input Skill | `app-planner` (7-phase interactive) | `bug-planner` (multi-format parser) |
-| Input File | `feature-list.json` (F-NNN) | `bug-fix-list.json` (B-NNN) |
-| Schema Version | `dev-pipeline-feature-list-v1` | `dev-pipeline-bug-fix-list-v1` |
-| Pipeline Phases | 7 Phase (Fast Path: 5) | 5 Phase (Fast Path: 3) |
-| Artifact Docs | 3: spec.md + plan.md + tasks.md | 2: fix-plan.md + fix-report.md |
-| Artifact Path | `.prizmkit/specs/<feature-slug>/` | `.prizmkit/bugfix/<bug-id>/` |
-| Prompt Template | `bootstrap-prompt.md` | `bugfix-bootstrap-prompt.md` |
-| Skills Chain | specify → plan → tasks → implement → review → summarize → commit | error-triage → bug-reproduce → implement → code-review → commit |
-| Commit Prefix | `feat(<scope>):` | `fix(<scope>):` |
-| REGISTRY Update | ✅ via summarize | ❌ not applicable |
-| TRAPS Update | Only in retrospective | ✅ automatic after every fix |
-| Manual Verification | None | Supported (verification_type=manual/hybrid) |
-| Agent Roles | PM → Dev → Reviewer → Doc | Dev → Reviewer (streamlined) |
+## Comparison with Feature and Refactor Pipelines
+
+| Dimension | Feature Pipeline | Refactor Workflow | Bug Fix Pipeline |
+|-----------|-----------------|-------------------|------------------|
+| Input Skill | `app-planner` (7-phase interactive) | Direct invocation (prizmkit.refactor) | `bug-planner` (multi-format parser) |
+| Input File | `feature-list.json` (F-NNN) | N/A (conversation trigger) | `bug-fix-list.json` (B-NNN) |
+| Schema Version | `dev-pipeline-feature-list-v1` | N/A | `dev-pipeline-bug-fix-list-v1` |
+| Pipeline Phases | 7 Phase (Fast Path: 5) | 6 Phase (Fast Path: 4) | 5 Phase (Fast Path: 3) |
+| Phase 1 | Specify (spec.md) | Analyze (refactor-analysis.md) | Triage (fix-plan.md) |
+| Artifact Docs | 3: spec.md + plan.md + tasks.md | 3: refactor-analysis.md + plan.md + tasks.md | 2: fix-plan.md + fix-report.md |
+| Artifact Path | `.prizmkit/specs/<feature-slug>/` | `.prizmkit/refactor/<slug>/` | `.prizmkit/bugfix/<bug-id>/` |
+| Prompt Template | `bootstrap-prompt.md` | N/A (in-session) | `bugfix-bootstrap-prompt.md` |
+| Skills Chain | specify → plan → tasks → implement → review → summarize → commit | tech-debt-tracker → plan → tasks → implement → review → commit | error-triage → bug-reproduce → implement → code-review → commit |
+| Commit Prefix | `feat(<scope>):` | `refactor(<scope>):` | `fix(<scope>):` |
+| REGISTRY Update | ✅ via summarize | ❌ not applicable | ❌ not applicable |
+| TRAPS Update | Only in retrospective | Resolved TRAPS removed | ✅ automatic after every fix |
+| Test Strategy | TDD per task | Full suite after EVERY task | Reproduction test |
+| Scope Guard | N/A | ✅ (enforced) | N/A |
+| Behavior Change | ✅ Expected | ❌ Forbidden | ✅ Fix behavior |
+| Manual Verification | None | None | Supported (verification_type=manual/hybrid) |
+| Agent Roles | PM → Dev → Reviewer → Doc | Dev → Reviewer (streamlined) | Dev → Reviewer (streamlined) |
 
 ## Path References
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {