# 1. Install required skills
/plugin marketplace add MadAppGang/claude-code
skill install superpowers:using-git-worktrees
skill install superpowers:writing-plans

# 2. Verify OpenRouter access (for multi-model)
export OPENROUTER_API_KEY=your-key

# 3. Configure models in ~/.claude/settings.json
{
  "brainstorming": {
    "primary_model": "anthropic/claude-opus-4-20250514",
    "explorer_models": [
      "x-ai/grok-code-fast-1",
      "google/gemini-2-5-pro",
      "anthropic/claude-sonnet-4-20250514"
    ]
  }
}

// Pattern: Use Tasks to track questions, Read/Write for presentation

// 1. Write question to temp file
await Write({
  file_path: "/tmp/brainstorm-q1.md",
  content: `## Question 1 of 3

**What are the main constraints or requirements for this feature?**

Please respond with:
- Functional requirements (what it must do)
- Non-functional requirements (performance, scale)
- Any existing dependencies or integrations
`
});

// 2. Present file and wait for user response
// User reads file, provides input via conversation

// 3. Summarize understanding
const problemSummary = await Write({
  file_path: "/tmp/brainstorm-problem.md",
  content: `## Problem Understanding

**Constraints identified:**
- [From user response]

**Success criteria:**
- [Measurable outcomes]

**Scope boundaries:**
- [What's in/out]

---

**Does this accurately capture the problem?** (Reply "yes" to proceed or clarify)
`
});

interface ModelResult {
  model: string;
  success: boolean;
  output?: string;
  error?: string;
}

async function exploreWithFallback(
  prompt: string,
  role: "explorer"
): Promise<ModelResult> {
  const fallbackModels = role === "explorer"
    ? ["x-ai/grok-code-fast-1", "google/gemini-2-5-pro", "deepseek/deepseek-coder"]
    : ["anthropic/claude-opus-4-20250514", "anthropic/claude-sonnet-4-20250514"];

  for (const model of fallbackModels) {
    try {
      const result = await Task({
        model: model,
        prompt: prompt,
        timeout_ms: 120000  // 2 minute timeout
      });

      return { model, success: true, output: result };
    } catch (error) {
      console.warn(`Model ${model} failed:`, error.message);
      continue;  // Try next in chain
    }
  }

  throw new Error(`All models in fallback chain failed`);
}

// WRONG: Sequential (slow)
// const result1 = await Task({ model: "grok", ... });
// const result2 = await Task({ model: "gemini", ... });
// const result3 = await Task({ model: "sonnet", ... });

// CORRECT: Parallel (3-5x faster)
const [result1, result2, result3] = await Promise.all([
  Task({
    model: "x-ai/grok-code-fast-1",
    prompt: generateExplorerPrompt(problem, "fast_code")
  }),
  Task({
    model: "google/gemini-2-5-pro",
    prompt: generateExplorerPrompt(problem, "balanced")
  }),
  Task({
    model: "anthropic/claude-sonnet-4-20250514",
    prompt: generateExplorerPrompt(problem, "thorough")
  })
]);

// Handle partial failures
const results = [result1, result2, result3].filter(r => r.success);
if (results.length === 0) {
  throw new Error("All exploration models failed");
}

## Approach: [Name]

**Model**: [Which model generated this]
**Approach Type**: [architecture/algorithm/pattern]
**Summary**: 2-3 sentences

**Key Components**:
1. Component A
2. Component B
3. Component C

**Trade-offs**:
- + Advantage
- - Disadvantage

