#!/bin/bash
# Fan-out: one agent per client folder

clients=("ArtOfYou" "Earleads" "Kateb" "Neoday" "xGrowth")

for client in "${clients[@]}"; do
  claude "Read 01_Projects/Clients/Active/$client/
  Return JSON: {blockers:[], next_actions:[], health: 1-10}" \
  --output "reports/${client}.json" &
done

wait
# All 5 finish in parallel
claude "Merge reports/*.json into a single dashboard summary"

#!/bin/bash
# MapReduce: security audit on all route files

# MAP phase: spawn one agent per file
files=$(find src/routes -name "*.ts" -type f)

for f in $files; do
  claude "Audit $f for security issues.
  Check: SQL injection, auth bypass, XSS, rate limiting.
  Return JSON: {file, issues:[], severity, score}" \
  --output "audit/$(basename $f).json" &
done

wait  # all agents finish in parallel

# REDUCE phase: aggregate all findings
claude "Read all audit/*.json files.
Produce a security report:
- Critical issues first
- Total score across all files
- Top 3 recommendations" --output "SECURITY-REPORT.md"

# Pipeline: each stage = different agent with different role

# Stage 1: Research agent
claude "Research this LinkedIn profile: $PROFILE_URL
Extract: role, company, pain points, recent posts.
Save to /tmp/prospect-research.json"

# Stage 2: Writer agent (uses research as input)
claude "Read /tmp/prospect-research.json
Write a personalized DM using the Twins Method.
Max 300 chars, value-first, no pitch.
Save to /tmp/draft-dm.txt"

# Stage 3: Critic agent (fresh eyes)
claude "Review /tmp/draft-dm.txt against these rules:
- No generic openers
- Must reference specific detail from research
- Must end with question
Save approved version to /tmp/final-dm.txt"

# Stage 4: Send (deterministic, no agent needed)
send_linkedin_dm "$(cat /tmp/final-dm.txt)"

#!/bin/bash
# Competing hypotheses: 3 agents, 3 theories

claude "Investigate the intermittent 500 error in /api/checkout.
ASSUME the root cause is a race condition.
Look for: shared state, missing locks, concurrent writes.
Return: {hypothesis, evidence:[], confidence:0-100}" \
  --output "/tmp/h1-race.json" &

claude "Investigate the intermittent 500 error in /api/checkout.
ASSUME the root cause is a memory leak.
Look for: unbounded caches, event listener buildup, streams.
Return: {hypothesis, evidence:[], confidence:0-100}" \
  --output "/tmp/h2-memory.json" &

claude "Investigate the intermittent 500 error in /api/checkout.
ASSUME the root cause is auth token expiry.
Look for: token refresh logic, cache TTL, session handling.
Return: {hypothesis, evidence:[], confidence:0-100}" \
  --output "/tmp/h3-auth.json" &

wait

claude "Compare /tmp/h1-race.json, /tmp/h2-memory.json, /tmp/h3-auth.json.
Which hypothesis has the strongest evidence?
Recommend a fix for the winning hypothesis."

#!/bin/bash
# Writer + Critic loop with stopping condition

MAX_ITERATIONS=3
iteration=0

# Initial implementation
claude "Implement a rate limiter middleware for Express.
Requirements: sliding window, per-user, Redis-backed.
Save to src/middleware/rateLimiter.ts"

while [ $iteration -lt $MAX_ITERATIONS ]; do
  # Critic: fresh agent, no bias
  claude "Review src/middleware/rateLimiter.ts with fresh eyes.
  Check: edge cases, error handling, performance, security.
  If no issues found, respond ONLY with: APPROVED
  Otherwise list specific issues as JSON:
  {issues:[], severity:critical|major|minor}" \
  --output "/tmp/review.json"

  # Check if approved
  if grep -q "APPROVED" /tmp/review.json; then
    echo "Approved after $iteration iterations"
    break
  fi

  # Writer: fix issues from review
  claude "Read the review at /tmp/review.json.
  Fix ALL listed issues in src/middleware/rateLimiter.ts.
  Do not introduce new features, only fix the issues."

  iteration=$((iteration + 1))
done

#!/bin/bash
# Bash Loop Swarm: mass code migration
# 200 Python files → Python 2 to Python 3

MAX_PARALLEL=10  # control concurrency
count=0

for f in $(find src/ -name "*.py" -type f); do
  claude "Migrate $f from Python 2 to Python 3.
  - Fix print statements
  - Fix integer division
  - Fix unicode handling
  - Fix dict.keys()/values()/items()
  - Run: python3 -c 'import ast; ast.parse(open("$f").read())'
  to verify syntax is valid after migration." &

  count=$((count + 1))
  # Throttle: wait every MAX_PARALLEL jobs
  if [ $((count % MAX_PARALLEL)) -eq 0 ]; then
    wait
  fi
done

wait  # wait for remaining jobs
echo "Migration complete: $count files processed"