- name: Run security audit
  run: |
    npm audit --audit-level=high
    npm audit --production --audit-level=moderate

- name: Run all tests
  run: npm test

// From package.json line showing duplicate "test" key:
"test": "NODE_OPTIONS='--experimental-vm-modules' jest --bail --maxWorkers=1 --forceExit",
...
"test": "tests"  // ← DUPLICATE KEY! This overwrites the actual test command!

// REMOVE THIS LINE (appears at the end of scripts section):
"test": "tests"

// KEEP ONLY THE ACTUAL TEST COMMAND:
"test": "NODE_OPTIONS='--experimental-vm-modules' jest --bail --maxWorkers=1 --forceExit"

# Option A: Use the specific CI test script that already exists
- name: Run all tests
  run: npm run test:ci

# Option B: Keep npm test but fix package.json first (preferred)
- name: Run all tests
  run: npm test

- name: Verify test setup
  run: |
    echo "Checking test files..."
    ls -la tests/
    echo "Test count: $(find tests -name '*.test.js' | wc -l)"

- name: Run all tests
  run: npm run test:ci

- name: Generate coverage report
  if: matrix.os == 'ubuntu-latest'
  run: npm run test:coverage
  continue-on-error: true  # Add this to prevent blocking

- name: Test rollback target viability
  run: |
    # ...
    npm ci || true
    npm run build:ts || echo "⚠️ Build test failed"

- name: Test rollback target viability
  run: |
    echo "🧪 Testing rollback target viability..."

    ROLLBACK_TARGET="${{ github.event.inputs.rollback_target || needs.failure-detection.outputs.rollback-target }}"

    # Create temporary branch for testing
    git checkout -b test-rollback-temp "$ROLLBACK_TARGET"

    # STRICT: Exit on any failure
    set -e

    echo "Installing dependencies..."
    npm ci

    echo "Testing TypeScript compilation..."
    npm run build:ts

    echo "Running smoke tests..."
    npm run test:health || echo "Health tests not available"

    # Switch back to original branch
    git checkout "${{ github.ref_name }}"
    git branch -D test-rollback-temp

    echo "✅ Rollback target is viable"

- name: Verify dependency integrity
  run: |
    echo "🔍 Verifying package-lock.json integrity..."

    ROLLBACK_TARGET="${{ github.event.inputs.rollback_target || needs.failure-detection.outputs.rollback-target }}"

    git show "$ROLLBACK_TARGET:package-lock.json" > /tmp/target-lock.json

    # Check if lock file exists and is valid JSON
    if jq empty /tmp/target-lock.json 2>/dev/null; then
      echo "✅ package-lock.json is valid"
    else
      echo "❌ package-lock.json is corrupted at rollback target"
      exit 1
    fi

- name: Validate rollback target
  id: validate
  run: |
    echo "🔍 Validating rollback target..."

    ROLLBACK_TARGET="${{ github.event.inputs.rollback_target || needs.failure-detection.outputs.rollback-target }}"
    VALIDATION_PASSED="false"
    VALIDATION_ERRORS=""

    if [ -n "$ROLLBACK_TARGET" ]; then
      # Check if target commit exists
      if git cat-file -e "$ROLLBACK_TARGET^{commit}" 2>/dev/null; then
        echo "✅ Rollback target $ROLLBACK_TARGET is valid"

        # Check if target is reachable from current branch
        if git merge-base --is-ancestor "$ROLLBACK_TARGET" HEAD; then
          echo "✅ Target is ancestor of current HEAD"
          VALIDATION_PASSED="true"
        else
          VALIDATION_ERRORS="Target is not an ancestor of current HEAD"
          echo "❌ $VALIDATION_ERRORS"
        fi
      else
        VALIDATION_ERRORS="Rollback target $ROLLBACK_TARGET does not exist"
        echo "❌ $VALIDATION_ERRORS"
      fi
    else
      VALIDATION_ERRORS="No rollback target specified"
      echo "❌ $VALIDATION_ERRORS"
    fi

    echo "validation-passed=$VALIDATION_PASSED" >> $GITHUB_OUTPUT
    echo "validation-errors=$VALIDATION_ERRORS" >> $GITHUB_OUTPUT

    # Fail the step if validation didn't pass
    if [ "$VALIDATION_PASSED" = "false" ]; then
      exit 1
    fi

