all-for-claudecode 2.0.0 → 2.2.0

package/scripts/afc-consistency-check.sh

@@ -0,0 +1,261 @@
+#!/bin/bash
+set -euo pipefail
+
+# afc-consistency-check.sh — Cross-reference validation for project consistency
+# Checks: config placeholders, agent names, hook scripts, test coverage
+# Run as part of: npm run lint
+
+# shellcheck disable=SC2329
+cleanup() {
+  :
+}
+trap cleanup EXIT
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="${1:-$(cd "$SCRIPT_DIR/.." && pwd)}"
+ERRORS=0
+WARNINGS=0
+
+# --- Helpers ---
+
+fail() {
+  printf "[afc:consistency] FAIL: %s\n" "$1" >&2
+  ERRORS=$((ERRORS + 1))
+}
+
+warn() {
+  printf "[afc:consistency] WARN: %s\n" "$1" >&2
+  WARNINGS=$((WARNINGS + 1))
+}
+
+ok() {
+  printf "[afc:consistency] ✓ %s\n" "$1"
+}
+
+# --- Check 1: Config Placeholder Validation ---
+# Verify all {config.*} references in commands/ and docs/ map to known config keys
+
+check_config_placeholders() {
+  local template="$PROJECT_DIR/templates/afc.config.template.md"
+  if [ ! -f "$template" ]; then
+    warn "Config template not found: $template"
+    return
+  fi
+
+  # Extract valid config keys from template
+  # YAML keys: ci, gate, test
+  local yaml_keys
+  yaml_keys=$(grep -oE '^\s*[a-z_]+:' "$template" 2>/dev/null | sed 's/[[:space:]]*//;s/://' | sort -u || true)
+  # Section headers → lowercase with underscores: Architecture → architecture, Code Style → code_style, Project Context → project_context
+  local section_keys
+  section_keys=$(grep -oE '^## [A-Za-z ]+' "$template" 2>/dev/null \
+    | sed 's/^## //' \
+    | tr '[:upper:]' '[:lower:]' \
+    | sed 's/ /_/g' \
+    | sort -u || true)
+
+  local valid_keys
+  valid_keys=$(printf '%s\n%s\n' "$yaml_keys" "$section_keys" | sort -u)
+
+  # Extract all {config.*} references from commands and docs
+  local refs
+  refs=$(grep -rohE '\{config\.[a-z_]+\}' "$PROJECT_DIR/commands/" "$PROJECT_DIR/docs/" 2>/dev/null \
+    | sed 's/{config\.//;s/}//' \
+    | sort -u || true)
+
+  local count=0
+  local invalid=0
+  for ref in $refs; do
+    count=$((count + 1))
+    if ! printf '%s\n' "$valid_keys" | grep -qxF "$ref"; then
+      fail "{config.$ref} referenced but not defined in config template"
+      invalid=$((invalid + 1))
+    fi
+  done
+
+  if [ "$invalid" -eq 0 ]; then
+    ok "Config placeholders: $count references, all valid"
+  fi
+}
+
+# --- Check 2: Agent Name Consistency ---
+# Verify subagent_type references in commands match agent definitions
+
+check_agent_names() {
+  local agents_dir="$PROJECT_DIR/agents"
+  if [ ! -d "$agents_dir" ]; then
+    warn "Agents directory not found"
+    return
+  fi
+
+  # Extract agent names from agent files (name: field in frontmatter)
+  local defined_agents
+  defined_agents=$(grep -h '^name:' "$agents_dir"/*.md 2>/dev/null \
+    | sed 's/^name:[[:space:]]*//' \
+    | tr -d '"' \
+    | sort -u || true)
+
+  # Extract subagent_type references from commands (afc:agent-name pattern)
+  local referenced_agents
+  referenced_agents=$(grep -rohE 'subagent_type:[[:space:]]*"afc:[^"]*"' "$PROJECT_DIR/commands/" 2>/dev/null \
+    | sed 's/.*"afc://;s/"//' \
+    | sort -u || true)
+
+  local count=0
+  local invalid=0
+  for ref in $referenced_agents; do
+    count=$((count + 1))
+    if ! printf '%s\n' "$defined_agents" | grep -qxF "$ref"; then
+      fail "subagent_type 'afc:$ref' referenced but no agents/$ref.md found"
+      invalid=$((invalid + 1))
+    fi
+  done
+
+  # Check for unprefixed subagent_type that should have afc: prefix
+  local unprefixed
+  unprefixed=$(grep -rohE 'subagent_type:[[:space:]]*"afc-[^"]*"' "$PROJECT_DIR/commands/" 2>/dev/null \
+    | sed 's/.*subagent_type:[[:space:]]*"//;s/".*//' \
+    | sort -u || true)
+  for ref in $unprefixed; do
+    if printf '%s\n' "$defined_agents" | grep -qxF "$ref"; then
+      fail "subagent_type '$ref' should use 'afc:$ref' prefix (found in agents/)"
+      invalid=$((invalid + 1))
+    fi
+  done
+
+  if [ "$invalid" -eq 0 ]; then
+    ok "Agent names: $count references, all consistent"
+  fi
+}
+
+# --- Check 3: Hook Script Existence ---
+# Verify all scripts referenced in hooks.json actually exist
+
+check_hook_scripts() {
+  local hooks_file="$PROJECT_DIR/hooks/hooks.json"
+  if [ ! -f "$hooks_file" ]; then
+    warn "hooks.json not found"
+    return
+  fi
+
+  local scripts
+  scripts=$(grep -oE 'scripts/[^"]+\.sh' "$hooks_file" 2>/dev/null | sort -u || true)
+
+  local count=0
+  local missing=0
+  for script in $scripts; do
+    count=$((count + 1))
+    if [ ! -f "$PROJECT_DIR/$script" ]; then
+      fail "hooks.json references '$script' but file not found"
+      missing=$((missing + 1))
+    fi
+  done
+
+  if [ "$missing" -eq 0 ]; then
+    ok "Hook scripts: $count references, all exist"
+  fi
+}
+
+# --- Check 4: Test Coverage ---
+# Verify each afc-*.sh script (except afc-state.sh library) has a spec file
+
+check_test_coverage() {
+  local count=0
+  local missing=0
+  for script in "$PROJECT_DIR"/scripts/afc-*.sh; do
+    local scriptname
+    scriptname=$(basename "$script" .sh)
+    # Skip shared library and self (validation script)
+    if [ "$scriptname" = "afc-state" ] || [ "$scriptname" = "afc-consistency-check" ]; then
+      continue
+    fi
+    count=$((count + 1))
+    if [ ! -f "$PROJECT_DIR/spec/${scriptname}_spec.sh" ]; then
+      fail "scripts/$scriptname.sh has no spec/${scriptname}_spec.sh"
+      missing=$((missing + 1))
+    fi
+  done
+
+  if [ "$missing" -eq 0 ]; then
+    ok "Test coverage: $count scripts, all have specs"
+  fi
+}
+
+# --- Check 5: Version Sync ---
+# Verify version numbers match across package.json, plugin.json, marketplace.json
+
+check_version_sync() {
+  local pkg="$PROJECT_DIR/package.json"
+  local plugin="$PROJECT_DIR/.claude-plugin/plugin.json"
+  local market="$PROJECT_DIR/.claude-plugin/marketplace.json"
+
+  if [ ! -f "$pkg" ] || [ ! -f "$plugin" ] || [ ! -f "$market" ]; then
+    warn "One or more version files missing"
+    return
+  fi
+
+  local pkg_ver plugin_ver market_meta market_plugin
+  if command -v jq >/dev/null 2>&1; then
+    pkg_ver=$(jq -r '.version' "$pkg")
+    plugin_ver=$(jq -r '.version' "$plugin")
+    market_meta=$(jq -r '.metadata.version' "$market")
+    market_plugin=$(jq -r '.plugins[0].version' "$market")
+  else
+    pkg_ver=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$pkg" | head -1 | sed 's/.*"version"[[:space:]]*:[[:space:]]*"//;s/"//')
+    plugin_ver=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$plugin" | head -1 | sed 's/.*"version"[[:space:]]*:[[:space:]]*"//;s/"//')
+    market_meta=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$market" | head -1 | sed 's/.*"version"[[:space:]]*:[[:space:]]*"//;s/"//')
+    market_plugin=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$market" | sed -n '2p' | sed 's/.*"version"[[:space:]]*:[[:space:]]*"//;s/"//')
+  fi
+
+  if [ "$pkg_ver" = "$plugin_ver" ] && [ "$plugin_ver" = "$market_meta" ] && [ "$market_meta" = "$market_plugin" ]; then
+    ok "Version sync: $pkg_ver (all 4 match)"
+  else
+    fail "Version mismatch: package.json=$pkg_ver plugin.json=$plugin_ver marketplace.meta=$market_meta marketplace.plugin=$market_plugin"
+  fi
+}
+
+# --- Check 6: SSOT Phase Constants ---
+# Verify SSOT phase list in afc-state.sh is not duplicated in other scripts
+
+check_phase_ssot() {
+  # shellcheck source=afc-state.sh
+  . "$SCRIPT_DIR/afc-state.sh"
+
+  local dupes=0
+  # Look for hardcoded phase lists (pipe-separated patterns with 3+ known phases)
+  for script in "$PROJECT_DIR"/scripts/afc-*.sh; do
+    local scriptname
+    scriptname=$(basename "$script")
+    # Skip the SSOT source itself and this validation script
+    if [ "$scriptname" = "afc-state.sh" ] || [ "$scriptname" = "afc-consistency-check.sh" ]; then
+      continue
+    fi
+    # Check for hardcoded phase case patterns (spec|plan|...|clean style)
+    if grep -qE 'spec\|plan\|.*\|clean' "$script" 2>/dev/null; then
+      fail "$scriptname contains hardcoded phase list — use SSOT helpers from afc-state.sh"
+      dupes=$((dupes + 1))
+    fi
+  done
+
+  if [ "$dupes" -eq 0 ]; then
+    ok "Phase SSOT: no hardcoded phase lists found in scripts"
+  fi
+}
+
+# --- Run All Checks ---
+
+printf "[afc:consistency] Running cross-reference validation...\n"
+
+check_config_placeholders
+check_agent_names
+check_hook_scripts
+check_test_coverage
+check_version_sync
+check_phase_ssot
+
+printf "\n[afc:consistency] Done: %d errors, %d warnings\n" "$ERRORS" "$WARNINGS"
+
+if [ "$ERRORS" -gt 0 ]; then
+  exit 1
+fi
+exit 0

package/scripts/afc-dag-validate.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+// DAG Validator: Check task dependency graph for circular references
+// Parses tasks.md and validates that depends: declarations form a valid DAG.
+//
+// Usage: afc-dag-validate.mjs <tasks_file_path>
+// Exit 0: valid DAG (no cycles)
+// Exit 1: cycle detected — prints cycle path
+
+import { readFileSync } from 'fs';
+
+const tasksFile = process.argv[2];
+if (!tasksFile) {
+  process.stderr.write(`Usage: ${process.argv[1]} <tasks_file_path>\n`);
+  process.exit(1);
+}
+
+let content;
+try {
+  content = readFileSync(tasksFile, 'utf8');
+} catch {
+  process.stderr.write(`Error: file not found: ${tasksFile}\n`);
+  process.exit(1);
+}
+
+// Parse tasks and dependencies
+const taskPattern = /^\s*-\s*\[[ xX]\]\s+(T\d+)/;
+const depsPattern = /depends:\s*\[([^\]]*)\]/;
+
+const nodes = new Set();
+const edges = new Map(); // from -> [to, ...]
+
+for (const line of content.split(/\r?\n/)) {
+  const taskMatch = line.match(taskPattern);
+  if (!taskMatch) continue;
+
+  const taskId = taskMatch[1];
+  nodes.add(taskId);
+  if (!edges.has(taskId)) edges.set(taskId, []);
+
+  const depsMatch = line.match(depsPattern);
+  if (depsMatch) {
+    const deps = depsMatch[1].match(/T\d+/g) || [];
+    for (const dep of deps) {
+      // Edge: dep → taskId (taskId depends on dep)
+      if (!edges.has(dep)) edges.set(dep, []);
+      edges.get(dep).push(taskId);
+    }
+  }
+}
+
+if (nodes.size === 0) {
+  process.stdout.write('Valid: no tasks found, nothing to validate\n');
+  process.exit(0);
+}
+
+// DFS cycle detection with full cycle path
+const WHITE = 0, GRAY = 1, BLACK = 2;
+const color = new Map();
+const parent = new Map();
+
+for (const node of nodes) color.set(node, WHITE);
+
+function dfs(node) {
+  color.set(node, GRAY);
+  for (const neighbor of (edges.get(node) || [])) {
+    if (!color.has(neighbor)) continue;
+    if (color.get(neighbor) === GRAY) {
+      // Cycle found — reconstruct path
+      const cycle = [neighbor, node];
+      let cur = node;
+      while (cur !== neighbor && parent.has(cur)) {
+        cur = parent.get(cur);
+        cycle.push(cur);
+      }
+      cycle.reverse();
+      process.stdout.write(`CYCLE: ${cycle.join(' → ')}\n`);
+      process.exit(1);
+    }
+    if (color.get(neighbor) === WHITE) {
+      parent.set(neighbor, node);
+      dfs(neighbor);
+    }
+  }
+  color.set(node, BLACK);
+}
+
+for (const node of nodes) {
+  if (color.get(node) === WHITE) {
+    dfs(node);
+  }
+}
+
+process.stdout.write(`Valid: ${nodes.size} tasks, no circular dependencies\n`);