**Confidence**: [Model's confidence 0-100]

interface Approach {
  id: string;
  name: string;
  summary: string;
  model: string;  // Which model proposed
  modelConfidence: number;  // 0-100
  embedding: number[];  // For clustering
}

interface Cluster {
  approaches: Approach[];
  representative: Approach;  // Most complete
  agreementScore: number;  // 0-1
  confidenceScore: number;  // 0-100
  consensusLevel: "UNANIMOUS" | "STRONG" | "DIVERGENT";
}

function calculateConsensus(approaches: Approach[]): Cluster[] {
  // Step 1: Cluster by semantic similarity
  const clusters = clusterByEmbedding(approaches, threshold: 0.85);

  // Step 2: Calculate metrics per cluster
  return clusters.map(cluster => {
    const models = cluster.map(a => a.model);
    const modelCount = new Set(models).size;
    const totalModels = approaches.length;

    // Agreement: proportion of models that have an approach in this cluster
    const agreementScore = modelCount / totalModels;

    // Confidence: weighted average + agreement bonus
    const baseConfidence = cluster
      .map(a => a.modelConfidence)
      .reduce((a, b) => a + b, 0) / cluster.length;

    const confidenceScore = Math.min(100,
      baseConfidence + (agreementScore * 20)  // +20% for agreement
    );

    // Consensus classification
    const consensusLevel = agreementScore >= 0.9 ? "UNANIMOUS" :
                          agreementScore >= 0.5 ? "STRONG" :
                          "DIVERGENT";

    return {
      approaches: cluster,
      representative: cluster.reduce((best, current) =>
        current.modelConfidence > best.modelConfidence ? current : best
      ),
      agreementScore,
      confidenceScore: Math.round(confidenceScore),
      consensusLevel
    };
  }).sort((a, b) => b.confidenceScore - a.confidenceScore);
}

Confidence = Base + AgreementBonus - DiversityPenalty

Where:
  Base = average(model confidences in cluster)
  AgreementBonus = (unique_models / total_models) * 20
  DiversityPenalty = (1 - similarity_coefficient) * 10

Example:
  3 models propose similar approaches
  Base = (92 + 88 + 95) / 3 = 91.7
  AgreementBonus = (3/3) * 20 = 20
  DiversityPenalty = (1 - 0.9) * 10 = 1
  Confidence = 91.7 + 20 - 1 = 110.7 -> capped at 100
  Final: 97%

async function presentApproaches(clusters: Cluster[]): Promise<string> {
  const topClusters = clusters.slice(0, 5);  // Top 5

  let presentation = `## Top Approaches\n\n`;

  for (const [index, cluster] of topClusters.entries()) {
    const approach = cluster.representative;

    presentation += `### ${String.fromCharCode(65 + index)}: ${approach.name} [${cluster.consensusLevel}]

**Summary**: ${approach.summary}

**Confidence**: ${cluster.confidenceScore}% (${cluster.approaches.length} model(s) agree)

**Pros**:
${cluster.approaches.map(a => `- ${a.summary}`).join("\n")}

**Cons**:
${cluster.approaches.map(a => `- Potential issue from ${a.model}`).join("\n")}

---
`;
  }

  presentation += `
## Your Choice

Which approach best fits your requirements?

- **A**: Select approach A
- **B**: Select approach B
- **C**: Select approach C
- **D**: Combine elements from multiple
- **E**: Explore alternatives (return to Phase 1)
`;

  // Save for user review
  await Write({
    file_path: "/tmp/brainstorm-approaches.md",
    content: presentation
  });

  return presentation;
}

## [Section Name] (Confidence: XX%)

**Approach**: [Selected approach]

**Implementation Details**:
[200-300 words]

**Assumptions**:
- Assumption 1
- Assumption 2

**Confidence Calculation**:
- Technical feasibility: XX%
- Edge cases covered: XX%
- Team capability: XX%
- Overall: XX%

**Status**: [AUTO_GATE|PENDING_USER] - [Reason]

## Plan Validation

**Problem**: [Summary]
**Approach**: [Selected]
**Confidence**: [Overall]

### Checklist

- [ ] Problem scope accurately captured
- [ ] Chosen approach matches expectations
- [ ] Module structure aligns with capabilities
- [ ] Technical constraints addressed
- [ ] Success criteria measurable

### Next Steps

**To proceed**:
1. Reply "approve" to finalize
2. Reply "revise [section]" to modify
3. Reply "restart" to begin fresh

**Final decision?**

// Complete Phase 1 parallel exploration
async function runParallelExploration(problem: string): Promise<Approach[]> {
  const explorerModels = [
    "x-ai/grok-code-fast-1",     // Fast, code-focused
    "google/gemini-2-5-pro",     // Balanced, creative
    "anthropic/claude-sonnet-4-20250514"  // Thorough
  ];

  const prompts = explorerModels.map(model =>
    `Generate 5 implementation approaches for: ${problem}

For each approach provide:
1. Name (2-3 words)
2. One-sentence summary
3. Key components (bullet points)
4. Trade-offs (+/-)
5. Your confidence (0-100)

Format as JSON array.`
  );

  // LAUNCH ALL MODELS IN PARALLEL
  const taskPromises = explorerModels.map((model, index) =>
    Task({
      model: model,
      prompt: prompts[index],
      timeout_ms: 120000,
      max_turns: 1
    }).catch(error => ({
      model,
      success: false,
      error: error.message
    }))
  );

  // WAIT FOR ALL TO COMPLETE
  const results = await Promise.all(taskPromises);

  // CONSOLIDATE SUCCESSFUL RESULTS
  const approaches: Approach[] = results
    .filter(r => r.success)
    .flatMap(r => parseApproaches(r.output));

  // HANDLE PARTIAL FAILURES
  if (approaches.length < 5) {
    console.warn(`Only got ${approaches.length} approaches from ${explorerModels.length} models`);
    if (approaches.length === 0) {
      throw new Error("All models failed");
    }
  }

  return approaches;
}

async function resilientExploration(problem: string): Promise<Approach[]> {
  let attempts = 0;
  const maxAttempts = 3;

  while (attempts < maxAttempts) {
    try {
      return await runParallelExploration(problem);
    } catch (error) {
      attempts++;
      if (attempts === maxAttempts) throw error;

      // Exponential backoff
      await new Promise(r => setTimeout(r, Math.pow(2, attempts) * 1000));
    }
  }
}

# Required for multi-model
OPENROUTER_API_KEY=...

# Optional
BRAINSTORM_TIMEOUT_MS=120000
BRAINSTORM_MAX_RETRIES=2
BRAINSTORM_MIN_MODELS=2  # Minimum models for valid consensus

{
  "brainstorming": {
    "primary": ["anthropic/claude-opus-4-20250514"],
    "explorers": {
      "primary_chain": ["x-ai/grok-code-fast-1", "google/gemini-2-5-pro"],
      "fallback_chain": ["deepseek/deepseek-coder", "anthropic/claude-haiku-3-20250514"]
    },
    "thresholds": {
      "auto_gate": 95,
      "confirm_gate": 60
    }
  }
}