qc-iterative-improve

name: qc-iterative-improve description: Execute iterative improvement workflow for QuantConnect strategies. Arguments: [strategy|issue#] [--iterations=N] [--no-backtest] [--commit]

QC Iterative Improve Skill

Orchestre l'amelioration iterative des strategies QuantConnect. Methodologie: Research notebook d'abord, implementation ensuite.

Action: $ARGUMENTS

Arguments

Mapping Issues -> Strategies

Tracker global: issue #29

Workflow principal

                    ┌─────────────────────────────────────┐
                    │  /qc-iterative-improve #XX          │
                    └──────────────┬──────────────────────┘
                                   │
                    ┌──────────────▼──────────────────────┐
                    │  1. CONTEXT: Lire issue + code +    │
                    │     backtests + notebook existant    │
                    └──────────────┬──────────────────────┘
                                   │
                    ┌──────────────▼──────────────────────┐
                    │  2. RESEARCH NOTEBOOK                │
                    │  Creer/enrichir research.ipynb       │
                    │  - Analyse exploratoire (QuantBook)  │
                    │  - Hypotheses et tests               │
                    │  - Visualisations                    │
                    │  - Conclusions argumentees           │
                    └──────────────┬──────────────────────┘
                                   │
                    ┌──────────────▼──────────────────────┐
                    │  3. IMPLEMENT                        │
                    │  Appliquer findings dans main.py     │
                    │  (seulement si notebook concluant)   │
                    └──────────────┬──────────────────────┘
                                   │
                    ┌──────────────▼──────────────────────┐
                    │  4. VALIDATE                         │
                    │  Compiler + backtester sur QC cloud  │
                    └──────────────┬──────────────────────┘
                                   │
                    ┌──────────────▼──────────────────────┐
                    │  5. EVALUATE + UPDATE                │
                    │  Comparer metriques, MAJ issue #29   │
                    │  Iterer si necessaire                │
                    └─────────────────────────────────────┘

Phase 0: Lire le backlog (OBLIGATOIRE)

1. Lire projects/OPTIMIZATION_BACKLOG.md
   - Verifier si la strategie a un plafond confirme -> STOP si oui
   - Lire les hypotheses deja testees et rejetees -> NE PAS retester
   - Appliquer les regles universelles (18 patterns confirmes)

2. A la fin de l'iteration: mettre a jour le backlog avec les nouvelles lecons

Phase 1: Lire le contexte

1. Lire l'issue GitHub (gh issue view #XX)
   - Problemes identifies
   - Travail demande
   - Lecons apprises des sessions precedentes

2. Lire le code cloud actuel
   - MCP: read_file(projectId, "main.py")
   - Local: projects/{Strategy}/main.py

3. Lire les derniers backtests
   - MCP: list_backtests(projectId, includeStatistics=true)
   - MCP: read_backtest(projectId, backtestId) pour le meilleur

4. Verifier si un notebook existe deja
   - projects/{Strategy}/research.ipynb
   - partner-course-quant-trading/examples/{Strategy}/research.ipynb
   - partner-course-quant-trading/lean-workspace/{Strategy}-Researcher/research.ipynb

Phase 2: Research Notebook (COEUR DU WORKFLOW)

Le notebook est l'artefact principal. Il doit etre:

• Pedagogique: expliquer le raisonnement a chaque etape
• Reproductible: executable avec QuantBook ou standalone
• Conclusif: chaque hypothese testee a un verdict clair

Structure recommandee du notebook

Cell 1 (md): # Research: {Strategy Name}
  - Contexte et objectif
  - Performance actuelle et problemes
  - Hypotheses a tester

Cell 2 (code): Setup & Data Loading
  - qb = QuantBook() ou import yfinance
  - Charger les donnees historiques
  - Afficher statistiques de base

Cell 3 (md): ## Analyse Exploratoire
  - Description de ce qu'on va explorer

Cell 4 (code): Analyse exploratoire
  - Distributions, correlations, regimes
  - Visualisations (matplotlib/plotly)

Cell 5-N: Hypotheses et tests
  Pour chaque hypothese:
  - Cell (md): Description de l'hypothese
  - Cell (code): Test de l'hypothese
  - Cell (md): Verdict (CONFIRMEE/INFIRMEE) et impact

Cell N+1 (md): ## Conclusions et Recommendations
  - Resume des findings
  - Configuration recommandee
  - Changements a implementer dans main.py

Cell N+2 (code): Configuration finale
  - Parametres recommandes en format dict/JSON
  - Backtest vectorise simplifie si possible

Deux approches possibles

Approche A: QuantBook (si lean research disponible)

qb = QuantBook()
symbol = qb.add_equity("SPY", Resolution.DAILY).symbol
history = qb.history(symbol, datetime(2015,1,1), datetime.now(), Resolution.DAILY)

Avantage: donnees QC exactes, memes indicateurs que l'algo

Approche B: Standalone (yfinance/pandas)

import yfinance as yf
data = yf.download("SPY", start="2015-01-01", end="2026-01-01")

Avantage: pas besoin de Docker/lean, executable n'importe ou Inconvenient: donnees peuvent differer legerement de QC

Recommandation: Utiliser l'approche B (standalone) pour la recherche, puis valider avec un backtest cloud QC. Plus rapide et plus accessible pedagogiquement.

Phase 3: Implementation

Seulement si le notebook a produit des conclusions claires.

1. Modifier main.py localement en appliquant les findings du notebook
2. MCP: read_file(projectId, "main.py")  -- acquiert le lock
3. MCP: update_file_contents(projectId, "main.py", newContent)

Phase 4: Validation

1. MCP: create_compile(projectId) -> compileId
2. MCP: read_compile(projectId, compileId) -> BuildSuccess?
3. MCP: create_backtest(projectId, compileId, "v{N}")
4. Attendre 60-240s selon type
5. MCP: read_backtest(projectId, backtestId) -> metriques

Phase 5: Evaluation et mise a jour

1. Comparer Sharpe avant/apres
2. Si ameliore: garder, MAJ fichier local + notebook
3. Si degrade: revert
4. MAJ issue GitHub avec le nouveau Sharpe
5. MAJ tracker #29 avec le statut
6. Si --commit: git add + commit

Reprise apres saturation de contexte

Le workflow est concu pour survivre aux redemarrages:

Etat persistant (survit au redemarrage):

• Issue GitHub (#XX) avec checklist de progression
• Notebook research.ipynb avec les cellules deja creees
• Code main.py (local + cloud)
• Backtests sur le cloud QC

Pour reprendre:

1. Relancer /qc-iterative-improve #XX
2. L'agent lit l'issue, le notebook, les backtests
3. Il identifie ou on en est et continue

Regles critiques

0. BACKLOG AVANT TOUT - Lire projects/OPTIMIZATION_BACKLOG.md avant de commencer. Ne pas retester des hypotheses rejetees.
1. Notebook AVANT code - Ne jamais modifier main.py sans avoir d'abord explore dans le notebook
2. read_file AVANT update_file_contents - Collaboration lock QC
3. 1 seul backtest a la fois - Node unique QC
4. Options = Resolution.MINUTE - Sinon chain vide
5. Pas de Universe Selection - Trop lent. ETFs fixes
6. Long-only en bull market - Short = catastrophique
7. "In Progress..." = bug MCP - Attendre et reessayer
8. Org perso seulement - Partner org = FREE, pas de backtest API

Sub-Agent

Output attendu

# QC Improvement Report: {Strategy} (Issue #{N})

**Date**: {timestamp}
**Iterations**: {actual}/{max}
**Resultat**: {SUCCESS|IN_PROGRESS|NO_CHANGE|FAILED}

## Research Notebook
- Chemin: projects/{Strategy}/research.ipynb
- Cellules: {N} ({code}/{md})
- Hypotheses testees: {list}
- Conclusions: {summary}

## Metriques

| Metric | Avant | Apres | Changement |
|--------|-------|-------|------------|
| Sharpe | {X} | {Y} | {delta} |
| CAGR | {X%} | {Y%} | {delta} |
| Max DD | {X%} | {Y%} | {delta} |

## Prochaines etapes
{next_steps pour la prochaine iteration}