package/scripts/afc-dag-validate.sh

@@ -0,0 +1,142 @@
+#!/bin/bash
+set -euo pipefail
+
+# DAG Validator: Check task dependency graph for circular references
+# Calls Node.js ESM version if available, falls back to bash implementation.
+#
+# Usage: afc-dag-validate.sh <tasks_file_path>
+# Exit 0: valid DAG (no cycles)
+# Exit 1: cycle detected — prints cycle path
+
+# shellcheck disable=SC2329
+cleanup() {
+  :
+}
+trap cleanup EXIT
+
+TASKS_FILE="${1:-}"
+if [ -z "$TASKS_FILE" ]; then
+  printf 'Usage: %s <tasks_file_path>\n' "$0" >&2
+  exit 1
+fi
+
+if [ ! -f "$TASKS_FILE" ]; then
+  printf 'Error: file not found: %s\n' "$TASKS_FILE" >&2
+  exit 1
+fi
+
+# --- Node.js fast path ---
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+if command -v node >/dev/null 2>&1; then
+  node "$SCRIPT_DIR/afc-dag-validate.mjs" "$TASKS_FILE"
+  exit $?
+fi
+
+# --- Bash fallback ---
+
+# Parse tasks and dependencies
+TMPDIR_WORK="$(mktemp -d)"
+# shellcheck disable=SC2064
+trap "rm -rf '$TMPDIR_WORK'; :" EXIT
+
+NODES_FILE="$TMPDIR_WORK/nodes.txt"
+EDGES_FILE="$TMPDIR_WORK/edges.txt"
+: > "$NODES_FILE"
+: > "$EDGES_FILE"
+
+while IFS= read -r line || [ -n "$line" ]; do
+  if ! printf '%s\n' "$line" | grep -qE '^\s*-\s*\[[ xX]\]\s+T[0-9]+'; then
+    continue
+  fi
+
+  task_id="$(printf '%s\n' "$line" | grep -oE 'T[0-9]+' | head -1)"
+  [ -z "$task_id" ] && continue
+
+  printf '%s\n' "$task_id" >> "$NODES_FILE"
+
+  deps_raw="$(printf '%s\n' "$line" | grep -oE 'depends:\s*\[([^]]*)\]' | sed 's/depends:[[:space:]]*\[//;s/\]//' || true)"
+  if [ -n "$deps_raw" ]; then
+    printf '%s\n' "$deps_raw" | tr ',' '\n' | while IFS= read -r dep; do
+      dep_id="$(printf '%s\n' "$dep" | grep -oE 'T[0-9]+' || true)"
+      if [ -n "$dep_id" ]; then
+        printf '%s\t%s\n' "$dep_id" "$task_id" >> "$EDGES_FILE"
+      fi
+    done
+  fi
+done < "$TASKS_FILE"
+
+TOTAL_TASKS=$(wc -l < "$NODES_FILE" | tr -d ' ')
+
+if [ "$TOTAL_TASKS" -eq 0 ]; then
+  printf 'Valid: no tasks found, nothing to validate\n'
+  exit 0
+fi
+
+# DFS cycle detection using color marking
+COLOR_DIR="$TMPDIR_WORK/colors"
+mkdir -p "$COLOR_DIR"
+
+while IFS= read -r node; do
+  printf '0' > "$COLOR_DIR/$node"
+done < "$NODES_FILE"
+
+CYCLE_FOUND=0
+CYCLE_PATH=""
+
+dfs_check() {
+  local start="$1"
+  local stack_file="$TMPDIR_WORK/stack.txt"
+  printf '%s\n' "$start" > "$stack_file"
+
+  while [ -s "$stack_file" ]; do
+    current="$(tail -1 "$stack_file")"
+
+    color_file="$COLOR_DIR/$current"
+    [ ! -f "$color_file" ] && { sed -i '' '$d' "$stack_file" 2>/dev/null || sed -i '$d' "$stack_file"; continue; }
+
+    color="$(cat "$color_file")"
+
+    if [ "$color" = "0" ]; then
+      printf '1' > "$color_file"
+
+      neighbors="$(grep -E "^${current}\t" "$EDGES_FILE" | cut -f2 || true)"
+      if [ -n "$neighbors" ]; then
+        while IFS= read -r neighbor; do
+          [ -z "$neighbor" ] && continue
+          nb_color_file="$COLOR_DIR/$neighbor"
+          [ ! -f "$nb_color_file" ] && continue
+
+          nb_color="$(cat "$nb_color_file")"
+          if [ "$nb_color" = "1" ]; then
+            CYCLE_FOUND=1
+            CYCLE_PATH="CYCLE: $neighbor → $current → $neighbor"
+            return
+          elif [ "$nb_color" = "0" ]; then
+            printf '%s\n' "$neighbor" >> "$stack_file"
+          fi
+        done <<EOF_NEIGHBORS
+$neighbors
+EOF_NEIGHBORS
+      fi
+    elif [ "$color" = "1" ]; then
+      printf '2' > "$color_file"
+      sed -i '' '$d' "$stack_file" 2>/dev/null || sed -i '$d' "$stack_file"
+    else
+      sed -i '' '$d' "$stack_file" 2>/dev/null || sed -i '$d' "$stack_file"
+    fi
+  done
+}
+
+while IFS= read -r node; do
+  color="$(cat "$COLOR_DIR/$node" 2>/dev/null || printf '0')"
+  if [ "$color" = "0" ]; then
+    dfs_check "$node"
+    if [ "$CYCLE_FOUND" -eq 1 ]; then
+      printf '%s\n' "$CYCLE_PATH"
+      exit 1
+    fi
+  fi
+done < "$NODES_FILE"
+
+printf 'Valid: %d tasks, no circular dependencies\n' "$TOTAL_TASKS"
+exit 0

