@curdx/flow 3.0.0 → 3.1.0

package/hooks/scripts/flow-context-watch.sh

@@ -1,94 +0,0 @@
-#!/usr/bin/env bash
-
-set -u
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-. "$SCRIPT_DIR/common.sh"
-
-INPUT="$(cat 2>/dev/null || echo "{}")"
-
-if ! has_python3; then
-  exit 0
-fi
-
-export CURDX_FLOW_CONTEXT_WATCH_INPUT="$INPUT"
-
-read_json_field() {
-  local field="$1"
-  python3 - "$field" <<'PY' 2>/dev/null
-import json
-import os
-import sys
-
-field = sys.argv[1]
-try:
-    data = json.loads(os.environ.get("CURDX_FLOW_CONTEXT_WATCH_INPUT", "{}"))
-except Exception:
-    data = {}
-
-value = data.get(field, "")
-if value is None:
-    value = ""
-print(value)
-PY
-}
-
-HOOK_EVENT_NAME="$(read_json_field hook_event_name)"
-NEW_CWD="$(read_json_field new_cwd)"
-CURRENT_CWD="$(read_json_field cwd)"
-
-START_DIR="$CURRENT_CWD"
-if [ "$HOOK_EVENT_NAME" = "CwdChanged" ] && [ -n "$NEW_CWD" ]; then
-  START_DIR="$NEW_CWD"
-fi
-
-FLOW_ROOT="$(resolve_flow_root "$START_DIR" 2>/dev/null || true)"
-ACTIVE_SPEC=""
-SPEC_DIR=""
-
-if [ -n "$FLOW_ROOT" ] && [ -f "$FLOW_ROOT/.flow/.active-spec" ]; then
-  ACTIVE_SPEC="$(cat "$FLOW_ROOT/.flow/.active-spec" 2>/dev/null || true)"
-fi
-
-if [ -n "$FLOW_ROOT" ] && [ -n "$ACTIVE_SPEC" ]; then
-  SPEC_DIR="$FLOW_ROOT/.flow/specs/$ACTIVE_SPEC"
-fi
-
-if [ -n "${CLAUDE_ENV_FILE:-}" ]; then
-  {
-    printf 'export CURDX_FLOW_PROJECT_ROOT=%s\n' "$(json_escape "$FLOW_ROOT")"
-    printf 'export CURDX_FLOW_ACTIVE_SPEC=%s\n' "$(json_escape "$ACTIVE_SPEC")"
-    if [ -n "$SPEC_DIR" ]; then
-      printf 'export CURDX_FLOW_SPEC_DIR=%s\n' "$(json_escape "$SPEC_DIR")"
-    else
-      printf 'export CURDX_FLOW_SPEC_DIR=%s\n' "$(json_escape "")"
-    fi
-  } >> "$CLAUDE_ENV_FILE" 2>/dev/null || true
-fi
-
-if [ -z "$FLOW_ROOT" ]; then
-  printf '{"watchPaths":[]}\n'
-  exit 0
-fi
-
-export CURDX_FLOW_CONTEXT_WATCH_ROOT="$FLOW_ROOT"
-export CURDX_FLOW_CONTEXT_WATCH_ACTIVE="$ACTIVE_SPEC"
-
-python3 <<'PY' 2>/dev/null
-import json
-import os
-from pathlib import Path
-
-root = Path(os.environ["CURDX_FLOW_CONTEXT_WATCH_ROOT"])
-active = os.environ.get("CURDX_FLOW_CONTEXT_WATCH_ACTIVE", "").strip()
-
-watch_paths = [str(root / ".flow" / ".active-spec")]
-if active:
-    spec_dir = root / ".flow" / "specs" / active
-    watch_paths.append(str(spec_dir / ".state.json"))
-    watch_paths.append(str(spec_dir / "tasks.md"))
-
-print(json.dumps({"watchPaths": watch_paths}, ensure_ascii=True))
-PY
-
-exit 0

package/hooks/scripts/inject-karpathy.sh

