claude-flow-novice 2.14.13 → 2.14.15

package/claude-assets/skills/seo-orchestration/orchestrate-seo.sh.backup

@@ -1,755 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# SEO Pipeline Orchestration - 8-Step Content Creation
-# Version: 1.0.0
-#
-# Orchestrates the SEO content pipeline using modular steps, Redis coordination,
-# and validation loops.
-#
-# Usage:
-#   ./orchestrate-seo.sh --task-id <id> \
-#                        --target-keyword <keyword> \
-#                        --content-type <type> \
-#                        --brand <brand> \
-#                        --audience <audience> \
-#                        [--mode <mvp|standard|enterprise>] \
-#                        [--max-iterations <n>] \
-#                        [--iteration <n>]
-##############################################################################
-
-set -euo pipefail
-
-# Determine script directory
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-REDIS_COORD_SKILL="$PROJECT_ROOT/.claude/skills/cfn-redis-coordination"
-
-# Configuration
-TASK_ID=""
-TARGET_KEYWORD=""
-CONTENT_TYPE=""
-BRAND=""
-AUDIENCE=""
-MODE="standard"
-MAX_ITERATIONS=3
-ITERATION=1
-TARGET_LOCATION=""
-WORD_COUNT_TARGET=""
-
-# Mode-specific thresholds
-declare -A VALIDATOR_GATE=(
-  [mvp]=0.70
-  [standard]=0.75
-  [enterprise]=0.80
-)
-
-declare -A CONSENSUS_THRESHOLD=(
-  [mvp]=0.90
-  [standard]=0.95
-  [enterprise]=0.98
-)
-
-# Execution tracking
-START_TIME=$(date +%s)
-CURRENT_STEP=0
-VALIDATION_CONSENSUS=0.0
-FINAL_ARTICLE_PATH=""
-ITERATIONS_COMPLETED=0
-
-##############################################################################
-# Argument Parsing
-##############################################################################
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --target-keyword)
-      TARGET_KEYWORD="$2"
-      shift 2
-      ;;
-    --content-type)
-      CONTENT_TYPE="$2"
-      if [[ ! "$CONTENT_TYPE" =~ ^(blog|landing|product|local)$ ]]; then
-        echo "Invalid content type. Must be: blog, landing, product, or local"
-        exit 1
-      fi
-      shift 2
-      ;;
-    --brand)
-      BRAND="$2"
-      shift 2
-      ;;
-    --audience)
-      AUDIENCE="$2"
-      shift 2
-      ;;
-    --mode)
-      MODE="$2"
-      if [[ ! "$MODE" =~ ^(mvp|standard|enterprise)$ ]]; then
-        echo "Invalid mode. Must be: mvp, standard, or enterprise"
-        exit 1
-      fi
-      shift 2
-      ;;
-    --max-iterations)
-      MAX_ITERATIONS="$2"
-      if [[ ! "$MAX_ITERATIONS" =~ ^[1-9][0-9]*$ ]]; then
-        echo "Max iterations must be a positive integer"
-        exit 1
-      fi
-      shift 2
-      ;;
-    --iteration)
-      ITERATION="$2"
-      shift 2
-      ;;
-    --target-location)
-      TARGET_LOCATION="$2"
-      shift 2
-      ;;
-    --word-count)
-      WORD_COUNT_TARGET="$2"
-      shift 2
-      ;;
-    *)
-      echo "Error: Unknown option: '$1'"
-      echo ""
-      echo "Usage: $0 [OPTIONS]"
-      echo ""
-      echo "Required options:"
-      echo "  --task-id <id>              Unique task identifier"
-      echo "  --target-keyword <keyword>  Primary SEO keyword"
-      echo "  --content-type <type>       Content type: blog, landing, product, local"
-      echo "  --brand <brand>             Brand name"
-      echo "  --audience <audience>       Target audience"
-      echo ""
-      echo "Optional options:"
-      echo "  --mode <mode>               SEO mode: mvp, standard, enterprise (default: standard)"
-      echo "  --max-iterations <n>        Maximum validation iterations (default: 3)"
-      echo "  --iteration <n>             Current iteration (default: 1)"
-      echo "  --target-location <loc>     Target location (for local SEO)"
-      echo "  --word-count <n>            Target word count (default: auto)"
-      exit 1
-      ;;
-  esac
-done
-
-# Validation
-if [ -z "$TASK_ID" ] || [ -z "$TARGET_KEYWORD" ] || [ -z "$CONTENT_TYPE" ] || [ -z "$BRAND" ] || [ -z "$AUDIENCE" ]; then
-  echo "Error: Required parameters missing"
-  echo "Usage: $0 --task-id <id> --target-keyword <keyword> --content-type <type> --brand <brand> --audience <audience>"
-  exit 1
-fi
-
-# Get thresholds for mode
-VALIDATOR_THRESHOLD=${VALIDATOR_GATE[$MODE]}
-CONSENSUS=${CONSENSUS_THRESHOLD[$MODE]}
-
-# Set word count target based on content type if not provided
-if [ -z "$WORD_COUNT_TARGET" ]; then
-  case "$CONTENT_TYPE" in
-    blog)
-      WORD_COUNT_TARGET="1500-2000"
-      ;;
-    landing)
-      WORD_COUNT_TARGET="800-1200"
-      ;;
-    product)
-      WORD_COUNT_TARGET="400-800"
-      ;;
-    local)
-      WORD_COUNT_TARGET="600-1000"
-      ;;
-  esac
-fi
-
-echo "=============================================="
-echo "SEO Pipeline Orchestration v1.0.0"
-echo "=============================================="
-echo "Task ID: $TASK_ID"
-echo "Content Type: $CONTENT_TYPE"
-echo "Target Keyword: $TARGET_KEYWORD"
-echo "Brand: $BRAND"
-echo "Audience: $AUDIENCE"
-echo "Mode: $MODE"
-echo "Word Count Target: $WORD_COUNT_TARGET"
-echo "Validator Threshold: $VALIDATOR_THRESHOLD"
-echo "Consensus Threshold: $CONSENSUS"
-echo "Max Iterations: $MAX_ITERATIONS"
-echo "=============================================="
-echo ""
-
-##############################################################################
-# Helper Functions
-##############################################################################
-
-function log_step() {
-  local step_num="$1"
-  local step_name="$2"
-  local message="$3"
-
-  echo "[$step_name] $message"
-  redis-cli RPUSH "seo:task:${TASK_ID}:logs" "[$(date -Iseconds)] [Step $step_num] $message" >/dev/null
-}
-
-function store_context() {
-  local task_id="$1"
-
-  log_step 0 "Init" "Storing SEO task context in Redis"
-
-  # Store task context using Redis HSET
-  redis-cli HSET "seo:task:${task_id}:context" \
-    target_keyword "$TARGET_KEYWORD" \
-    content_type "$CONTENT_TYPE" \
-    brand "$BRAND" \
-    audience "$AUDIENCE" \
-    mode "$MODE" \
-    word_count_target "$WORD_COUNT_TARGET" \
-    target_location "$TARGET_LOCATION" \
-    max_iterations "$MAX_ITERATIONS" >/dev/null
-
-  # Store status
-  redis-cli HSET "seo:task:${task_id}:status" \
-    current_step "0" \
-    iteration "$ITERATION" \
-    status "initializing" >/dev/null
-
-  log_step 0 "Init" "Context stored in Redis"
-}
-
-function update_status() {
-  local step_num="$1"
-  local status="$2"
-
-  redis-cli HSET "seo:task:${TASK_ID}:status" \
-    current_step "$step_num" \
-    status "$status" \
-    last_updated "$(date -Iseconds)" >/dev/null
-}
-
-function spawn_agent() {
-  local agent_type="$1"
-  local step_num="$2"
-  local context="$3"
-  local timeout="${4:-300}"  # Default 5 minute timeout
-
-  local agent_id="${agent_type}-step${step_num}-iter${ITERATION}"
-
-  log_step "$step_num" "$(get_step_name $step_num)" "Spawning agent: $agent_type (ID: $agent_id)"
-
-  # Spawn agent via CLI
-  npx claude-flow-novice agent "$agent_type" \
-    --task-id "$TASK_ID" \
-    --agent-id "$agent_id" \
-    --iteration "$ITERATION" \
-    --context "$context" &
-
-  local agent_pid=$!
-
-  # Store agent PID
-  redis-cli HSET "seo:task:${TASK_ID}:agents" "$agent_id" "$agent_pid" >/dev/null
-
-  log_step "$step_num" "$(get_step_name $step_num)" "Agent spawned (PID: $agent_pid)"
-
-  # Wait for agent completion
-  if redis-cli blpop "swarm:${TASK_ID}:${agent_id}:done" "$timeout" >/dev/null 2>&1; then
-    log_step "$step_num" "$(get_step_name $step_num)" "Agent completed: $agent_id"
-    return 0
-  else
-    log_step "$step_num" "$(get_step_name $step_num)" "Warning: Agent timeout: $agent_id"
-    return 1
-  fi
-}
-
-function get_step_name() {
-  local step="$1"
-  case "$step" in
-    1) echo "Keyword Research" ;;
-    2) echo "Competitor Analysis" ;;
-    3) echo "Content Outline" ;;
-    4) echo "Research" ;;
-    5) echo "Content Writing" ;;
-    6) echo "SEO Optimization" ;;
-    7) echo "Validation" ;;
-    8) echo "Publishing" ;;
-    *) echo "Unknown" ;;
-  esac
-}
-
-function should_run_step() {
-  local step="$1"
-
-  # All content types run certain core steps
-  case "$CONTENT_TYPE" in
-    blog)
-      # Blog runs all 8 steps
-      return 0
-      ;;
-    landing)
-      # Landing page skips competitor analysis (step 2), minimal research (step 4)
-      if [[ "$step" == "2" || "$step" == "4" ]]; then
-        return 1
-      fi
-      return 0
-      ;;
-    product)
-      # Product page skips competitor analysis (2), outline (3), research (4)
-      if [[ "$step" == "2" || "$step" == "3" || "$step" == "4" ]]; then
-        return 1
-      fi
-      return 0
-      ;;
-    local)
-      # Local content skips competitor analysis (2)
-      if [[ "$step" == "2" ]]; then
-        return 1
-      fi
-      return 0
-      ;;
-  esac
-
-  return 0
-}
-
-function store_step_output() {
-  local step_num="$1"
-  local output="$2"
-
-  redis-cli HSET "seo:task:${TASK_ID}:step:${step_num}:output" \
-    iteration "$ITERATION" \
-    timestamp "$(date -Iseconds)" \
-    output "$output" >/dev/null
-}
-
-##############################################################################
-# Pipeline Steps
-##############################################################################
-
-function step1_keyword_research() {
-  if ! should_run_step "1"; then
-    log_step 1 "Keyword Research" "Skipped for content type: $CONTENT_TYPE"
-    return 0
-  fi
-
-  update_status 1 "running"
-  CURRENT_STEP=1
-
-  local context="Task: Keyword research for '$TARGET_KEYWORD' | Content Type: $CONTENT_TYPE | Brand: $BRAND | Audience: $AUDIENCE | Output: content/seo-data/keyword-research-${TASK_ID}.json"
-
-  if spawn_agent "seo-analytics-specialist" 1 "$context" 600; then
-    # Retrieve output from agent
-    local keyword_data=$(redis-cli HGET "seo:task:${TASK_ID}:agents:seo-analytics-specialist-step1-iter${ITERATION}" "output" 2>/dev/null || echo "")
-    store_step_output 1 "$keyword_data"
-    log_step 1 "Keyword Research" "Completed successfully"
-    return 0
-  else
-    log_step 1 "Keyword Research" "Failed or timed out"
-    return 1
-  fi
-}
-
-function step2_competitor_analysis() {
-  if ! should_run_step "2"; then
-    log_step 2 "Competitor Analysis" "Skipped for content type: $CONTENT_TYPE"
-    return 0
-  fi
-
-  update_status 2 "running"
-  CURRENT_STEP=2
-
-  local context="Task: Analyze top 3 competitors for keyword '$TARGET_KEYWORD' | Keyword Data: content/seo-data/keyword-research-${TASK_ID}.json | Output: content/seo-data/competitor-analysis-${TASK_ID}.md"
-
-  if spawn_agent "competitive-seo-analyst" 2 "$context" 600; then
-    local competitor_data=$(redis-cli HGET "seo:task:${TASK_ID}:agents:competitive-seo-analyst-step2-iter${ITERATION}" "output" 2>/dev/null || echo "")
-    store_step_output 2 "$competitor_data"
-    log_step 2 "Competitor Analysis" "Completed successfully"
-    return 0
-  else
-    log_step 2 "Competitor Analysis" "Failed or timed out"
-    return 1
-  fi
-}
-
-function step3_content_outline() {
-  if ! should_run_step "3"; then
-    log_step 3 "Content Outline" "Skipped for content type: $CONTENT_TYPE"
-    return 0
-  fi
-
-  update_status 3 "running"
-  CURRENT_STEP=3
-
-  local context="Task: Create SEO-optimized outline for '$TARGET_KEYWORD' | Keyword Data: content/seo-data/keyword-research-${TASK_ID}.json | Competitor Data: content/seo-data/competitor-analysis-${TASK_ID}.md | Brand: $BRAND | Word Count: $WORD_COUNT_TARGET | Output: content/outlines/outline-${TASK_ID}.md"
-
-  if spawn_agent "content-seo-strategist" 3 "$context" 600; then
-    local outline_data=$(redis-cli HGET "seo:task:${TASK_ID}:agents:content-seo-strategist-step3-iter${ITERATION}" "output" 2>/dev/null || echo "")
-    store_step_output 3 "$outline_data"
-    log_step 3 "Content Outline" "Completed successfully"
-    return 0
-  else
-    log_step 3 "Content Outline" "Failed or timed out"
-    return 1
-  fi
-}
-
-function step4_research() {
-  if ! should_run_step "4"; then
-    log_step 4 "Research" "Skipped for content type: $CONTENT_TYPE"
-    return 0
-  fi
-
-  update_status 4 "running"
-  CURRENT_STEP=4
-
-  log_step 4 "Research" "Performing research via Perplexity API"
-
-  # Check OpenRouter API key
-  if [ -z "${OPENROUTER_API_KEY:-}" ]; then
-    log_step 4 "Research" "Warning: OPENROUTER_API_KEY not set, skipping research"
-    return 0
-  fi
-
-  # Extract research questions from outline
-  local outline_path="content/outlines/outline-${TASK_ID}.md"
-  local research_query="Research comprehensive information about: $TARGET_KEYWORD. Focus on: latest statistics, expert quotes, credible sources, and supporting data."
-
-  # Call Perplexity API via OpenRouter
-  local research_response=$(curl -s https://openrouter.ai/api/v1/chat/completions \
-    -H "Authorization: Bearer ${OPENROUTER_API_KEY}" \
-    -H "Content-Type: application/json" \
-    -d "{
-      \"model\": \"perplexity/pplx-70b-online\",
-      \"messages\": [{\"role\": \"user\", \"content\": \"$research_query\"}]
-    }" 2>/dev/null || echo '{"error": "API call failed"}')
-
-  # Store research output
-  store_step_output 4 "$research_response"
-
-  # Save research to file
-  echo "$research_response" > "content/research/research-${TASK_ID}.json"
-
-  log_step 4 "Research" "Completed successfully"
-  return 0
-}
-
-function step5_content_writing() {
-  if ! should_run_step "5"; then
-    log_step 5 "Content Writing" "Skipped for content type: $CONTENT_TYPE"
-    return 0
-  fi
-
-  update_status 5 "running"
-  CURRENT_STEP=5
-
-  # Build context with feedback if this is an iteration
-  local feedback=""
-  if [ "$ITERATION" -gt 1 ]; then
-    feedback=$(redis-cli HGET "seo:task:${TASK_ID}:validation:feedback" "iteration$((ITERATION - 1))" 2>/dev/null || echo "")
-  fi
-
-  local context="Task: Write $CONTENT_TYPE content for '$TARGET_KEYWORD' | Outline: content/outlines/outline-${TASK_ID}.md | Research: content/research/research-${TASK_ID}.json | Brand: $BRAND | Audience: $AUDIENCE | Word Count: $WORD_COUNT_TARGET | Tone: Conversational, human, natural | Output: content/drafts/draft-${TASK_ID}.md"
-
-  if [ -n "$feedback" ]; then
-    context="$context | Feedback from iteration $((ITERATION - 1)): $feedback"
-  fi
-
-  if spawn_agent "content-seo-strategist" 5 "$context" 900; then
-    local draft_data=$(redis-cli HGET "seo:task:${TASK_ID}:agents:content-seo-strategist-step5-iter${ITERATION}" "output" 2>/dev/null || echo "")
-    store_step_output 5 "$draft_data"
-    log_step 5 "Content Writing" "Completed successfully"
-    return 0
-  else
-    log_step 5 "Content Writing" "Failed or timed out"
-    return 1
-  fi
-}
-
-function step6_seo_optimization() {
-  if ! should_run_step "6"; then
-    log_step 6 "SEO Optimization" "Skipped for content type: $CONTENT_TYPE"
-    return 0
-  fi
-
-  update_status 6 "running"
-  CURRENT_STEP=6
-
-  local context="Task: SEO optimize content | Draft: content/drafts/draft-${TASK_ID}.md | Primary Keyword: $TARGET_KEYWORD | Content Type: $CONTENT_TYPE | Target URL: /blog/$TARGET_KEYWORD | Tasks: Meta title (50-60 chars), Meta description (150-160 chars), Header optimization, Internal linking (3-5 links), Image alt text, Schema preparation | Output: content/optimized/optimized-${TASK_ID}.md"
-
-  # Use technical-seo-specialist as primary agent
-  if spawn_agent "technical-seo-specialist" 6 "$context" 600; then
-    local optimized_data=$(redis-cli HGET "seo:task:${TASK_ID}:agents:technical-seo-specialist-step6-iter${ITERATION}" "output" 2>/dev/null || echo "")
-    store_step_output 6 "$optimized_data"
-    log_step 6 "SEO Optimization" "Completed successfully"
-    return 0
-  else
-    log_step 6 "SEO Optimization" "Failed or timed out"
-    return 1
-  fi
-}
-
-function step7_validation() {
-  if ! should_run_step "7"; then
-    log_step 7 "Validation" "Skipped for content type: $CONTENT_TYPE"
-    return 0
-  fi
-
-  update_status 7 "running"
-  CURRENT_STEP=7
-
-  log_step 7 "Validation" "Spawning 3 validators in parallel"
-
-  local article_path="content/optimized/optimized-${TASK_ID}.md"
-
-  # Spawn validators in parallel
-  local validator_context_humanizer="Task: Validate article for natural, human-like writing | Article: $article_path | Iteration: $ITERATION | Check for: AI language patterns, conversational tone, personal examples, varied sentence structure | Output: Confidence score (0.0-1.0), Issues found, Recommended rewrites"
-
-  local validator_context_branding="Task: Validate article alignment with $BRAND brand | Article: $article_path | Brand: $BRAND | Iteration: $ITERATION | Check for: Brand voice consistency, value proposition, tone alignment, messaging | Output: Confidence score (0.0-1.0), Brand issues, Recommended adjustments"
-
-  local validator_context_audience="Task: Validate article fit for target audience | Article: $article_path | Audience: $AUDIENCE | Iteration: $ITERATION | Check for: Audience resonance, complexity level, relatable examples, clear value | Output: Confidence score (0.0-1.0), Audience fit issues, Suggested improvements"
-
-  # Spawn all validators in background
-  (spawn_agent "humanizer-validator" 7 "$validator_context_humanizer" 300) &
-  local pid_humanizer=$!
-
-  (spawn_agent "branding-validator" 7 "$validator_context_branding" 300) &
-  local pid_branding=$!
-
-  (spawn_agent "audience-validator" 7 "$validator_context_audience" 300) &
-  local pid_audience=$!
-
-  # Wait for all validators
-  wait "$pid_humanizer" "$pid_branding" "$pid_audience" 2>/dev/null || true
-
-  log_step 7 "Validation" "All validators completed"
-
-  # Collect confidence scores
-  local humanizer_score=$(redis-cli HGET "swarm:${TASK_ID}:humanizer-validator-step7-iter${ITERATION}:confidence" "score" 2>/dev/null || echo "0.0")
-  local branding_score=$(redis-cli HGET "swarm:${TASK_ID}:branding-validator-step7-iter${ITERATION}:confidence" "score" 2>/dev/null || echo "0.0")
-  local audience_score=$(redis-cli HGET "swarm:${TASK_ID}:audience-validator-step7-iter${ITERATION}:confidence" "score" 2>/dev/null || echo "0.0")
-
-  # Store validator scores
-  redis-cli HSET "seo:task:${TASK_ID}:validation:scores" \
-    "iteration${ITERATION}_humanizer" "$humanizer_score" \
-    "iteration${ITERATION}_branding" "$branding_score" \
-    "iteration${ITERATION}_audience" "$audience_score" >/dev/null
-
-  # Calculate consensus (average)
-  VALIDATION_CONSENSUS=$(echo "scale=2; ($humanizer_score + $branding_score + $audience_score) / 3" | bc)
-
-  log_step 7 "Validation" "Humanizer: $humanizer_score | Branding: $branding_score | Audience: $audience_score | Consensus: $VALIDATION_CONSENSUS"
-
-  # Check individual gate thresholds
-  local gate_pass=true
-  if (( $(echo "$humanizer_score < $VALIDATOR_THRESHOLD" | bc -l) )); then
-    log_step 7 "Validation" "Humanizer validator failed gate ($humanizer_score < $VALIDATOR_THRESHOLD)"
-    gate_pass=false
-  fi
-  if (( $(echo "$branding_score < $VALIDATOR_THRESHOLD" | bc -l) )); then
-    log_step 7 "Validation" "Branding validator failed gate ($branding_score < $VALIDATOR_THRESHOLD)"
-    gate_pass=false
-  fi
-  if (( $(echo "$audience_score < $VALIDATOR_THRESHOLD" | bc -l) )); then
-    log_step 7 "Validation" "Audience validator failed gate ($audience_score < $VALIDATOR_THRESHOLD)"
-    gate_pass=false
-  fi
-
-  # Check consensus threshold
-  if [[ "$gate_pass" == "true" ]] && (( $(echo "$VALIDATION_CONSENSUS >= $CONSENSUS" | bc -l) )); then
-    log_step 7 "Validation" "Consensus passed ($VALIDATION_CONSENSUS >= $CONSENSUS)"
-    return 0
-  else
-    log_step 7 "Validation" "Consensus failed ($VALIDATION_CONSENSUS < $CONSENSUS) or gate failed"
-
-    # Collect feedback from validators
-    local feedback=$(redis-cli HGET "seo:task:${TASK_ID}:validation:feedback" "iteration${ITERATION}" 2>/dev/null || echo "See validator outputs for specific feedback")
-
-    # Store feedback for next iteration
-    redis-cli HSET "seo:task:${TASK_ID}:validation:feedback" \
-      "iteration${ITERATION}" "$feedback" >/dev/null
-
-    return 1
-  fi
-}
-
-function step8_publishing() {
-  if ! should_run_step "8"; then
-    log_step 8 "Publishing" "Skipped for content type: $CONTENT_TYPE"
-    return 0
-  fi
-
-  update_status 8 "running"
-  CURRENT_STEP=8
-
-  local context="Task: Add schema markup and prepare for publishing | Article: content/optimized/optimized-${TASK_ID}.md | URL: https://${BRAND}.com/blog/${TARGET_KEYWORD} | Author: ${BRAND} Team | Published: $(date +%Y-%m-%d) | Tasks: Add Article schema (JSON-LD), Add BreadcrumbList schema, Add Organization schema, Validate with Google Rich Results Test, Final formatting | Output: content/published/published-${TASK_ID}.md"
-
-  if spawn_agent "schema-markup-engineer" 8 "$context" 600; then
-    local published_data=$(redis-cli HGET "seo:task:${TASK_ID}:agents:schema-markup-engineer-step8-iter${ITERATION}" "output" 2>/dev/null || echo "")
-    store_step_output 8 "$published_data"
-
-    # Set final article path
-    FINAL_ARTICLE_PATH="content/published/published-${TASK_ID}.md"
-
-    log_step 8 "Publishing" "Completed successfully - Article ready at $FINAL_ARTICLE_PATH"
-    return 0
-  else
-    log_step 8 "Publishing" "Failed or timed out"
-    return 1
-  fi
-}
-
-##############################################################################
-# Main Pipeline Execution
-##############################################################################
-
-function run_pipeline() {
-  log_step 0 "Pipeline" "Starting SEO pipeline for iteration $ITERATION"
-
-  # Step 1: Keyword Research
-  if ! step1_keyword_research; then
-    log_step 0 "Pipeline" "Step 1 failed, retrying once"
-    sleep 2
-    if ! step1_keyword_research; then
-      log_step 0 "Pipeline" "Step 1 failed after retry, aborting"
-      return 1
-    fi
-  fi
-
-  # Step 2: Competitor Analysis
-  if ! step2_competitor_analysis; then
-    log_step 0 "Pipeline" "Step 2 failed, retrying once"
-    sleep 2
-    if ! step2_competitor_analysis; then
-      log_step 0 "Pipeline" "Step 2 failed after retry, continuing with degraded data"
-      # Non-critical step, continue
-    fi
-  fi
-
-  # Step 3: Content Outline
-  if ! step3_content_outline; then
-    log_step 0 "Pipeline" "Step 3 failed, retrying once"
-    sleep 2
-    if ! step3_content_outline; then
-      log_step 0 "Pipeline" "Step 3 failed after retry, aborting"
-      return 1
-    fi
-  fi
-
-  # Step 4: Research
-  if ! step4_research; then
-    log_step 0 "Pipeline" "Step 4 failed, continuing without external research"
-    # Non-critical step, continue
-  fi
-
-  # Step 5: Content Writing
-  if ! step5_content_writing; then
-    log_step 0 "Pipeline" "Step 5 failed, retrying once"
-    sleep 2
-    if ! step5_content_writing; then
-      log_step 0 "Pipeline" "Step 5 failed after retry, aborting"
-      return 1
-    fi
-  fi
-
-  # Step 6: SEO Optimization
-  if ! step6_seo_optimization; then
-    log_step 0 "Pipeline" "Step 6 failed, retrying once"
-    sleep 2
-    if ! step6_seo_optimization; then
-      log_step 0 "Pipeline" "Step 6 failed after retry, aborting"
-      return 1
-    fi
-  fi
-
-  # Step 7: Validation (with iteration loop)
-  if ! step7_validation; then
-    ITERATIONS_COMPLETED=$ITERATION
-
-    if [ "$ITERATION" -ge "$MAX_ITERATIONS" ]; then
-      log_step 7 "Validation" "Max iterations ($MAX_ITERATIONS) reached, proceeding to publishing"
-      # Proceed to step 8 even if validation consensus not met
-    else
-      log_step 7 "Validation" "Validation failed, starting iteration $((ITERATION + 1))"
-
-      # Recursive call with incremented iteration
-      ITERATION=$((ITERATION + 1))
-      run_pipeline
-      return $?
-    fi
-  fi
-
-  # Step 8: Publishing
-  if ! step8_publishing; then
-    log_step 0 "Pipeline" "Step 8 failed, retrying once"
-    sleep 2
-    if ! step8_publishing; then
-      log_step 0 "Pipeline" "Step 8 failed after retry, aborting"
-      return 1
-    fi
-  fi
-
-  log_step 0 "Pipeline" "SEO pipeline completed successfully"
-  return 0
-}
-
-function output_result() {
-  local status="$1"
-  local end_time=$(date +%s)
-  local execution_time=$((end_time - START_TIME))
-
-  echo ""
-  echo "=============================================="
-  echo "SEO Pipeline Execution Complete"
-  echo "=============================================="
-  echo "Status: $status"
-  echo "Content Type: $CONTENT_TYPE"
-  echo "Target Keyword: $TARGET_KEYWORD"
-  echo "Iterations: $ITERATIONS_COMPLETED"
-  echo "Final Validation Consensus: $VALIDATION_CONSENSUS"
-  echo "Final Article Path: $FINAL_ARTICLE_PATH"
-  echo "Execution Time: ${execution_time}s"
-  echo "=============================================="
-
-  # Output structured JSON result
-  cat <<EOF
-{
-  "status": "$status",
-  "content_type": "$CONTENT_TYPE",
-  "target_keyword": "$TARGET_KEYWORD",
-  "brand": "$BRAND",
-  "iterations_completed": $ITERATIONS_COMPLETED,
-  "validation_consensus": $VALIDATION_CONSENSUS,
-  "final_article_path": "$FINAL_ARTICLE_PATH",
-  "execution_time_seconds": $execution_time,
-  "task_id": "$TASK_ID"
-}
-EOF
-
-  # Store final result in Redis
-  redis-cli HSET "seo:task:${TASK_ID}:result" \
-    status "$status" \
-    iterations "$ITERATIONS_COMPLETED" \
-    consensus "$VALIDATION_CONSENSUS" \
-    article_path "$FINAL_ARTICLE_PATH" \
-    execution_time "$execution_time" >/dev/null
-}
-
-##############################################################################
-# Main Execution
-##############################################################################
-
-# Store context in Redis
-store_context "$TASK_ID"
-
-# Run pipeline
-if run_pipeline; then
-  ITERATIONS_COMPLETED=$ITERATION
-  output_result "success"
-  exit 0
-else
-  ITERATIONS_COMPLETED=$ITERATION
-  output_result "failed"
-  exit 1
-fi