✅ Step 1: Paper Retrieval
   → Fetching paper metadata from arXiv...
   → Title: "A Primer on Perpetuals"

✅ Step 2: Methodology Extraction
   → Strategy Type: arbitrage (funding rate)
   → Entry: When funding rate > 0.1% annualized
   → Exit: When funding rate < 0 or position age > 8h

✅ Step 3: NautilusTrader Mapping
   → Indicators: None (uses funding rate API)
   → Order Types: MARKET, STOP_MARKET
   → Custom: FundingRateMonitor (needs implementation)

✅ Step 4: Spec Generation
   → Created: specs/023-funding-rate-arb/spec.md
   → Entity: strategy__arbitrage_perp_funding_2022

✅ Ready for: /speckit.plan

Input: Paper ID (arXiv, DOI, SSRN, or URL)
Actions:
  - Fetch paper metadata (title, authors, abstract)
  - If paper > 50 pages: Use mcp__gemini-cli__ask-gemini for analysis
  - If paper < 50 pages: Use Claude context for analysis
Output: Structured paper summary

Extract from paper:
  - Strategy type: momentum|mean_reversion|market_making|arbitrage|trend_following|statistical_arbitrage
  - Entry conditions (natural language)
  - Exit conditions (natural language)
  - Indicators used (with parameters)
  - Position sizing method
  - Risk management rules
  - Backtest methodology
  - Reported results (Sharpe, drawdown, returns)

Use mapping tables from:
  - docs/research/indicator_mapping.md
  - docs/research/order_mapping.md

Map each paper component:
  - Paper indicator → NautilusTrader class + params
  - Paper order type → NautilusTrader OrderType enum
  - Paper event → NautilusTrader event handler

Flag custom indicators needed:
  - If indicator not in mapping → Add to "custom_indicators_needed"
  - Suggest implementation approach

Generate files:
  - specs/{n}-{strategy_name}/spec.md (from template)
  - Update memory.json with strategy__ entity (via sync)

Create spec directory:
  - Use next available spec number
  - Name: {methodology}_{asset}_{author_year}

User: "Convert arxiv:2103.15879 momentum paper to strategy"

Output:
- Strategy: Crypto Momentum Cross-Sectional
- Type: momentum
- Indicators: ExponentialMovingAverage, RelativeStrengthIndex
- Entry: Buy top 5 by 7-day momentum, RSI < 70
- Exit: Hold 7 days or RSI > 80
- Spec: specs/024-crypto-momentum/spec.md

User: "paper to strategy Avellaneda-Stoikov"

Output:
- Strategy: Optimal Market Making (Avellaneda-Stoikov)
- Type: market_making
- Indicators: OrderBookImbalance (custom), InventoryRisk (custom)
- Entry: Continuous quote updates
- Exit: Inventory limits exceeded
- Spec: specs/025-optimal-mm/spec.md
- Note: Requires custom indicators

User: "implement strategy from pairs trading cointegration paper"

Output:
- Strategy: Statistical Pairs Trading
- Type: mean_reversion
- Indicators: LinearRegression (custom), ZScore (custom)
- Entry: Z-score > 2 (short), Z-score < -2 (long)
- Exit: Z-score crosses 0
- Spec: specs/026-pairs-trading/spec.md

Command: /research
Uses: paper-to-strategy skill
Output: Complete spec.md ready for /speckit.plan

Input: specs/{n}/spec.md
Process: Generate 3+ implementation variants
Output: Ranked implementations by backtest performance

Error: Paper ID not found in databases
Action:
  1. Try alternative databases (arXiv → SSRN → DOI)
  2. Ask user for direct PDF/URL
  3. If still not found → "Paper not accessible, please provide PDF"

Error: Paper doesn't clearly define trading logic
Action:
  1. Ask clarifying questions about entry/exit
  2. Extract from "Methodology" or "Results" sections
  3. If still unclear → Generate partial spec with [NEEDS CLARIFICATION] markers

Warning: Indicator not in NautilusTrader
Action:
  1. Add to custom_indicators_needed section
  2. Suggest implementation approach
  3. Check if similar indicator exists (e.g., "momentum" → RateOfChange)

Trigger: Spec generation complete
Command: Invoke alpha-evolve agent with spec.md path

alpha-evolve receives:
  - specs/{n}/spec.md: Strategy specification
  - specs/{n}/plan.md: Implementation plan (if exists)
  - Indicator mappings from docs/research/

alpha-evolve produces:
  - 3+ implementation variants
  - Fitness scores (tests, performance, quality)
  - Selected winner or ensemble

## Next Steps

### Option 1: Standard Implementation
Run `/speckit.plan` to create implementation plan, then use nautilus-coder.

### Option 2: Multi-Implementation (Recommended for complex strategies)
Invoke alpha-evolve agent for 3+ implementation variants:

1. Read the generated spec: specs/{n}/spec.md
2. Generate 3 approaches varying:
   - Algorithm complexity
   - Indicator usage patterns
   - Risk management implementation
3. Backtest each variant
4. Select best by Sharpe ratio / drawdown
5. Promote winner to production

### Alpha-Evolve Command
Use Task tool with subagent_type='alpha-evolve':
"Implement strategy from specs/{n}/spec.md with 3 variants.
Evaluate by backtest Sharpe ratio and max drawdown.
Select best implementation."

=== ALPHA-EVOLVE RESULTS ===

| Variant | Sharpe | Drawdown | Tests | TOTAL |
|---------|--------|----------|-------|-------|
| A: Event-driven | 1.8 | 15% | PASS | 85/100 |
| B: State machine | 1.5 | 12% | PASS | 78/100 |
| C: Rule-based | 2.1 | 22% | PASS | 72/100 |

Winner: Variant A (balanced performance + lower drawdown)