Ideate

What this skill does

## Customization

Before executing, check for user customizations at:
`~/.claude/PAI/USER/SKILLCUSTOMIZATIONS/Ideate/`

# Ideate — The Cognitive Progress Engine

A loop-controlled evolutionary creativity engine that mirrors human cognitive processes to generate genuinely novel ideas. **This is NOT BeCreative** — BeCreative is a single-pass diversity tool. Ideate is an evolutionary *system*: multiple cycles of consuming, dreaming, stealing, breeding, and testing ideas over simulated time scales from hours to decades, driven by a first-class Loop Controller and a Lamarckian Meta-Learner.

## The Core Insight

Human creativity reduces to 5 irreducible functions:

| Function | What It Does | Human Analog |
|----------|--------------|--------------|
| **INGEST** | Gather diverse raw material | Reading, conversations, experiences |
| **PERTURB** | Recombine inputs with controlled noise | Dreaming, daydreaming, shower thoughts |
| **CROSS-POLLINATE** | Map patterns from foreign domains | "Stealing" ideas from unrelated fields |
| **SELECT** | Score against fitness function | Critical thinking, peer review, testing |
| **ITERATE** | Feed survivors back as inputs | Sleep cycles, weeks of study, years of work |

The 9 workflow phases expand these into a richer human-legible system. DREAM, DAYDREAM, and CONTEMPLATE are PERTURB at different noise levels. MATE is PERTURB on existing ideas. META-LEARN adds the Lamarckian advantage — analyzing WHY ideas worked and steering future generation.

## The 9 Phases (Summary)

| # | Phase | Noise | What it does | Agent |
|---|-------|-------|--------------|-------|
| 1 | **CONSUME** | — | Multi-domain research, atomic idea extraction | The Glutton |
| 2 | **DREAM** | 0.9 | Free-association on random input subsets, no problem awareness | The Dreamer |
| 3 | **DAYDREAM** | 0.5 | Tangential wandering with the problem held loosely | The Wanderer |
| 4 | **CONTEMPLATE** | 0.1 | Structured analysis via 4 lenses (mandatory; checkpoint A gates) | The Sage |
| 5 | **STEAL** | — | Cross-domain pattern borrowing via weighted random domain lottery | The Thief |
| 6 | **MATE** | — | Genetic recombination via Fisher-Yates shuffle + 8 mutation operations | The Matchmaker |
| 7 | **TEST** | — | Multi-judge scoring on Feasibility/Novelty/Impact/Elegance (checkpoint B gates) | The Judge |
| 8 | **EVOLVE** | — | Selection: kill bottom 50%, elite top 10%, mutate the rest, immigrant injection | The Curator |
| 9 | **META-LEARN** | — | Lamarckian strategy adjustment + next-cycle question generation | The Scientist |

Post-loop: **The Historian** runs the Insight Extractor for cross-cycle pattern analysis.

Full phase mechanics live in `Workflows/FullCycle.md`.

## Workflow Routing

| User says... | Workflow |
|--------------|----------|
| "ideate", "id8", "novel ideas for X", "evolve ideas for X", default | `Workflows/FullCycle.md` |
| "quick novelty for X", "fast brainstorm with scoring" | `Workflows/QuickCycle.md` |
| "dream on X", "free-associate these inputs", "wild recombinations" | `Workflows/Dream.md` |
| "steal ideas from biology for X", "cross-pollinate from Y" | `Workflows/Steal.md` |
| "breed these ideas", "recombine X and Y" | `Workflows/Mate.md` |
| "score these candidates", "test these ideas against fitness" | `Workflows/Test.md` |

## The Loop Controller

Owns inter-cycle state and makes continue/pivot/stop decisions after each cycle's META-LEARN phase. State tracked:

```json
{
  "cycle_count": 0,
  "max_cycles": null,
  "budget_seconds_remaining": 600,
  "fitness_history": [{"cycle": 1, "avg_score": 52.3, "top_score": 68.1, "diversity_index": 0.91}],
  "stagnation_counter": 0,
  "strategy_version": 1,
  "strategy_adjustments": {},
  "loop_decision_log": []
}
```