@@ -1,53 +0,0 @@
-#!/usr/bin/env bash
-# CurDX-Flow SessionStart baseline injection
-# Injects the L1 baseline (Karpathy 4 principles + mandatory tool rules + 3 red lines)
-# as additionalContext at every session boot (startup, /clear, post-compact).
-#
-# Wired under SessionStart with matcher "startup|clear|compact" so the
-# baseline survives startup, /clear, and post-compact resume.
-
-set -u
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-. "$SCRIPT_DIR/common.sh"
-
-CONTEXT='## CurDX-Flow Mind Baseline (L1 — always on)
-
-### 1. Think Before Coding
-- State assumptions before any non-trivial task
-- When uncertain, use AskUserQuestion — do not silently assume
-- When confused, stop — do not push forward
-
-### 2. Simplicity First
-- YAGNI: do not write features beyond what was requested
-- No single-use abstractions
-- If 200 lines suffice, do not write 1000
-
-### 3. Surgical Changes
-- Modify only the lines that must change
-- Match existing style
-- Do not delete pre-existing dead code
-
-### 4. Goal-Driven
-- Define a verifiable success criterion first
-- Forbidden to say done/fixed/working without evidence
-
-## Mandatory Tools (L2 — enforced)
-
-- library/framework questions → **context7 first** (`mcp__context7__*`); forbidden to rely on training memory
-- planning / design / architecture / review → **sequential-thinking first** (≥5 thoughts)
-- before any task → **claude-mem search** (if installed)
-- UI code → **frontend-design skill** (if installed)
-- browser QA → **chrome-devtools MCP**
-
-## Three Red Lines (L3 — inherited from pua, universal)
-
-1. **Closed loop**: claiming "done"? Provide evidence (build output / passing tests / curl result)
-2. **Fact-driven**: verify before saying "probably". An unverified attribution is blame-shifting
-3. **Exhaust everything**: before saying "I cannot", complete the systematic 4-stage debugging'
-
-if has_python3; then
-  emit_session_start_context "$CONTEXT"
-fi
-
-exit 0

package/hooks/scripts/quick-mode-guard.sh

