@curdx/flow 2.3.11 → 3.1.0

package/hooks/scripts/stop-watcher.sh

@@ -1,230 +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 ----------
-[ ! -d ".flow" ] && allow_stop
-
-# ---------- 2. Must have active spec ----------
-ACTIVE=$(cat .flow/.active-spec 2>/dev/null)
-[ -z "$ACTIVE" ] && allow_stop
-SPEC_DIR=".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"

package/hooks/scripts/subagent-artifact-guard.sh

@@ -1,159 +0,0 @@
-#!/usr/bin/env bash
-# CurDX-Flow SubagentStop Hook
-# Blocks successful subagent completion if the expected artifact never landed on disk.
-#
-# Why:
-# - long markdown/report-writing agents can truncate near the end of a run
-# - users then see a cheerful success summary but the actual file is missing or tiny
-# - latest Claude Code hooks expose SubagentStop with agent_type + last_assistant_message,
-#   which lets us guard only "success-looking" exits while allowing genuine precondition failures
-
-set -u
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-. "$SCRIPT_DIR/common.sh"
-
-INPUT="$(cat 2>/dev/null || echo "{}")"
-
-if ! has_python3; then
-  # Without JSON parsing, fail open rather than blocking subagents blindly.
-  exit 0
-fi
-
-export SUBAGENT_GUARD_INPUT="$INPUT"
-
-AGENT_TYPE="$(python3 -c 'import json, os
-try:
-    data = json.loads(os.environ["SUBAGENT_GUARD_INPUT"])
-    print(data.get("agent_type", ""))
-except Exception:
-    print("")
-' 2>/dev/null)"
-
-LAST_MESSAGE="$(python3 -c 'import json, os
-try:
-    data = json.loads(os.environ["SUBAGENT_GUARD_INPUT"])
-    print((data.get("last_assistant_message") or "").strip())
-except Exception:
-    print("")
-' 2>/dev/null)"
-
-looks_like_success() {
-  local msg="${1:-}"
-  printf '%s' "$msg" | grep -Eq '(^✓| generated$| generated\n|Wrote |Review complete|Requirements done|Research complete|UI Sketch generation complete|Report:|Next:|TASK_COMPLETE|ALL_TASKS_COMPLETE)'
-}
-
-active_spec_path() {
-  local file_name="$1"
-
-  [ ! -d ".flow" ] && return 1
-
-  local active
-  active="$(cat .flow/.active-spec 2>/dev/null)"
-  [ -z "$active" ] && return 1
-
-  printf '.flow/specs/%s/%s\n' "$active" "$file_name"
-}
-
-completed_task_id() {
-  local msg="${1:-}"
-  printf '%s' "$msg" | sed -nE 's/.*TASK_COMPLETE:[[:space:]]*([0-9]+(\.([0-9]+|VF|X(\+[0-9]+)?))*).*/\1/p' | head -1
-}
-
-artifact_target=""
-minimum_size=200
-
-case "$AGENT_TYPE" in
-  flow-researcher)
-    artifact_target="$(active_spec_path research.md)" || exit 0
-    minimum_size=400
-    ;;
-  flow-product-designer)
-    artifact_target="$(active_spec_path requirements.md)" || exit 0
-    minimum_size=400
-    ;;
-  flow-architect)
-    artifact_target="$(active_spec_path design.md)" || exit 0
-    minimum_size=400
-    ;;
-  flow-planner)
-    artifact_target="$(active_spec_path tasks.md)" || exit 0
-    minimum_size=400
-    ;;
-  flow-executor)
-    artifact_target="$(active_spec_path tasks.md)" || exit 0
-    if printf '%s' "$LAST_MESSAGE" | grep -q 'ALL_TASKS_COMPLETE'; then
-      exit 0
-    fi
-    task_id="$(completed_task_id "$LAST_MESSAGE")"
-    [ -z "$task_id" ] && exit 0
-    if grep -Eq "^- \\[x\\] \\*\\*${task_id//./\\.}\\*\\*" "$artifact_target" 2>/dev/null; then
-      exit 0
-    fi
-    emit_subagentstop_block "[CurDX-Flow subagent-artifact-guard] flow-executor emitted TASK_COMPLETE: ${task_id}, but ${artifact_target} does not mark that task as [x]. Update tasks.md and the spec progress/state before stopping."
-    exit 0
-    ;;
-  flow-debugger)
-    artifact_target="$(active_spec_path debug-report.md)" || exit 0
-    minimum_size=250
-    ;;
-  flow-triage-analyst)
-    artifact_target="$(active_spec_path triage-report.md)" || exit 0
-    minimum_size=250
-    ;;
-  flow-ux-designer)
-    artifact_target="$(active_spec_path ui-sketch.md)" || exit 0
-    minimum_size=250
-    ;;
-  flow-reviewer)
-    artifact_target="$(active_spec_path review-report.md)" || exit 0
-    minimum_size=300
-    ;;
-  flow-verifier)
-    artifact_target="$(active_spec_path verification-report.md)" || exit 0
-    minimum_size=300
-    ;;
-  flow-security-auditor)
-    artifact_target="$(active_spec_path security-audit.md)" || exit 0
-    minimum_size=250
-    ;;
-  flow-qa-engineer)
-    artifact_target="$(active_spec_path qa-report.md)" || exit 0
-    minimum_size=250
-    ;;
-  flow-edge-hunter)
-    artifact_target="$(active_spec_path edge-cases.md)" || exit 0
-    minimum_size=250
-    ;;
-  flow-adversary)
-    artifact_target="$(active_spec_path adversarial-review.md)" || exit 0
-    minimum_size=250
-    ;;
-  flow-ui-researcher)
-    artifact_target="$(active_spec_path ui-research.md)" || exit 0
-    minimum_size=250
-    ;;
-  flow-brownfield-analyst)
-    artifact_target=".flow/codebase-index.md"
-    minimum_size=250
-    ;;
-  *)
-    exit 0
-    ;;
-esac
-
-if [ -f "$artifact_target" ]; then
-  size="$(wc -c < "$artifact_target" 2>/dev/null | tr -d ' ')"
-  if [ "${size:-0}" -ge "$minimum_size" ]; then
-    exit 0
-  fi
-fi
-
-if ! looks_like_success "$LAST_MESSAGE"; then
-  # The subagent appears to be stopping because of a real precondition failure,
-  # clarification request, or other non-success path. Let that response through.
-  exit 0
-fi
-
-emit_subagentstop_block "[CurDX-Flow subagent-artifact-guard] ${AGENT_TYPE} is stopping with a success summary, but ${artifact_target} is missing or too small. Write the full artifact to disk first, then respond with the minimal completion summary only."
-exit 0