- name: Create integration test database
  run: |
    echo "🗄️ Creating integration test database..."

    mkdir -p integration-test-data

    # Initialize SQLite database for integration tests
    sqlite3 ${{ env.INTEGRATION_DB_PATH }} << 'EOF'
    CREATE TABLE IF NOT EXISTS test_sessions (
      # ... SQL commands ...
    );
    EOF

- name: Setup integration test environment
  run: |
    echo "🔧 Setting up integration test environment..."

    # Install SQLite3
    sudo apt-get update
    sudo apt-get install -y sqlite3

    # Verify installation
    sqlite3 --version

    echo "✅ SQLite3 installed successfully"

- name: Create integration test database
  run: |
    echo "🗄️ Creating integration test database..."

    DB_PATH="${{ env.INTEGRATION_DB_PATH }}"

    # Create directory
    mkdir -p "$(dirname "$DB_PATH")"
    mkdir -p integration-test-data

    # Create database with explicit path
    sqlite3 "$DB_PATH" <<'SQL'
    CREATE TABLE IF NOT EXISTS test_sessions (
      id TEXT PRIMARY KEY,
      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
      status TEXT DEFAULT 'pending',
      metadata TEXT
    );

    CREATE TABLE IF NOT EXISTS agent_tests (
      id TEXT PRIMARY KEY,
      session_id TEXT,
      agent_type TEXT,
      agent_count INTEGER,
      status TEXT DEFAULT 'pending',
      started_at DATETIME,
      completed_at DATETIME,
      results TEXT,
      FOREIGN KEY (session_id) REFERENCES test_sessions (id)
    );

    CREATE TABLE IF NOT EXISTS integration_scenarios (
      id TEXT PRIMARY KEY,
      session_id TEXT,
      scenario_name TEXT,
      status TEXT DEFAULT 'pending',
      agents_involved TEXT,
      execution_time_ms INTEGER,
      success_rate REAL,
      error_details TEXT,
      FOREIGN KEY (session_id) REFERENCES test_sessions (id)
    );
SQL

    # Insert test session
    sqlite3 "$DB_PATH" <<SQL
    INSERT INTO test_sessions (id, metadata) VALUES
    ('${{ steps.setup.outputs.test-session-id }}', '{"scope": "${{ github.event.inputs.integration_scope || 'full' }}", "agent_count": "${{ github.event.inputs.agent_count || '8' }}"}');
SQL

    # Verify database creation
    if [ -f "$DB_PATH" ]; then
      echo "✅ Database created successfully"
      sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM test_sessions;"
    else
      echo "❌ Database creation failed"
      exit 1
    fi

    # Copy to artifact directory
    cp "$DB_PATH" integration-test-data/

# Create tests/integration/scripts/ directory with proper test scripts

# tests/integration/scripts/test-coordination.js
# tests/integration/scripts/test-communication.js
# tests/integration/scripts/test-task-distribution.js

- name: Initialize swarm for agent testing
  run: |
    echo "🚀 Initializing swarm for ${{ matrix.type }} agents (count: ${{ matrix.count }})"

    # Use external script instead of inline code
    node tests/integration/scripts/test-coordination.js \
      --agent-type "${{ matrix.type }}" \
      --agent-count "${{ matrix.count }}" \
      --output "coordination-test-${{ matrix.type }}.log"

- name: Pre-flight integration test checks
  run: |
    echo "🔍 Running pre-flight checks..."

    # Check Node.js version
    node --version
    npm --version

    # Check SQLite availability
    if command -v sqlite3 &> /dev/null; then
      echo "✅ SQLite3 available: $(sqlite3 --version)"
    else
      echo "❌ SQLite3 not found"
      exit 1
    fi

    # Check test scripts exist
    if [ -d "tests/integration/scripts" ]; then
      echo "✅ Integration test scripts found"
      ls -la tests/integration/scripts/
    else
      echo "❌ Integration test scripts directory missing"
      exit 1
    fi

    # Check Jest is available
    if npm run test -- --version &> /dev/null; then
      echo "✅ Jest test runner available"
    else
      echo "❌ Jest test runner not available"
    fi

    echo "✅ All pre-flight checks passed"