@@ -1,69 +0,0 @@
-#!/usr/bin/env bash
-# CurDX-Flow PreToolUse Hook for AskUserQuestion
-# Blocks AskUserQuestion when the active spec has quickMode=true.
-# This prevents quick execution loops from stalling waiting for user input.
-#
-# The hook reads Claude's PreToolUse input JSON from stdin. We only act when
-# the tool being invoked is AskUserQuestion.
-
-set -u
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-. "$SCRIPT_DIR/common.sh"
-
-# Read input (Claude sends JSON on stdin for PreToolUse)
-INPUT=$(cat 2>/dev/null || echo "{}")
-
-if ! command -v python3 >/dev/null 2>&1; then
-  # Without JSON parsing, allow everything (fail open)
-  exit 0
-fi
-
-# Parse the tool name being invoked
-TOOL_NAME=$(echo "$INPUT" | python3 -c '
-import json, sys
-try:
-    d = json.load(sys.stdin)
-    print(d.get("tool_name", ""))
-except Exception:
-    print("")
-' 2>/dev/null)
-
-# We only guard AskUserQuestion
-if [ "$TOOL_NAME" != "AskUserQuestion" ]; then
-  exit 0
-fi
-
-# Check if we're in a flow project with quick mode enabled.
-FLOW_ROOT="$(resolve_flow_root 2>/dev/null || true)"
-[ -n "$FLOW_ROOT" ] || exit 0
-
-ACTIVE=$(cat "$FLOW_ROOT/.flow/.active-spec" 2>/dev/null)
-[ -z "$ACTIVE" ] && exit 0
-
-STATE_FILE="$FLOW_ROOT/.flow/specs/$ACTIVE/.state.json"
-[ ! -f "$STATE_FILE" ] && exit 0
-
-# Read quickMode. Pass STATE_FILE via env (NOT shell interpolation
-# into the python source) so an active-spec name containing quotes/$ cannot
-# inject python code.
-export STATE_FILE
-QUICK_MODE=$(python3 -c '
-import json, os
-try:
-    s = json.load(open(os.environ["STATE_FILE"]))
-    qm = s.get("quickMode", False)
-    print("true" if qm else "false")
-except Exception:
-    print("false")
-' 2>/dev/null)
-
-if [ "$QUICK_MODE" = "true" ]; then
-  # Block and inject guidance
-  MSG="[CurDX-Flow quick-mode-guard] Active spec '$ACTIVE' is in quick mode — AskUserQuestion is forbidden. Decide based on user preferences in .flow/CONTEXT.md plus the most reasonable assumption, and record your assumption in .progress.md."
-  emit_pretooluse_deny "$MSG"
-  exit 0
-fi
-
-# Allow
-exit 0

package/hooks/scripts/session-start.sh

@@ -1,94 +0,0 @@
-#!/usr/bin/env bash
-# CurDX-Flow SessionStart Hook
-# Duties:
-#   1. Daily dependency check — nudge user to `npx @curdx/flow install --all` if recommended plugins missing
-#   2. Load active spec progress into session context
-#   3. Persist stable CurDX-Flow environment hints for this session
-#
-# Design notes:
-#   - Idempotent: marker file tracks last check date
-#   - Silent when everything is healthy (no noise)
-#   - Graceful degradation: missing `claude` CLI doesn't break hook
-
-set -u
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-. "$SCRIPT_DIR/common.sh"
-
-DATA_DIR="${CLAUDE_PLUGIN_DATA:-$HOME/.claude/plugins/data/curdx-flow}"
-MARKER="$DATA_DIR/.deps-checked"
-TODAY="$(date +%Y-%m-%d)"
-ADDITIONAL_CONTEXT=""
-FLOW_ROOT="$(resolve_flow_root 2>/dev/null || true)"
-
-mkdir -p "$DATA_DIR" 2>/dev/null || true
-
-# ---------- 1. Dependency check (once per day) ----------
-LAST_CHECK=""
-[ -f "$MARKER" ] && LAST_CHECK="$(cat "$MARKER" 2>/dev/null)"
-
-if env_flag_enabled "${CLAUDE_PLUGIN_OPTION_DAILY_DEPENDENCY_CHECK:-1}" && [ "$LAST_CHECK" != "$TODAY" ]; then
-  MISSING=()
-
-  # Skip if `claude` CLI is not on PATH
-  if command -v claude >/dev/null 2>&1; then
-    INSTALLED="$(claude plugin list 2>/dev/null || true)"
-
-    # Names must stay in lockstep with cli/registry.js RECOMMENDED_PLUGINS.
-    # Drift is guarded by test/registry-session-start-parity.test.js.
-    echo "$INSTALLED" | grep -q 'pua'                 || MISSING+=("pua")
-    echo "$INSTALLED" | grep -q 'claude-mem'          || MISSING+=("claude-mem")
-    echo "$INSTALLED" | grep -q 'frontend-design'     || MISSING+=("frontend-design")
-    echo "$INSTALLED" | grep -q 'chrome-devtools-mcp' || MISSING+=("chrome-devtools-mcp")
-  fi
-
-  if [ "${#MISSING[@]}" -gt 0 ]; then
-    JOINED="$(IFS=,; echo "${MISSING[*]}")"
-    ADDITIONAL_CONTEXT+="## CurDX-Flow Recommended Plugins Check\n\nThe following recommended plugins were not detected: **${JOINED}**\n\nRun \`npx @curdx/flow install --all\` for interactive one-shot install. Run \`npx @curdx/flow doctor\` for the full health report.\n\n"
-  fi
-
-  { echo "$TODAY" > "$MARKER"; } 2>/dev/null || true
-fi
-
-# ---------- 2. Load .flow/ state (if project is a flow project) ----------
-if [ -n "$FLOW_ROOT" ]; then
-  ADDITIONAL_CONTEXT+="## CurDX-Flow Project Active\n\n"
-  ADDITIONAL_CONTEXT+="- Plugin root: \`${CLAUDE_PLUGIN_ROOT:-unknown}\`\n"
-  ADDITIONAL_CONTEXT+="- Plugin data: \`${CLAUDE_PLUGIN_DATA:-$DATA_DIR}\`\n"
-  ADDITIONAL_CONTEXT+="- Best practice: write long agent artifacts to disk first; keep final assistant summaries short.\n\n"
-
-  if [ -f "$FLOW_ROOT/.flow/PROJECT.md" ]; then
-    ADDITIONAL_CONTEXT+="### Project Vision\n$(head -80 "$FLOW_ROOT/.flow/PROJECT.md")\n\n"
-  fi
-
-  if [ -f "$FLOW_ROOT/.flow/.active-spec" ]; then
-    ACTIVE="$(cat "$FLOW_ROOT/.flow/.active-spec" 2>/dev/null)"
-    if [ -n "$ACTIVE" ] && [ -d "$FLOW_ROOT/.flow/specs/$ACTIVE" ]; then
-      ADDITIONAL_CONTEXT+="### Active Spec: \`$ACTIVE\`\n\n"
-      if [ -f "$FLOW_ROOT/.flow/specs/$ACTIVE/.progress.md" ]; then
-        ADDITIONAL_CONTEXT+="$(head -40 "$FLOW_ROOT/.flow/specs/$ACTIVE/.progress.md")\n\n"
-      fi
-    fi
-  fi
-fi
-
-# ---------- 3. Persist session environment hints ----------
-if [ -n "${CLAUDE_ENV_FILE:-}" ]; then
-  {
-    printf 'export CURDX_FLOW_PLUGIN_ROOT=%s\n' "$(json_escape "${CLAUDE_PLUGIN_ROOT:-}")"
-    printf 'export CURDX_FLOW_PLUGIN_DATA=%s\n' "$(json_escape "${CLAUDE_PLUGIN_DATA:-$DATA_DIR}")"
-    if [ -n "$FLOW_ROOT" ]; then
-      printf 'export CURDX_FLOW_PROJECT_ROOT=%s\n' "$(json_escape "$FLOW_ROOT")"
-    fi
-    if [ -n "$FLOW_ROOT" ] && [ -f "$FLOW_ROOT/.flow/.active-spec" ]; then
-      printf 'export CURDX_FLOW_ACTIVE_SPEC=%s\n' "$(json_escape "$(cat "$FLOW_ROOT/.flow/.active-spec" 2>/dev/null)")"
-    fi
-  } >> "$CLAUDE_ENV_FILE" 2>/dev/null || true
-fi
-
-# ---------- 4. Emit hook output ----------
-if [ -n "$ADDITIONAL_CONTEXT" ]; then
-  emit_session_start_context "$ADDITIONAL_CONTEXT"
-fi
-
-exit 0

package/hooks/scripts/session-title.sh

@@ -1,87 +0,0 @@
-#!/usr/bin/env bash
-
-set -u
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-. "$SCRIPT_DIR/common.sh"
-
-INPUT="$(cat 2>/dev/null || echo "{}")"
-DATA_DIR="${CLAUDE_PLUGIN_DATA:-$HOME/.claude/plugins/data/curdx-flow}"
-FLOW_ROOT="$(resolve_flow_root 2>/dev/null || true)"
-
-[ -n "$FLOW_ROOT" ] || exit 0
-
-ACTIVE="$(cat "$FLOW_ROOT/.flow/.active-spec" 2>/dev/null || true)"
-[ -n "$ACTIVE" ] || exit 0
-
-if ! has_python3; then
-  emit_userprompt_submit_title "curdx-flow/${ACTIVE}"
-  exit 0
-fi
-
-export CURDX_FLOW_SESSION_TITLE_INPUT="$INPUT"
-export CURDX_FLOW_SESSION_TITLE_ACTIVE="$ACTIVE"
-export CURDX_FLOW_ROOT="$FLOW_ROOT"
-
-TITLE_INFO="$(python3 <<'PY' 2>/dev/null
-import json
-import os
-from pathlib import Path
-
-active = os.environ["CURDX_FLOW_SESSION_TITLE_ACTIVE"]
-data = json.loads(os.environ.get("CURDX_FLOW_SESSION_TITLE_INPUT", "{}"))
-session_id = data.get("session_id", "")
-
-phase = ""
-task_index = 0
-total_tasks = 0
-
-state_path = Path(os.environ["CURDX_FLOW_ROOT"]) / ".flow" / "specs" / active / ".state.json"
-if state_path.exists():
-    try:
-        state = json.loads(state_path.read_text(encoding="utf-8"))
-        phase = state.get("phase") or ""
-        execute_state = state.get("execute_state") or {}
-        task_index = int(execute_state.get("task_index") or 0)
-        total_tasks = int(execute_state.get("total_tasks") or 0)
-    except Exception:
-        phase = ""
-        task_index = 0
-        total_tasks = 0
-
-label = phase
-if phase == "execute" and total_tasks > 0:
-    label = f"{phase} {task_index}/{total_tasks}"
-
-title = f"curdx-flow/{active}"
-if label:
-    title = f"{title} [{label}]"
-
-print(session_id)
-print(title)
-PY
-)"
-
-SESSION_ID="$(printf '%s\n' "$TITLE_INFO" | sed -n '1p')"
-TITLE="$(printf '%s\n' "$TITLE_INFO" | sed -n '2p')"
-[ -n "$TITLE" ] || exit 0
-
-if [ -n "$SESSION_ID" ]; then
-  MARKER_DIR="$DATA_DIR/session-titles"
-  MARKER_FILE="$MARKER_DIR/$SESSION_ID"
-  LAST_TITLE=""
-
-  if [ -f "$MARKER_FILE" ]; then
-    LAST_TITLE="$(cat "$MARKER_FILE" 2>/dev/null || true)"
-  fi
-
-  if [ "$LAST_TITLE" = "$TITLE" ]; then
-    exit 0
-  fi
-
-  mkdir -p "$MARKER_DIR" 2>/dev/null || true
-  printf '%s\n' "$TITLE" > "$MARKER_FILE" 2>/dev/null || true
-fi
-
-emit_userprompt_submit_title "$TITLE"
-exit 0

package/hooks/scripts/stop-watcher.sh

@@ -1,231 +0,0 @@
-#!/usr/bin/env bash
-# CurDX-Flow Stop Hook — StopHookLoop strategy implementation
-#
-# Fires when Claude's turn ends. Decides whether to block (force continue)
-# or allow the session to stop.
-#
-# Decision logic:
-#   1. Not a flow project? → allow stop
-#   2. No active spec? → allow stop
-#   3. Strategy is not "stop-hook"? → allow stop
-#   4. Phase != "execute"? → allow stop
-#   5. All tasks done OR "ALL_TASKS_COMPLETE" in transcript? → cleanup + allow stop
-#   6. Too many rounds (>100) or too many failures (>3)? → stop + warn
-#   7. Otherwise → block and force continue next task
-
-set -u
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-. "$SCRIPT_DIR/common.sh"
-
-DATA_DIR="${CLAUDE_PLUGIN_DATA:-$HOME/.claude/plugins/data/curdx-flow}"
-
-# ---------- helper: exit with "allow stop" ----------
-allow_stop() {
-  # No output = allow stop normally
-  exit 0
-}
-
-autonomous_blocking_enabled() {
-  env_flag_enabled "${CLAUDE_PLUGIN_OPTION_AUTONOMOUS_BLOCKING:-1}"
-}
-
-# ---------- helper: block and inject continuation ----------
-block_continue() {
-  local reason="$1"
-  emit_stop_block "$reason"
-  exit 0
-}
-
-# ---------- 1. Must be a flow project ----------
-FLOW_ROOT="$(resolve_flow_root 2>/dev/null || true)"
-[ -n "$FLOW_ROOT" ] || allow_stop
-
-# ---------- 2. Must have active spec ----------
-ACTIVE=$(cat "$FLOW_ROOT/.flow/.active-spec" 2>/dev/null)
-[ -z "$ACTIVE" ] && allow_stop
-SPEC_DIR="$FLOW_ROOT/.flow/specs/$ACTIVE"
-[ ! -d "$SPEC_DIR" ] && allow_stop
-
-STATE_FILE="$SPEC_DIR/.state.json"
-[ ! -f "$STATE_FILE" ] && allow_stop
-
-# ---------- 3-4. Strategy + phase check (use python3 for JSON parsing) ----------
-if ! command -v python3 >/dev/null 2>&1; then
-  # Without python3 we can't safely parse JSON. Allow stop.
-  allow_stop
-fi
-
-# Export STATE_FILE BEFORE invoking python3 — the heredoc-based parser reads
-# os.environ["STATE_FILE"]. Previously the export was placed after the
-# heredoc, so python3 always got None, json.load(None) silently failed, and
-# the stop-hook strategy never activated.
-export STATE_FILE
-
-read STRATEGY PHASE TASK_INDEX TOTAL_TASKS FAILED ROUNDS RECOVERY_MODE MAX_FIX_TASKS <<EOF
-$(python3 <<'PY'
-import json, os, sys
-p = os.environ.get("STATE_FILE")
-try:
-    s = json.load(open(p))
-except Exception:
-    sys.exit(0)
-strategy = s.get("strategy", "auto")
-phase = s.get("phase", "")
-ex = s.get("execute_state", {}) or {}
-ti = ex.get("task_index", 0)
-tt = ex.get("total_tasks", 0)
-failed = ex.get("failed_attempts", 0)
-rounds = ex.get("global_iteration", 0)
-recovery_mode = ex.get("recovery_mode", "manual")
-max_fix_tasks = ex.get("max_fix_tasks_per_original", 2)
-print(strategy, phase, ti, tt, failed, rounds, recovery_mode, max_fix_tasks)
-PY
-)
-EOF
-
-# Only activate for stop-hook strategy + execute phase
-[ "$STRATEGY" != "stop-hook" ] && allow_stop
-[ "$PHASE" != "execute" ] && allow_stop
-
-if ! autonomous_blocking_enabled; then
-  allow_stop
-fi
-
-# ---------- 5. Check hook input + completion signal in transcript ----------
-# Claude Code passes transcript path via stdin as JSON: {"transcript_path": "/path/..."}
-# We read stdin to detect ALL_TASKS_COMPLETE or TASK_FAILED
-INPUT=$(cat 2>/dev/null || echo "{}")
-TRANSCRIPT_PATH=$(echo "$INPUT" | python3 -c 'import json,sys;
-try: print(json.load(sys.stdin).get("transcript_path",""))
-except: print("")' 2>/dev/null)
-
-STOP_HOOK_ACTIVE=$(echo "$INPUT" | python3 -c 'import json,sys;
-try: print("true" if json.load(sys.stdin).get("stop_hook_active", False) else "false")
-except: print("false")' 2>/dev/null)
-
-if [ "$STOP_HOOK_ACTIVE" = "true" ]; then
-  # Claude Code sets stop_hook_active during a stop-hook continuation.
-  # Treat it as context only: the final decision still comes from transcript
-  # signals, state-file progress, and tasks.md parity. Unconditionally allowing
-  # stop here can terminate an in-flight stop-hook loop after the first
-  # continuation, leaving remaining tasks stranded.
-  echo "[CurDX-Flow stop-hook] stop_hook_active=true; evaluating transcript/state before deciding" >&2
-fi
-
-TRANSCRIPT_TAIL=""
-if [ -n "$TRANSCRIPT_PATH" ] && [ -f "$TRANSCRIPT_PATH" ]; then
-  # Read last 50KB only (efficiency)
-  TRANSCRIPT_TAIL=$(tail -c 51200 "$TRANSCRIPT_PATH" 2>/dev/null || echo "")
-fi
-
-# Python state-file updates: use quoted heredocs (<<'PY') + os.environ so
-# the spec-name-derived STATE_FILE path is NEVER interpolated into the
-# python source text. Previously a spec name containing single quotes or
-# $-signs could break the script or inject arbitrary code.
-
-# Helper: count unchecked tasks in tasks.md. If tasks.md is absent, return 0
-# to avoid blocking recovery for partially-initialized specs.
-unchecked_task_count() {
-  local tasks_file="$SPEC_DIR/tasks.md"
-  [ ! -f "$tasks_file" ] && { echo 0; return; }
-  grep -Ec '^- \[ \] \*\*[0-9]+(\.[0-9]+|\.VF|\.X|\.X\+1)*\*\*' "$tasks_file" 2>/dev/null || echo 0
-}
-
-last_task_signal() {
-  local msg="${1:-}"
-  printf '%s' "$msg" \
-    | grep -Eo 'ALL_TASKS_COMPLETE|TASK_(COMPLETE|FAILED):[[:space:]]*[0-9]+(\.([0-9]+|VF|X(\+[0-9]+)?))*' \
-    | tail -1
-}
-
-failed_task_id() {
-  local msg="${1:-}"
-  printf '%s' "$msg" | sed -nE 's/.*TASK_FAILED:[[:space:]]*([0-9]+(\.([0-9]+|VF|X(\+[0-9]+)?))*).*/\1/p' | tail -1
-}
-
-mark_execute_complete() {
-  python3 <<'PY' 2>/dev/null
-import json, os
-p = os.environ["STATE_FILE"]
-s = json.load(open(p))
-s.setdefault("phase_status", {})["execute"] = "completed"
-s["phase"] = "verify"
-json.dump(s, open(p, "w"), indent=2, ensure_ascii=False)
-PY
-}
-
-# Check for explicit completion signals
-LAST_TASK_SIGNAL="$(last_task_signal "$TRANSCRIPT_TAIL")"
-
-if [ "$LAST_TASK_SIGNAL" = "ALL_TASKS_COMPLETE" ]; then
-  UNCHECKED="$(unchecked_task_count)"
-  if [ "${UNCHECKED:-0}" -gt 0 ]; then
-    block_continue "[CurDX-Flow stop-hook] ALL_TASKS_COMPLETE was emitted, but tasks.md still has ${UNCHECKED} unchecked task(s). Read .flow/specs/${ACTIVE}/tasks.md, complete only the remaining unchecked tasks, update tasks.md, then emit ALL_TASKS_COMPLETE again."
-  fi
-  mark_execute_complete
-  allow_stop
-fi
-
-# Check for the latest fail signal (accumulate; actual stop decision below)
-if printf '%s' "$LAST_TASK_SIGNAL" | grep -q "^TASK_FAILED"; then
-  FAILED_TASK="$(failed_task_id "$LAST_TASK_SIGNAL")"
-  [ -z "$FAILED_TASK" ] && FAILED_TASK="the current task"
-
-  # Increment failed_attempts
-  python3 <<'PY' 2>/dev/null
-import json, os
-p = os.environ["STATE_FILE"]
-s = json.load(open(p))
-s.setdefault("execute_state", {})
-s["execute_state"]["failed_attempts"] = s["execute_state"].get("failed_attempts", 0) + 1
-json.dump(s, open(p, "w"), indent=2, ensure_ascii=False)
-PY
-  # Re-read — again via os.environ, no shell interpolation into python.
-  FAILED=$(python3 -c 'import json, os; print(json.load(open(os.environ["STATE_FILE"]))["execute_state"]["failed_attempts"])' 2>/dev/null || echo 0)
-
-  if [ "${FAILED:-0}" -lt 3 ]; then
-    if [ "${RECOVERY_MODE:-manual}" = "fix-task" ]; then
-      block_continue "[CurDX-Flow stop-hook] TASK_FAILED observed for ${FAILED_TASK}. Do not skip it. Recovery mode is fix-task: insert one targeted [FIX ${FAILED_TASK}] task immediately after the failed task in tasks.md (max ${MAX_FIX_TASKS:-2} fix task(s) per original), update .state.json execute_state.fix_task_map, then execute the fix task before retrying ${FAILED_TASK}. The fix task must include Do, Files, Done when, Verify, and Commit fields."
-    fi
-
-    block_continue "[CurDX-Flow stop-hook] TASK_FAILED observed for ${FAILED_TASK}. Do not advance past the failed task. Re-read tasks.md, perform root-cause analysis, retry the first unchecked task, and emit TASK_COMPLETE only after its Verify command passes. failed_attempts=${FAILED}/3."
-  fi
-fi
-
-# ---------- 6. Safety brakes ----------
-if [ "$FAILED" -ge 3 ]; then
-  # Too many failures — stop and surface
-  allow_stop
-fi
-
-if [ "$ROUNDS" -ge 100 ]; then
-  # Runaway loop protection
-  allow_stop
-fi
-
-# Check if all tasks done
-if [ "$TASK_INDEX" -ge "$TOTAL_TASKS" ] && [ "$TOTAL_TASKS" -gt 0 ]; then
-  UNCHECKED="$(unchecked_task_count)"
-  if [ "${UNCHECKED:-0}" -gt 0 ]; then
-    block_continue "[CurDX-Flow stop-hook] State says execute is complete (${TASK_INDEX}/${TOTAL_TASKS}), but tasks.md still has ${UNCHECKED} unchecked task(s). Continue with the first unchecked task; do not add new tasks."
-  fi
-  mark_execute_complete
-  allow_stop
-fi
-
-# ---------- 7. Block and continue ----------
-# Increment round counter
-python3 <<'PY' 2>/dev/null
-import json, os
-p = os.environ["STATE_FILE"]
-s = json.load(open(p))
-s.setdefault("execute_state", {})
-s["execute_state"]["global_iteration"] = s["execute_state"].get("global_iteration", 0) + 1
-json.dump(s, open(p, "w"), indent=2, ensure_ascii=False)
-PY
-
-NEXT_INDEX=$((TASK_INDEX + 1))
-REASON="[CurDX-Flow stop-hook] Spec '$ACTIVE' has tasks remaining ($TASK_INDEX/$TOTAL_TASKS). Continue to the next task. Dispatch flow-executor for task_id=next. On completion, emit TASK_COMPLETE or TASK_FAILED. When all tasks are done, emit ALL_TASKS_COMPLETE."
-
-block_continue "$REASON"