package/hooks/scripts/subagent-statusline.sh

@@ -1,105 +0,0 @@
-#!/usr/bin/env bash
-# CurDX-Flow subagentStatusLine command.
-# Reads the official subagent status-line JSON payload from stdin and emits
-# one JSON line per CurDX-Flow subagent row that should be overridden.
-
-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_SUBAGENT_STATUSLINE_INPUT="$INPUT"
-
-python3 <<'PY'
-import json
-import os
-from pathlib import Path
-
-try:
-    data = json.loads(os.environ.get("CURDX_SUBAGENT_STATUSLINE_INPUT", "{}"))
-except Exception:
-    raise SystemExit(0)
-
-columns = data.get("columns")
-try:
-    columns = int(columns)
-except Exception:
-    columns = 100
-columns = max(40, columns)
-
-
-def flow_type(task):
-    raw = str(task.get("type") or task.get("name") or task.get("label") or "")
-    if raw.startswith("curdx-flow:"):
-        raw = raw.split(":", 1)[1]
-    return raw
-
-
-def is_flow_task(task):
-    values = [
-        task.get("type"),
-        task.get("name"),
-        task.get("label"),
-        task.get("description"),
-    ]
-    return any(str(value or "").startswith(("flow-", "curdx-flow:flow-")) for value in values)
-
-
-def active_spec(cwd):
-    if not cwd:
-        return ""
-    try:
-        value = (Path(cwd) / ".flow" / ".active-spec").read_text(encoding="utf-8").strip()
-    except Exception:
-        return ""
-    return value[:40]
-
-
-def token_label(value):
-    try:
-        count = int(value)
-    except Exception:
-        return ""
-    if count >= 1000:
-        return f"{count / 1000:.1f}k tok"
-    return f"{count} tok"
-
-
-def clamp(text):
-    if len(text) <= columns:
-        return text
-    if columns <= 4:
-        return text[:columns]
-    return text[: columns - 3] + "..."
-
-
-for task in data.get("tasks") or []:
-    if not isinstance(task, dict) or not is_flow_task(task):
-        continue
-
-    task_id = task.get("id")
-    if not task_id:
-        continue
-
-    parts = ["[curdx-flow]", flow_type(task) or "flow-agent"]
-
-    status = str(task.get("status") or "").strip()
-    if status:
-        parts.append(status)
-
-    spec = active_spec(task.get("cwd"))
-    if spec:
-        parts.append(f"spec:{spec}")
-
-    tokens = token_label(task.get("tokenCount"))
-    if tokens:
-        parts.append(tokens)
-
-    print(json.dumps({"id": str(task_id), "content": clamp(" | ".join(parts))}, ensure_ascii=True))
-PY

package/knowledge/artifact-output-discipline.md

@@ -1,24 +0,0 @@
-# Artifact Output Discipline
-
-Use this discipline for artifact-producing agents that write canonical files
-such as `research.md`, `requirements.md`, `design.md`, `tasks.md`, or
-`codebase-index.md`.
-
-## Core Rules
-
-1. Write the artifact first. The first substantive action should be the `Write`
-   tool call for the final file content.
-2. Do not preview or paraphrase the artifact inline. The file is the
-   deliverable.
-3. Keep status updates minimal: short bullets or fixed summary lines only.
-4. End with the exact compact output contract defined by the agent-specific
-   section. No extra explanation before or after it.
-5. If something blocks the write, report the blocker directly instead of
-   emitting a fake success summary.
-
-## Why
-
-- Prevents context waste from duplicating the artifact in chat
-- Makes the written file the canonical output surface
-- Keeps artifact-producing subagents consistent across research, product,
-  architecture, planning, and brownfield mapping

package/knowledge/artifact-summary-contracts.md

@@ -1,50 +0,0 @@
-# Artifact Summary Contracts
-
-Use these compact summary contracts after an artifact lands successfully. Pair
-them with `artifact-output-discipline.md`: write first, no preview, then emit
-the exact contract below and stop.
-
-## research.md
-
-```text
-✓ research.md generated
-Recommendations: N
-Next: /curdx-flow:spec --phase=requirements
-```
-
-## requirements.md
-
-```text
-✓ requirements.md generated
-User stories: N
-Functional requirements: N
-Next: /curdx-flow:spec --phase=design
-```
-
-## design.md
-
-```text
-✓ design.md generated
-Architecture decisions: N
-Components: N
-Next: /curdx-flow:spec --phase=tasks
-```
-
-## tasks.md
-
-```text
-✓ tasks.md generated
-Total tasks: N
-Coverage audit: PASS
-Phases: 1-5
-Next: /curdx-flow:implement
-```
-
-## codebase-index.md
-
-```text
-✓ codebase-index.md generated
-Modules: N
-Entry points: N
-Next: /curdx-flow:start <feature-name>
-```