- name: Initialize swarm for agent testing
  timeout-minutes: 10  # Workflow-level timeout
  run: |
    echo "🚀 Initializing swarm for ${{ matrix.type }} agents (count: ${{ matrix.count }})"

    # Use Node.js script with proper timeout
    node tests/integration/scripts/test-coordination.js \
      --agent-type "${{ matrix.type }}" \
      --agent-count "${{ matrix.count }}" \
      --timeout 300000 \
      --output "coordination-test-${{ matrix.type }}.log" \
      || {
        echo "❌ Coordination test failed or timed out"
        cat "coordination-test-${{ matrix.type }}.log" || true
        exit 1
      }

env:
  WORKSPACE_ROOT: ${{ github.workspace }}
  BIN_PATH: ${{ github.workspace }}/bin
  TEST_DATA_PATH: ${{ github.workspace }}/integration-test-data

- name: Critical operation
  run: |
    set -e  # Exit on any error
    set -o pipefail  # Catch errors in pipes

    # ... commands ...

- name: Validate repository state
  run: |
    echo "🔍 Validating repository state..."

    REQUIRED_FILES=(
      "package.json"
      "package-lock.json"
      "tsconfig.json"
      ".eslintrc.json"
    )

    REQUIRED_DIRS=(
      "src"
      "tests"
      "bin"
    )

    for file in "${REQUIRED_FILES[@]}"; do
      if [ ! -f "$file" ]; then
        echo "❌ Missing required file: $file"
        exit 1
      fi
    done

    for dir in "${REQUIRED_DIRS[@]}"; do
      if [ ! -d "$dir" ]; then
        echo "❌ Missing required directory: $dir"
        exit 1
      fi
    done

    echo "✅ Repository state validated"

- name: Install dependencies with retry
  uses: nick-invision/retry@v2
  with:
    timeout_minutes: 10
    max_attempts: 3
    command: npm ci

# REMOVE THIS JOB and merge into security job:
- name: Check documentation exists
  run: |
    echo "✅ Checking documentation..."
    test -f README.md || (echo "❌ README.md missing" && exit 1)
    test -f CHANGELOG.md || (echo "❌ CHANGELOG.md missing" && exit 1)
    echo "✅ Documentation files present"

# OPTIONAL: Can be removed or converted to a separate scheduled workflow
- name: License compliance check
  run: npx license-checker --onlyAllow 'MIT;Apache-2.0;BSD-2-Clause;BSD-3-Clause;ISC;CC0-1.0'
  continue-on-error: true

- name: System health check
  run: |
    echo "💊 Running system health check..."

    # Use npm script instead
    npm run test:health || echo "⚠️ Health check warnings (non-blocking)"

# REMOVE THIS - it's just a 30 second delay with no actual monitoring
- name: Monitor system stability
  run: |
    # ... sleep 30 ...

- name: Monitor system stability
  run: |
    echo "📊 Monitoring system stability after rollback..."

    # Run actual smoke tests
    npm run test:health

    # Check key endpoints or services
    node dist/cli/main.js --version

    echo "✅ System appears stable"

// Current: Generates fake data
const latency = Math.floor(Math.random() * 50) + 10;
const success = Math.random() > 0.05; // 95% success rate

- name: Test inter-agent communication
  run: |
    echo "📡 Testing inter-agent communication for ${{ matrix.type }}"

    # Run actual integration tests
    npm run test:integration -- --testPathPattern=agent-communication \
      --testTimeout=60000 \
      --maxWorkers=1

# Test locally before pushing
npm test
npm run test:ci
npm run build:ts
npm run lint
npm run typecheck

# Check for duplicate keys in package.json
cat package.json | jq '.scripts | keys | group_by(.) | map(select(length > 1))'