package/scripts/afc-failure-hint.sh

@@ -2,6 +2,9 @@
 set -euo pipefail
 # PostToolUseFailure Hook: Output hints matching error patterns on tool failure
 
+# shellcheck source=afc-state.sh
+. "$(dirname "$0")/afc-state.sh"
+
 # shellcheck disable=SC2329
 cleanup() {
   # Placeholder for temporary resource cleanup if needed
@@ -10,7 +13,6 @@ cleanup() {
 trap cleanup EXIT
 
 PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
-PIPELINE_FLAG="$PROJECT_DIR/.claude/.afc-active"
 FAILURES_LOG="$PROJECT_DIR/.claude/.afc-failures.log"
 
 # Parse input from stdin
@@ -29,7 +31,7 @@ TOOL_NAME="${TOOL_NAME:-unknown}"
 ERROR="${ERROR:-}"
 
 # If pipeline is active, log failure (normalize error message to single line)
-if [ -f "$PIPELINE_FLAG" ] && [ -n "$ERROR" ]; then
+if afc_state_is_active && [ -n "$ERROR" ]; then
   ERROR_ONELINE=$(printf '%s\n' "$ERROR" | head -1 | cut -c1-200)
   printf '%s\n' "$(date +%s) $TOOL_NAME: $ERROR_ONELINE" >> "$FAILURES_LOG"
 fi
@@ -64,14 +66,14 @@ esac
 if [ -n "$HINT" ]; then
   # Generate safe JSON with jq if available, otherwise strip special chars and use printf
   if command -v jq &> /dev/null; then
-    jq -n --arg ctx "[AFC HINT] $HINT (tool: $TOOL_NAME)" \
+    jq -n --arg ctx "[afc:hint] $HINT (tool: $TOOL_NAME)" \
       '{"hookSpecificOutput":{"hookEventName":"PostToolUseFailure","additionalContext":$ctx}}' 2>/dev/null || true
   else
     # shellcheck disable=SC1003
     SAFE_HINT=$(printf '%s' "$HINT" | tr -d '"' | tr -d '\\')
     # shellcheck disable=SC1003
     SAFE_TOOL=$(printf '%s' "$TOOL_NAME" | tr -d '"' | tr -d '\\')
-    printf '{"hookSpecificOutput":{"hookEventName":"PostToolUseFailure","additionalContext":"[AFC HINT] %s (tool: %s)"}}\n' "$SAFE_HINT" "$SAFE_TOOL"
+    printf '{"hookSpecificOutput":{"hookEventName":"PostToolUseFailure","additionalContext":"[afc:hint] %s (tool: %s)"}}\n' "$SAFE_HINT" "$SAFE_TOOL"
   fi
 fi
 

package/scripts/afc-parallel-validate.mjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+// Parallel Task Validator: Check for file path conflicts among [P] tasks
+// within the same phase.
+//
+// Usage: afc-parallel-validate.mjs <tasks_file_path>
+// Exit 0: valid (no overlaps, or no [P] tasks)
+// Exit 1: overlaps detected — prints conflict details
+
+import { readFileSync } from 'fs';
+
+const tasksFile = process.argv[2];
+if (!tasksFile) {
+  process.stderr.write(`Usage: ${process.argv[1]} <tasks_file_path>\n`);
+  process.exit(1);
+}
+
+let content;
+try {
+  content = readFileSync(tasksFile, 'utf8');
+} catch {
+  process.stderr.write(`Error: file not found: ${tasksFile}\n`);
+  process.exit(1);
+}
+
+const phasePattern = /^## Phase (\d+)/;
+const taskPPattern = /^\s*-\s*\[[ xX]\]\s+(T\d+)\s+\[P\]/;
+const backtickPattern = /`([^`]+)`/g;
+
+let currentPhase = '';
+let totalPTasks = 0;
+const conflicts = [];
+const phasesWithP = new Set();
+
+// Single-pass parsing
+let phaseFileMap = new Map(); // file_path -> task_id
+
+for (const line of content.split(/\r?\n/)) {
+  const phaseMatch = line.match(phasePattern);
+  if (phaseMatch) {
+    currentPhase = phaseMatch[1];
+    phaseFileMap = new Map();
+    continue;
+  }
+
+  if (!currentPhase) continue;
+
+  const taskMatch = line.match(taskPPattern);
+  if (!taskMatch) continue;
+
+  const taskId = taskMatch[1];
+  totalPTasks++;
+  phasesWithP.add(currentPhase);
+
+  // Extract backtick-wrapped file paths (containing / or .)
+  let match;
+  backtickPattern.lastIndex = 0;
+  while ((match = backtickPattern.exec(line)) !== null) {
+    const path = match[1];
+    if (!/[/.]/.test(path)) continue;
+
+    const existing = phaseFileMap.get(path);
+    if (existing) {
+      conflicts.push(`CONFLICT: Phase ${currentPhase} — ${existing} and ${taskId} both target ${path}`);
+    } else {
+      phaseFileMap.set(path, taskId);
+    }
+  }
+}
+
+if (totalPTasks === 0) {
+  process.stdout.write('Valid: no [P] tasks found, nothing to validate\n');
+  process.exit(0);
+}
+
+if (conflicts.length > 0) {
+  process.stdout.write(conflicts.join('\n') + '\n');
+  process.exit(1);
+}
+
+process.stdout.write(`Valid: ${totalPTasks} [P] tasks across ${phasesWithP.size} phases, no file overlaps\n`);