**Loop Gate logic:**
```
IF budget_seconds_remaining <= 0:        STOP (budget exhausted)
ELIF stagnation_counter >= 3:
    IF strategy_pivots_remaining > 0:    PIVOT (shift domains/noise/agents)
    ELSE:                                STOP (exhausted strategies)
ELIF diversity_index < 0.3:              PIVOT (collapse — inject immigrants)
ELIF top_score >= target_score:          STOP (target reached)
ELSE:                                    CONTINUE
```

## Structural Randomness Engine

LLM "temperature" is soft probability redistribution biased toward the training distribution. Ideate uses **structural randomness** at the data level instead:

- **Input subsetting** (DREAM): Fisher-Yates shuffle picks each agent's input subset
- **Domain lottery** (STEAL): weighted random sampling from the 50+ candidate domain pool
- **Pairing shuffle** (MATE): Fisher-Yates pairs adjacent items; 20% slots forced cross-phase
- **Mutation dice** (EVOLVE): roll an 8-sided die, apply that mutation operation:
  1. Flip one assumption
  2. Invert the constraint
  3. Change the scale (10× bigger or smaller)
  4. Change the time horizon
  5. Merge with a random killed idea's best element
  6. Apply a constraint from a random domain
  7. Remove the most complex component
  8. Add an adversarial requirement

Implementation: `crypto.getRandomValues()` with seed = cycle number + problem hash.

## External Validation Hooks (TEST extension)

Optional pluggable interface that adds real-world signal to internal scoring:

```typescript
interface ValidationHook {
  name: string;
  validate(idea: Idea, problem: Problem): Promise<{ modifier: number; evidence: string }>;
}
```

Built-in hooks: `MarketSearch` (existing implementations), `FeasibilityCheck` (technical blockers), `ExpertPanel` (async human review), `PrototypeSimulation` (generate + test prototype).

## Time-Scale Configuration

| Time scale | Budget | Est. cycles | Agents/phase |
|------------|--------|-------------|--------------|
| `hours` | 5 min | 1-2 | 2-3 |
| `days` | 12 min | 2-4 | 3-4 |
| `weeks` | 25 min | 3-8 | 4-5 |
| `months` | 45 min | 5-15 | 5-6 |
| `years` | 90 min | 8-30 | 6-8 |
| `decades` | 180 min | 15-50+ | 8-10 |

Loop Controller decides actual cycle count adaptively, not a fixed count.

## State Persistence

Each run persists to `~/.claude/PAI/MEMORY/WORK/{slug}/ideate/`:

```
ideate/
  config.json           # Problem, time_scale, domains, hooks
  loop-state.json       # Loop Controller (fitness_history, strategy, decisions)
  domain-pool.json      # Weighted domain pool (expanded across cycles)
  cycle-NNN/            # Per-cycle artifacts: input-pool, dreams, daydreams,
                        # analyses, checkpoint-a, stolen, offspring, scores,
                        # checkpoint-b, survivors, meta-learning, summary
  insights.md           # Insight Extractor output (post-loop)
  final-output.md       # Ranked candidate list with full provenance
```

## Idea Data Structure

```json
{
  "id": "idea-042",
  "text": "...",
  "provenance": {
    "parents": ["idea-017", "idea-023"],
    "operation": "crossover",
    "mutation_type": "scale_change",
    "mutation_die_roll": 3,
    "cycle": 3, "phase": "MATE",
    "source_domains": ["mycology", "distributed-systems"],
    "randomness_seed": "a7f3c9..."
  },
  "scores": {
    "feasibility": 72, "novelty": 88, "impact": 65, "elegance": 81,
    "composite": 76.5, "confidence": 0.82, "judge_variance": 8.3,
    "external_validation": {"market_search": {"modifier": -5, "evidence": "..."}},
    "adjusted_composite": 74.5
  },
  "arguments": {"supporting": "...", "counter": "..."}
}
```

## Final Output Format

```markdown
# Ideate Results: [Problem]

**Time scale:** [scale] | **Budget used:** X of Y min | **Cycles:** N (adaptive)
**Strategy pivots:** M | **Total ideas:** X | **Survived:** Y | **Kill rate:** Z%

## Top Candidates (ranked by adjusted composite score)

### 1. [Title] — Score: 85.2/100 (confidence: 0.91)

**The idea:** [2-3 sentences]
**Scores:** Feasibility: 78 | Novelty: 92 | Impact: 84 | Elegance: 87
**External validation:** [hook results]
**Provenance:** Born in cycle N from [operation] of [parents]. Mutation: [type].
**For it:** [supporting argument]
**Agains