Aether v6.0 — Framework d'analyse de sécurité des contrats intelligents

Version 6.0 | Nouveautés de v6.0 | Changelog

Aether est un framework Python pour analyser les contrats intelligents Solidity, générer des constatations de vulnérabilités, produire des tests de preuve de concept (PoC) basés sur Foundry et valider des exploits sur des forks du mainnet. Il combine l'analyse AST Solidity, l'analyse de taint, l'analyse de graphe de flux de contrôle, l'analyse inter-contrats, l'exécution symbolique Halmos, plus de 180 détecteurs statiques basés sur des motifs, un pipeline LLM multi-agents collaboratif (GPT/Gemini/Claude) avec une mémoire institutionnelle SAGE partagée, 14 archétypes de protocoles, une base de connaissances de plus de 75 exploits, la détection calibrée par ML, la détection des particularités de jetons, l'extraction d'invariants, la résolution du contexte des contrats liés et un filtrage avancé sensible au contexte dans une interface TUI plein écran persistante unique.

Nouveautés de v6.0

Pipeline d'agents collaboratifs — Le pipeline d'analyse approfondie passe de 5 passes indépendantes à 5 agents collaboratifs partageant des connaissances structurées via la mémoire institutionnelle SAGE :

• Mémoire de session partagée — Chaque passe stocke les résultats, les rejets et les protections vérifiées dans une session SAGE par audit. Les passes suivantes reçoivent "Prior Pass Intelligence" au lieu de résumés de texte simples.
• Rejets en tant qu'enregistrements de première classe — Lorsque la passe 3 rejette un problème (par exemple, "réentrance protégée par le modificateur nonReentrant"), la passe 5 ne le signalera plus. Cela élimine directement la source n° 1 des constatations en double.
• Mécanisme de contestation — Les passes ultérieures peuvent annuler les rejets précédents, mais doivent fournir de NOUVELLES preuves. "La passe 3 n'a pas vu le chemin de rappel via cette autre fonction" est valide. "Je ne suis pas d'accord" ne l'est pas.
• Confirmation inter-passes — Lorsque plusieurs passes confirment indépendamment une constatation, la confiance augmente de 15%. Les constatations confirmées entre passes sont priorisées dans les rapports.
• SAGE requis — La mémoire institutionnelle est désormais requise, et non optionnelle. Pas de SAGE = pas d'audit. Exécutez docker compose up -d pour démarrer.

Nouveautés de v5.0

Mémoire institutionnelle SAGE — Aether apprend désormais de chaque audit, réduisant les faux positifs et améliorant la qualité des constatations au fil du temps :

• Base de connaissances pré-entraînée — Livrée avec 170 mémoires institutionnelles : 75 motifs d'exploits, 63 listes de contrôle d'archétypes de protocoles, 12 catégories de particularités de jetons, 20 exploits historiques sélectionnés (DAO, Wormhole, Euler, Ronin, Curve, et plus)
• Intégration au pipeline — SAGE rappelle les constatations historiques et les motifs d'exploits dans les passes 3 et 5 de l'analyse approfondie ; il stocke les enseignements des audits après le pipeline pour un rappel futur
• Boucle de rétroaction — Les constatations confirmées sont stockées comme des faits à haute confiance ; les constatations rejetées (faux positifs) sont stockées afin que les futurs audits les évitent. Les résultats d'AccuracyTracker alimentent automatiquement SAGE
• Pipeline de validation — Nouvelle étape -1 : le contrôle des FP connus de SAGE filtre les constatations correspondant à des motifs précédemment rejetés avant toute autre validation
• Synchronisation de la précision des détecteurs — SageFeedbackManager.sync_detector_accuracy() identifie les détecteurs à haute/basse performance et stocke des réflexions sur les comportements à adopter et à éviter
• Pré-remplissage automatique au démarrage — Le premier lancement avec SAGE Docker en cours d'exécution pré-remplit automatiquement la base de connaissances pré-entraînée. Sensible à la version : ignore si déjà pré-remplie
• Intégration TUI — Statut SAGE ON/OFF avec le nombre de mémoires affiché dans la CostBar
• Déploiement Docker — docker compose up -d démarre SAGE ; configuration via sage_enabled/sage_url dans ~/.aether/config.yaml
• Dégradation progressive — L'indisponibilité de SAGE ne casse jamais aucune fonctionnalité d'audit

Contributeurs: Merci à @sashavdv pour avoir corrigé les variables de chemin codées en dur (PR #1) et à @pro258b pour avoir identifié la méthode validate_anthropic_key() manquante (PR #2).

Démarrage rapide de SAGE

SAGE est un système de mémoire institutionnelle persistant propulsé par le consensus BFT. Consultez le projet SAGE pour la documentation complète.```bash

Install SAGE Python SDK

pip install sage-agent-sdk

Start SAGE (Docker required)

docker compose up -d

Run Aether — SAGE auto-seeds on first launch

python aether.py

Regenerate seed fixtures after updating knowledge bases (dev only)

python -c "from core.sage_seeder import SageSeeder; SageSeeder.generate_seed_fixtures()"

### Comment SAGE améliore les audits```
Audit 1 → Findings + FPs → Record outcomes in SAGE
                                    ↓
Audit 2 → SAGE recalls FP patterns → Fewer false positives
                                    ↓
Audit 3 → Richer institutional context → Better severity calibration
                                    ↓
Audit N → Institutional expert-level knowledge → Bug-bounty-quality findings

Nouveautés de la v4.7

Exécution automatique des PoC — Les PoC Foundry générés se compilent et s'exécutent désormais automatiquement :

• L'intégration forge test --json exécute les PoC immédiatement après la compilation
• Analyse des résultats JSON avec la dataclass PoCTestResult pour un rapport structuré succès/échec/erreur
• Prise en charge du mode fork pour valider les exploits sur le mainnet contre l'état en direct
• Nouvelle phase POC_TESTING dans JobManager pour le suivi en direct de la progression dans la TUI

Exécution symbolique Halmos — Vérification formelle par exécution symbolique :

• HalmosRunner pour exécuter les tests symboliques Halmos contre les propriétés générées
• HalmosPropertyGenerator pour générer automatiquement des propriétés de vérification à partir des invariants extraits
• Nœud de pipeline HalmosSymbolicNode intégré à l'étape de validation 1.95
• Options de configuration : enable_symbolic_verification, halmos_timeout
• Dégradation progressive si Halmos n'est pas installé — ignore la vérification symbolique sans erreur

Analyse du graphe de flux de contrôle — Compréhension du flux de contrôle au niveau du compilateur :

• Classes de données BasicBlock, CFGEdge, ControlFlowGraph dans solidity_ast.py
• build_cfg(), get_dominators(), get_loop_headers(), format_cfg_for_llm() pour l'analyse structurelle
• Analyse des blocs d'assembly via parse_assembly_block() pour la prise en charge de l'assembly inline
• Propagation de taint sensible aux branches dans l'analyseur de taint pour une analyse sensible au chemin d'exécution
• Contexte CFG injecté dans l'analyse approfondie Pass 2 avec les données de taint

Boucle de rétroaction ML — Calibrage basé sur les résultats historiques :

• AccuracyTracker.record_finding_outcome() pour suivre les résultats de soumission et les gains de bounty
• get_detector_accuracy() et get_detector_weights() pour les statistiques de performance par détecteur
• Classe de données DetectorStats suivant les vrais/faux positifs et la précision historique
• Ajustement du poids de confiance dans EnhancedVulnerabilityDetector en fonction de l'historique du détecteur
• Calibrage de la sévérité à partir des données historiques injecté dans l'analyse approfondie Pass 5

Contexte des contrats liés — L'analyse LLM voit désormais le code source complet des dépendances :

• RelatedContractResolver découvre automatiquement les contrats parents, interfaces, bibliothèques et dépendances
• Le mode projet utilise l'analyse des relations inter-contrats ; le mode fichier unique analyse les instructions import
• Système de budget par passe : 200K caractères pour les passes Gemini Flash, 100K pour Claude, 50K pour GPT
• Bibliothèques standard (@openzeppelin, solmate, solady) résumées en interface uniquement pour économiser le budget
• Les audits de fichiers uniques découvrent automatiquement les fichiers .sol voisins pour le contexte

Nettoyage de la dette technique — 8 500 lignes de code mort supprimées :

• Supprimés : ai_ensemble.py, audit_engine.py, fork_verifier.py
• Suppression de toutes les références à ai_ensemble dans la CLI, le runner d'audit, les écrans TUI et le générateur de rapports
• Suppression de slither_project_cache du gestionnaire de base de données
• Suppression des stubs de vérification formelle du moteur d'audit amélioré

Nouveautés de la v4.0

Analyse AST Solidity — Aether v4.0 ajoute une analyse de code basée sur le compilateur via py-solc-x, allant au-delà de l'analyse statique par regex uniquement :

• Intégration complète de solc --ast-json pour une résolution correcte de l'héritage, la visibilité des fonctions, la disposition du stockage avec numéros de slots et le suivi des lectures/écritures de variables d'état par fonction
• Repli élégant sur regex en cas d'échec de compilation (imports manquants, mauvaise version du compilateur)
• Résumé structurel de l'AST automatiquement injecté dans le pipeline LLM d'analyse approfondie pour une meilleure compréhension du protocole

Moteur d'analyse de taint — Suit les entrées contrôlées par l'utilisateur à travers les contrats pour identifier les flux de données dangereux :

• 8 types de sources de taint : paramètres de fonction, msg.sender, msg.value, calldata, retours d'appels externes, block.timestamp, block.number, tx.origin
• 12 types de sinks dangereux : delegatecall, selfdestruct, appels externes, transferts ETH, écritures de stockage, indexation de tableaux, division par zéro, etc.
• Détection des assainisseurs : reconnaît les vérifications de bornes require, les modificateurs de contrôle d'accès, les reverts conditionnels, le clamping Math.min/max, SafeCast
• Suivi de taint inter-contrats sur plusieurs fichiers
• Intégré au pipeline de validation (étape 1.85) pour la corroboration/réfutation des résultats sensible à la taint

Analyse inter-contrats (Pass 3.5) — Nouvelle passe d'analyse approfondie ciblant les vulnérabilités multi-contrats :

• Analyseur de relations inter-contrats : détecte l'héritage, les appels d'interface, delegatecall, staticcall, les relations typées de variables d'état
• Regroupement union-find des contrats liés avec détection des frontières de confiance
• Passe LLM dédiée analysant : violations de frontières de confiance, cohérence d'état inter-contrats, réentrance inter-contrats, conformité d'interface, interactions de mise à niveau, élévation de privilèges
• Le contexte inter-contrats est également injecté dans la Pass 4 pour une prise de conscience inter-fonctions

Base de données des particularités de jetons — 12 catégories de comportements ERC-20 non standard qui causent de vrais exploits :

Intégrée au pipeline de détection statique et aux listes de contrôle des archétypes.

Moteur de précision amélioré — Détection avancée des vulnérabilités d'arrondi et de précision :

• Détection de l'inflation de parts / attaque du premier déposant pour les coffres ERC-4626, les pools de prêt, le staking
• Analyse du sens d'arrondi — les dépôts doivent arrondir vers le BAS, les retraits vers le HAUT
• Suivi des troncatures de division — détecte les variables de taux tronquées ensuite utilisées dans des multiplications
• Détection de l'exploitation des poussières — arrondir à zéro permet des opérations gratuites
• Débordement d'accumulateur — évaluation du risque de débordement de l'accumulateur de récompenses

Génération de PoC exécutables — Les tests Foundry générés se compilent et s'exécutent réellement :

• Bibliothèque de contrats mock : MockERC20, MockOracle, MockWETH, MockFlashLoanProvider
• Générateur intelligent de setUp() : extrait les paramètres du constructeur, déploie les mocks, gère les contrats évolutifs, frappe des jetons, définit les approbations
• Nombre maximal de tentatives de compilation augmenté de 3 à 5
• Les invites LLM incluent la documentation de l'API mock et le setUp recommandé

Améliorations du pipeline LLM :

• Exemples few-shot dans les passes 3, 4, 5 — exemples de vulnérabilités réelles et de faux positifs issus de la base de connaissances des exploits
• Calibrage de la sévérité — seuils concrets liés à l'impact financier (Critique >1 M$, Élevée >100 K$, Moyenne >10 K$)
• Application du raisonnement en chaîne — raisonnement obligatoire en 5 étapes avant la sortie JSON
• Rotation multi-fournisseurs — Gemini Flash pour les passes économiques, Anthropic Claude pour le raisonnement, OpenAI GPT pour la diversité
• Ensemble d'IA retiré — l'ensemble à 6 agents (coût x6, contexte inférieur) remplacé par une rotation de fournisseurs dans le pipeline structuré

Nouveautés de la v3.5

Moteur d'analyse approfondie — Aether v3.5 transforme fondamentalement la façon dont l'outil détecte les vulnérabilités, passant d'un appel LLM unique « trouver des bugs » à un pipeline structuré en 6 passes qui reflète la manière dont les auditeurs professionnels abordent la revue de code : comprendre d'abord, puis attaquer systématiquement.

Moteur d'analyse approfondie (Pipeline LLM en 6 passes)

Au lieu d'envoyer un contrat entier à un LLM avec une seule invite, Aether exécute désormais six passes d'analyse séquentielles avec un contexte accumulé :

Les passes 1-2 sont mises en cache par hash du contenu du contrat, de sorte que les ré-audits sautent la phase de compréhension. Chaque passe suivante reçoit tout le contexte précédent, construisant un modèle d'attaque complet. Activé par le flag AETHER_DEEP_ANALYSIS=1 (activé par défaut) ; en cas d'échec, repli sur l'approche one-shot.

Système d'archétypes de protocole

Avant d'analyser les bugs, Aether détecte quel type de protocole le contrat implémente et charge des listes de contrôle de vulnérabilités spécifiques à l'archétype :

10 archétypes au total, chacun avec 3 à 7 éléments de liste de contrôle spécifiques tirés d'exploits réels.

Base de connaissances des exploits (50+ schémas)

Une base de données structurée de plus de 50 schémas d'exploits réels catégorisés remplace l'ancienne liste statique de 10 schémas :

Chaque schéma comprend des indicateurs de code, les protections manquantes, le mécanisme d'exploit étape par étape et des précédents réels (avec les montants en dollars). Les schémas sont filtrés par archétype détecté et par domaine de concentration de l'agent.

Moteur d'invariants

Extrait automatiquement les invariants du protocole à partir de trois sources :

1. Balises NatSpec @invariant dans les commentaires des contrats
2. Invariants découverts par le LLM lors de la Pass 1 de l'analyse approfondie
3. Invariants courants détectés par schémas (conservation du solde, produit constant AMM, ratios de collateralisation, etc.)

Génère des suites de tests Foundry invariant_*() qui servent de preuves de vérification formelle allégée — un test d'invariant qui échoue prouve que le bug est réel.

Correctifs du pipeline

• Calibrage de sévérité contextuel — ne rétrograde plus systématiquement division_by_zero, integer_underflow, etc. en faible. Vérifie désormais si le résultat se trouve dans un bloc unchecked{}, à proximité de transferts de valeur, dans des calculs de prix ou dans des contextes d'oracle avant de décider
• Correction de la porte de validation — les résultats "pending" passent désormais à l'analyse LLM (précédemment, seuls les "validated" passaient, ce qui écartait silencieusement de nombreux vrais résultats)
• Pénalité de confiance sensible au spécialiste — les résultats mono-agent d'un spécialiste dans son domaine (par ex. AnthropicReasoningSpecialist trouvant un bug de logique complexe) ne reçoivent qu'une pénalité de -0,05 au lieu de -0,15
• Correction de la déduplication par bucket de lignes — suppression du bucket arbitraire (line // 10) * 10 qui séparait des résultats distants de 2 lignes en groupes différents
• Intégration du détecteur DeFi — DeFiVulnerabilityDetector (analyse de présence/absence en deux étapes) s'exécute désormais dans le moteur d'audit amélioré principal, pas seulement dans le pipeline basé sur les flux

Nouveautés de la v3.0

TUI textuelle entièrement intégrée — Aether v3.0 est une application plein écran persistante qui ne revient jamais à un terminal brut. Chaque opération — audits, génération de PoC, génération de rapports, sélection de la portée GitHub, configuration des paramètres — s'exécute entièrement dans la TUI :

• Zéro appel app.suspend() — la TUI ne disparaît jamais, aucune bascule de terminal brutale
• Tâches en arrière-plan pour tout — audits locaux, audits GitHub, génération de PoC et génération de rapports s'exécutent tous en tant que threads démons avec diffusion en direct de la sortie
• Tableau des tâches en direct — vue de type htop de toutes les tâches en cours/terminées avec statut en temps réel, progression des phases, nombre de résultats, coût et temps écoulé
• Exploration par tâche — appuyez sur Entrée sur une tâche pour voir la sortie défilante en direct, la barre de progression des phases et les métadonnées
• Opérations concurrentes — lancez plusieurs audits, générations de PoC et rapports simultanément ; tous visibles et traçables
• Boîte de dialogue de sélection de contrats — multi-sélection presque plein écran et filtrable remplaçant l'ancien sélecteur basé sur curses. Espace pour basculer, a/n pour tout/rien, taper pour filtrer, contrats déjà audités codés par couleur
• Flux d'audit GitHub intégré — clonez, découvrez, sélectionnez les contrats et lancez les audits sans quitter la TUI. Gestion de la portée (continuer, ré-auditer, nouvelle portée) via les boîtes de dialogue natives de Textual
• Paramètres intégrés — configuration de la clé API et sélection du modèle via TextInputDialog et SelectDialog, aucun assistant de configuration externe requis
• Barre de coût de session — suivi en temps réel du coût LLM par fournisseur (OpenAI, Gemini, Anthropic)
• Piloté au clavier — n Nouvel audit, r Reprendre, h Historique, PoC, Rapports, Récupérer, Paramètres, Quitter

Quatre types de tâches en arrière-plan : Toutes les opérations lourdes s'exécutent en tant que threads démons en arrière-plan via AuditRunner, avec la sortie capturée par ThreadDemuxWriter et visible dans JobDetailScreen :

Prise en charge de trois fournisseurs LLM : OpenAI (GPT-5/5.3), Google Gemini (2.5/3.0) et Anthropic Claude (Sonnet 4.5/Opus 4.6) pour une flexibilité et une redondance maximales.

Génération de PoC améliorée : Analyse de contrats basée sur l'AST, corrections itératives de compilation et invites LLM prêtes pour la production générant des exploits adaptés aux soumissions de bug bounty.

Filtrage avancé des faux positifs : La validation en plusieurs étapes réduit les faux positifs de 66 % à environ 20-25 %, améliorant la précision de 33 % à 75-80 % :

• Détection des scripts — les scripts de déploiement (script/, .s.sol, forge-std/Script.sol) sont automatiquement exclus de l'analyse des vulnérabilités
• Marqueurs de contexte de fichier — les invites LLM incluent des libellés [PRODUCTION]/[DEPLOYMENT SCRIPT] afin que les modèles se concentrent sur le code de production
• Détection dynamique des modificateurs — les modificateurs personnalisés de contrôle d'accès (par ex. onlyDistributor, authorized) sont extraits du code source du contrat et reconnus aux côtés des schémas codés en dur
• Déduplication par portée de fonction — les résultats dupliqués dans la même fonction sont fusionnés au lieu d'utiliser une proximité fragile de numéros de ligne
• Détection atomique du constructeur — déploiement + initialisation dans le même constructeur reconnus comme non front-runnables
• Détection de la gouvernance (paramètres protégés par onlyOwner/onlyGovernor)
• Analyse du déploiement (vérifie que les chemins de code sont réellement utilisés en production)
• Vérifications de protections intégrées (auto-protection Solidity 0.8+, SafeMath)
• Validation LLM sensible à la gouvernance avec une liste de contrôle de 18 schémas
• Suivi de la précision avec les résultats de soumission et les gains de bounty
• Mise en cache intelligente pour une analyse répétée 2x plus rapide

Intégration de la base de données de vulnérabilités Move : Schémas issus de 128 résultats critiques/élevés sur 77 audits, adaptés pour Solidity/EVM :

• Logique métier, gestion d'état, incohérence des données, centralisation, problèmes de boucles et validation d'entrée renforcée

Démarrage rapide

1. Configuration```bash

python setup.py # Interactive installer (recommended)

### 2. Lancer Aether```bash
python aether.py         # Launches the full-screen Textual TUI

C'est tout. La TUI vous guide à travers tout via des raccourcis clavier et des boîtes de dialogue modales.

Prérequis

• Python 3.11+ (testé avec 3.12.8)
• Node.js 22+ (pour les projets basés sur Hardhat/npm)
• Foundry (forge/anvil) dans le PATH pour la génération et la validation de PoC
• solc-select pour plusieurs versions du compilateur Solidity
• py-solc-x (optionnel) pour l'analyse AST de Solidity — utilise l'analyse par regex si indisponible
• Clés API pour les fonctionnalités LLM :
  • OPENAI_API_KEY (pour les modèles GPT)
  • GEMINI_API_KEY (pour les modèles Gemini)
  • ANTHROPIC_API_KEY (pour les modèles Claude)
  • ETHERSCAN_API_KEY (optionnel, pour récupérer les contrats vérifiés)

Installation manuelle

Si vous préférez l'installation manuelle :```bash

Foundry

curl -L https://foundry.paradigm.xyz | bash && foundryup export PATH="$PATH:$HOME/.foundry/bin"

solc-select

pip install solc-select solc-select install 0.4.26 0.8.0 0.8.19 0.8.20 latest

Python dependencies

python -m venv venv && source venv/bin/activate pip install -r requirements.txt

## Configuration

L'assistant de configuration (`python setup.py`) gère tout. Vous pouvez également configurer depuis l'interface TUI via `s` (Paramètres) :

- **Configurer les clés API** — invites séquentielles pour les clés OpenAI, Gemini, Anthropic, Etherscan avec valeurs actuelles masquées
- **Configurer les modèles** — sélectionner les modèles par fournisseur parmi les options disponibles
- **Assistant complet** — exécute la saisie des clés API puis la sélection des modèles
- **Paramètres de triage** — ajuster les seuils de gravité, les niveaux de confiance, le nombre maximal de résultats

Ou définissez les variables d'environnement directement :```bash
export OPENAI_API_KEY=sk-...
export GEMINI_API_KEY=...
export ANTHROPIC_API_KEY=...

Configuration is stored in ~/.aether/config.yaml.

Emplacements des bases de données :

• Résultats du moteur : ~/.aether/aetheraudit.db
• Flux de travail d'audit GitHub : ~/.aether/aether_github_audit.db

Guide TUI

Toute interaction se fait via des raccourcis clavier depuis l'écran principal :

n — Nouvel audit

Assistant en plusieurs étapes avec trois types de source :

Fichier ou répertoire local :

1. Sélectionnez le chemin via PathDialog
2. S'il s'agit d'un répertoire, sélectionnez les contrats via CheckboxDialog
3. Choisissez les fonctionnalités (Enhanced, LLM Validation, Foundry PoC, Enhanced Reports)
4. Définissez le répertoire de sortie
5. Confirmez et lancez comme tâche(s) en arrière-plan

URL GitHub :

1. Saisissez l'URL du dépôt
2. Aether clone le dépôt et découvre les contrats (progression affichée en ligne)
3. Si des périmètres précédents existent, choisissez : continuer, réauditer ou créer un nouveau périmètre
4. Sélectionnez les contrats via ContractSelectorDialog (filtrable, espace pour basculer, a/n pour tout/rien)
5. L'audit se lance comme tâche en arrière-plan — visible dans le tableau des tâches

URL d'explorateur de blocs / adresse :

1. Saisissez une adresse ou une URL d'explorateur
2. Aether récupère le code source vérifié
3. Continuez à travers les fonctionnalités et la sélection de sortie

r — Reprendre un audit

Tableau de tous les audits GitHub en cours avec nom du projet, périmètre, progression (N/M contrats) et heure de dernière mise à jour. Sélectionnez-en un pour vérifier les contrats en attente et le lancer comme tâche en arrière-plan.

h — Historique des audits

Vue unifiée de tous les audits passés des deux bases de données (locale + GitHub). Sélectionnez une entrée pour afficher un sous-menu :

• Voir les détails — répartition du périmètre avec progression et statut
• Générer des PoCs — redirection vers l'assistant PoC avec projet présélectionné
• Réauditer — sélectionnez les contrats via ContractSelectorDialog, lancez comme tâche en arrière-plan

p — Générer des PoCs

Sélectionnez un projet, configurez le nombre maximal d'éléments, la sévérité minimale et le filtrage par consensus uniquement. La génération de PoC s'exécute comme tâche en arrière-plan — surveillez la progression dans le tableau des tâches.

o — Rapports

Sélectionnez le projet, le périmètre et le format (markdown/json/html/tous). La génération du rapport s'exécute comme tâche en arrière-plan.

f — Récupérer un contrat

Choisissez un réseau parmi plus de 10 chaînes prises en charge, saisissez une adresse ou collez une URL d'explorateur, récupérez le code source vérifié et, éventuellement, auditez-le immédiatement.

s — Paramètres

• Exécuter l'assistant de configuration complet — clés API puis sélection du modèle, le tout en ligne
• Afficher la configuration actuelle — affichage formaté de tous les paramètres
• Reconfigurer les clés API — invites TextInputDialog avec valeurs actuelles masquées
• Reconfigurer les sélections de modèles — SelectDialog par fournisseur
• Paramètres de triage — sévérité, seuil de confiance, nombre maximal de résultats
• Effacer les données — effacer la base de données d'audit locale, la base de données d'audit GitHub, le cache d'analyse, ou tout à la fois (avec confirmation)

Entrée — Détail de la tâche

Appuyez sur Entrée sur n'importe quelle ligne du tableau des tâches pour voir :

• Sortie de journal défilante en direct (mise à jour chaque seconde)
• Barre de progression de phase
• Métadonnées de la tâche (type, cible, statut, coût, temps écoulé)

q — Quitter

Quitte la TUI. Si des tâches sont en cours, demande une confirmation.

Portée et capacités

• Analyse AST Solidity — Analyse de code assistée par compilateur via py-solc-x pour une résolution correcte de l'héritage, la visibilité des fonctions, la disposition du stockage et le suivi des lectures/écritures des variables d'état ; repli élégant sur regex
• Analyse du graphe de flux de contrôle — build_cfg() construit des blocs de base avec arbres de dominance et détection des en-têtes de boucle ; analyse des blocs d'assembly ; contexte CFG injecté dans l'analyse approfondie et la propagation de taint
• Moteur d'analyse de taint — Suit les entrées contrôlées par l'utilisateur (8 types de sources) à travers les contrats jusqu'à 12 types de sinks dangereux avec détection de sanitizers, suivi inter-contrats et propagation CFG sensible aux branches
• Analyse inter-contrats — Analyseur de relations inter-contrats avec détection des frontières de confiance, regroupement union-find, passe LLM dédiée (Pass 3.5) pour les vulnérabilités multi-contrats et RelatedContractResolver pour le contexte de dépendances
• Moteur d'analyse approfondie — Pipeline LLM en 6 passes plus Pass 3.5 (inter-contrats) : comprendre → cartographier la surface d'attaque → vérifier les invariants → analyse inter-contrats → analyse inter-fonctions → modélisation adversarial → cas limites ; sélection du niveau de modèle par passe, mise en cache, exemples few-shot, application du raisonnement en chaîne, contexte CFG dans la passe 2, calibration ML de la sévérité dans la passe 5, contexte des contrats liés par passe
• Exécution symbolique Halmos — HalmosRunner + HalmosPropertyGenerator pour la vérification formelle des invariants ; intégré à l'étape de validation 1.95 ; dégradation élégante si Halmos n'est pas installé
• Boucle de rétroaction ML — AccuracyTracker enregistre les résultats des soumissions et génère des poids de confiance par détecteur ; calibration de la sévérité à partir des données historiques injectée dans l'analyse approfondie

Répertoires de sortie

• ./output/ — Racine générale de sortie
• ./output/reports/ — Rapports générés
• ./output/pocs/ — Suites de PoCs Foundry générées
• ./output/exploit_tests/ — Résultats des tests d'exploits

Architecture

Points d'entrée

• aether.py — Point d'entrée unique ; lance la TUI Textual
• cli/interactive_menu.py — Fine couche d'adaptation créant JobManager + AetherApp
• cli/tui/app.py — AetherApp(App) — application Textual principale avec raccourcis clavier et minuteur d'actualisation d'une seconde

Couche TUI (cli/tui/)

• Écrans : MainScreen (tableau des tâches + barre de coûts), JobDetailScreen (journal en direct + phase + métadonnées), NewAuditScreen, HistoryScreen, ResumeScreen, PoCScreen, ReportsScreen, FetchScreen, SettingsScreen
• Widgets : JobsTable (DataTable interrogeant JobManager), CostBar (coût de session par fournisseur), LogViewer (RichLog avec actualisation incrémentale), PhaseBar (progression par blocs Unicode)
• Boîtes de dialogue : ConfirmDialog, , , , , — toutes des sous-classes de ModalScreen

Exécution en arrière-plan

• cli/audit_runner.py — classe AuditRunner exécutant les audits, PoCs, rapports et audits GitHub dans des threads daemon
• core/job_manager.py — singleton JobManager : registre des tâches de session (QUEUED/RUNNING/COMPLETED/FAILED/CANCELLED)
• core/audit_progress.py — ContractAuditStatus avec tampons de journal par tâche, ThreadDemuxWriter pour la capture stdout/stderr
• core/llm_usage_tracker.py — singleton thread-safe avec snapshot() pour les écarts de coût par tâche

Orchestration centrale

• cli/main.py — classe AetherCLI (~2600 lignes) — orchestrateur d'audit interne utilisé par AuditRunner
• core/enhanced_audit_engine.py — Moteur d'audit principal avec intégration de l'analyse approfondie
• core/post_audit_summary.py — panneau post-audit avec répartition des coûts par fournisseur

Couche d'analyse approfondie (v4.7)

• core/deep_analysis_engine.py — pipeline LLM en 6 passes plus Pass 3.5 (inter-contrats) : comprendre → surface d'attaque → invariants → inter-contrats → inter-fonctions → adversarial → cas limites ; sélection du niveau de modèle, mise en cache, exemples few-shot, application du raisonnement en chaîne, contexte CFG dans la passe 2, calibration ML de la sévérité dans la passe 5, contexte des contrats liés par passe
• core/protocol_archetypes.py — détection d'archétypes de protocoles (14 types dont LIQUID_STAKING, PERPETUAL_DEX, CDP_STABLECOIN, YIELD_AGGREGATOR) avec listes de contrôle de vulnérabilités par archétype
• core/exploit_knowledge_base.py — plus de 75 schémas d'exploits réels catégorisés dans 14 catégories (dont CROSS_CONTRACT, SIGNATURE_AUTH, TOKEN_INTEGRATION, PROXY_UPGRADE, TYPE_SAFETY)
• core/invariant_engine.py — extraction d'invariants (NatSpec + LLM + schéma) et génération de tests d'invariants Foundry + génération de propriétés Halmos
• core/solidity_ast.py — analyse AST Solidity via py-solc-x avec repli regex pour l'héritage, la visibilité, la disposition du stockage, le suivi des lectures/écritures d'état ; construction du graphe de flux de contrôle (build_cfg(), get_dominators(), get_loop_headers())
• core/taint_analyzer.py — analyse de flux de données / taint avec 8 types de sources, 12 types de sinks, détection de sanitizers, suivi inter-contrats, propagation CFG sensible aux branches

Couche de détection

• core/enhanced_vulnerability_detector.py — détecteur principal avec plus de 60 schémas
• core/business_logic_detector.py, core/state_management_detector.py, core/data_inconsistency_detector.py, core/centralization_detector.py, core/looping_detector.py — détecteurs inspirés de Move
• core/defi_vulnerability_detector.py, core/mev_detector.py, core/oracle_manipulation_detector.py — détecteurs spécifiques DeFi (détecteur DeFi intégré au moteur amélioré en v3.5)
• core/arithmetic_analyzer.py, core/precision_analyzer.py, core/gas_analyzer.py, , — analyseurs spécialisés (analyseur de précision amélioré avec détection de l'inflation des parts, de la direction d'arrondi, de la troncature des divisions, de l'exploitation de poussière et des dépassements d'accumulateur)

Couche de validation

• core/validation_pipeline.py — pipeline en plusieurs étapes : vérification des protections intégrées, détection de gouvernance, validation sensible au taint (étape 1.85), vérification symbolique Halmos (étape 1.95), vérification de déploiement, validation locale
• core/governance_detector.py, core/deployment_analyzer.py, core/llm_false_positive_filter.py
• core/control_flow_guard_detector.py, core/inheritance_verifier.py
• core/nodes/halmos_node.py — nœud de pipeline HalmosSymbolicNode pour la validation par exécution symbolique

Couche LLM et IA

• core/enhanced_llm_analyzer.py — analyse LLM structurée (GPT/Gemini/Claude) avec sortie JSON et rotation multi-fournisseurs
• core/enhanced_prompts.py — modèles de prompts de production avec chargement dynamique des schémas d'exploits depuis la base de connaissances, exemples few-shot, calibration de la sévérité et application du raisonnement en chaîne

Couche de génération de PoCs

• core/foundry_poc_generator.py (~8000 lignes) — analyse basée sur l'AST, retour de compilation itératif (jusqu'à 5 tentatives), exécution automatique via forge test --json avec analyse de PoCTestResult et prise en charge du mode fork
• core/llm_foundry_generator.py — génération de tests basée sur LLM avec documentation d'API mock et schémas setUp recommandés
• core/enhanced_foundry_integration.py — validation et formatage Foundry
• core/poc_templates.py — modèles de contrats mock (MockERC20, MockOracle, MockWETH, MockFlashLoanProvider)
• core/poc_setup_generator.py — génération intelligente de setUp() : extraction des paramètres du constructeur, déploiement de mocks, gestion des contrats upgradeables, mint et approbations de jetons

Couche de persistance

• core/database_manager.py — DatabaseManager (audits locaux) + AetherDatabase (audits GitHub)
• core/analysis_cache.py — mise en cache intelligente pour une analyse répétée 2 fois plus rapide
• core/accuracy_tracker.py — boucle de rétroaction ML : résultats des soumissions, gains de bounties, statistiques de précision par détecteur, génération des poids de confiance

Intégrations

• core/github_auditor.py — clone des dépôts, détection des frameworks, découverte des contrats, coordination de l'analyse
• core/etherscan_fetcher.py, core/basescan_fetcher.py — récupération des contrats vérifiés depuis les explorateurs de blocs
• core/exploit_tester.py — validation des exploits contre des forks Anvil

Exécution basée sur des flux

Les flux d'audit sont définis dans des configurations YAML (configs/). Pipeline d'audit amélioré : FileReaderNode -> StaticAnalysisNode -> LLMAnalysisNode -> EnhancedExploitabilityNode -> [FixGeneratorNode -> ValidationNode -> HalmosSymbolicNode] -> ReportNode

Tests

2059 tests répartis dans 76 fichiers de test, exécutés en ~23 secondes :```bash python -m pytest tests/ # All tests (~23s, 2059 tests) python -m pytest tests/test_enhanced_detectors.py -v # Single file python -m pytest tests/test_enhanced_detectors.py::TestArithmeticAnalyzer -v # Single class python -m pytest tests/ -k "governance" -v # Pattern match python -m pytest tests/ --cov=core --cov-report=html # With coverage

## Dépannage

- **Foundry introuvable** — Vérifiez que `forge`/`anvil` sont installés et dans le `PATH` (`foundryup` et `export PATH="$PATH:$HOME/.foundry/bin"`)
- **solc introuvable** — Installez `solc-select` et les versions requises : `solc-select install 0.8.20 latest`
- **Fonctionnalités LLM non fonctionnelles** — Vérifiez que les clés API sont définies. Certains modèles peuvent être indisponibles dans votre compte/région ; le système bascule automatiquement en mode de repli
- **Base de données introuvable** — Pour les rapports GitHub, assurez-vous que le workflow d'audit a été exécuté au préalable
- **Textual ne se charge pas** — Exécutez `pip install textual>=1.0.0` s'il manque

---

## Journal des modifications

### v4.7 — Auto-exécution des PoC, vérification symbolique Halmos, analyse CFG et boucle de rétroaction ML
- **Auto-exécution des PoC** — les PoC Foundry générés sont automatiquement compilés et exécutés via `forge test --json` avec l'analyse des `PoCTestResult` et le support du mode fork ; phase `POC_TESTING` pour le suivi en direct dans la TUI
- **Exécution symbolique Halmos** — nœud de pipeline `HalmosRunner`, `HalmosPropertyGenerator` et `HalmosSymbolicNode` (étape de validation 1.95) pour la vérification formelle des invariants ; dégradation progressive si Halmos n'est pas installé
- **Analyse du graphe de flux de contrôle** — `BasicBlock`, `CFGEdge`, `ControlFlowGraph` avec `build_cfg()`, arbres de dominance, détection des en-têtes de boucle, analyse des blocs d'assembly ; contexte CFG injecté dans la passe 2 d'analyse approfondie ; propagation de taint sensible aux branches
- **Boucle de rétroaction ML** — `AccuracyTracker` enregistre les résultats des soumissions avec `get_detector_accuracy()` et `get_detector_weights()` pour des statistiques par détecteur ; ajustement des poids de confiance dans `EnhancedVulnerabilityDetector` ; calibration de la sévérité dans la passe 5 d'analyse approfondie
- **Contexte des contrats liés** — `RelatedContractResolver` découvre les contrats parents, interfaces, bibliothèques et dépendances avec un système de budget par passe (200K/100K/50K caractères) ; résumé de la bibliothèque standard ; découverte de contrats frères au sein d'un même fichier
- **Nettoyage de la dette technique** — 8 500 lignes de code mort supprimées : suppression de `ai_ensemble.py`, `audit_engine.py`, `fork_verifier.py` ; retrait de toutes les références ai_ensemble du CLI, de l'exécuteur d'audit, des écrans TUI et du générateur de rapports
- **2059 tests** réussis dans 76 fichiers de test

### v4.0 — Analyse AST Solidity, analyse de taint et suivi du flux de données
- **Analyseur AST Solidity** — intégration complète de solc via py-solc-x pour une résolution correcte de l'héritage, la visibilité des fonctions, la disposition du stockage, le suivi des lectures/écritures d'état ; repli élégant sur les regex
- **Moteur d'analyse de taint** — suit les entrées contrôlées par l'utilisateur à travers 8 types de sources vers 12 sinks dangereux avec détection des assainisseurs et suivi inter-contrats
- **Intégration au pipeline** — les données AST alimentent la passe 1, les données de taint alimentent la passe 2, étape de validation 1.85 sensible au taint
- **1839 tests** réussis dans 67 fichiers de test (~23 secondes)

### v3.8 — Détection améliorée et génération de PoC
- **Analyse inter-contrats** — nouvelle passe 3.5 avec analyseur de relations inter-contrats, détection des frontières de confiance, regroupement union-find
- **Base de données des particularités de jetons** — 12 catégories de comportements ERC-20 non standard (fee-on-transfer, rebasing, ERC-777, etc.)
- **Moteur de précision amélioré** — détection de l'inflation des parts, analyse du sens d'arrondi, suivi des troncatures de division, exploitation du dust, dépassement d'accumulateur
- **Génération de PoC exécutables** — bibliothèque de contrats simulés (ERC20, Oracle, WETH, FlashLoan), setUp() intelligent, tentatives de compilation maximales 3→5
- **Exemples few-shot** dans les passes d'analyse approfondie 3, 4, 5 avec de vraies vulnérabilités et des exemples de faux positifs
- **Calibration de la sévérité** — seuils concrets (Critique >1 M$, Élevée >100 K$, Moyenne >10 K$, Faible théorique)
- **Imposition de la chaîne de raisonnement** — raisonnement obligatoire en 5 étapes avant la sortie JSON
- **Ensemble IA retiré** — remplacé par une rotation multi-fournisseurs dans les passes d'analyse approfondie
- **Rotation multi-fournisseurs** — Gemini Flash (passes économiques), Anthropic Claude (raisonnement), OpenAI GPT (diversité)
- **1682 tests** réussis

### v3.7 — Archétypes étendus et schémas d'exploitation
- **4 nouveaux archétypes de protocole** — LIQUID_STAKING, PERPETUAL_DEX, CDP_STABLECOIN, YIELD_AGGREGATOR (10→14 au total)
- **25 nouveaux schémas d'exploitation** — catégories CROSS_CONTRACT, SIGNATURE_AUTH, TOKEN_INTEGRATION, PROXY_UPGRADE, TYPE_SAFETY (50→75 au total)
- **Scanner de contrats amélioré** — les contrats abstraits sont désormais notés, seuils ajustés pour le support des monorepos
- **1528 tests** réussis

### v3.5.2 — Réduction des faux positifs
- **Détection des scripts dans la découverte de contrats** — les fichiers sous `script/`/`scripts/`, les fichiers `.s.sol`, et les contrats qui importent `forge-std/Script.sol` ou qui héritent de `is Script` sont marqués comme scripts de déploiement et exclus de l'analyse des vulnérabilités par LLM. Élimine toute une classe de faux positifs provenant des helpers de déploiement Foundry analysés comme code de production
- **Marqueurs de contexte de fichier dans les invites LLM** — le contenu combiné inclut désormais des marqueurs `// FILE: <name>` par fichier, et les passes d'analyse approfondie 1 et 3 reçoivent un en-tête `## Project Files` étiquetant chaque fichier comme `[PRODUCTION]` ou `[DEPLOYMENT SCRIPT]` afin que les LLM se concentrent sur le bon code
- **Détection dynamique des modificateurs** — `GovernanceDetector` extrait désormais les modificateurs de contrôle d'accès personnalisés définis dans le contrat (par ex. `onlyDistributor`, `onlyMinter`, `authorized`) en recherchant les définitions de modificateurs avec le préfixe `only` ou des vérifications `msg.sender`. Ceux-ci sont fusionnés avec la liste codée en dur des modificateurs pour `has_access_control()` et `is_governance_function()`
- **Déduplication à l'échelle de la fonction** — `VulnerabilityDeduplicator` regroupe désormais les constats par `(function_name, vuln_type)` lorsque le code du contrat est disponible, remplaçant la correspondance fragile par ligne exacte qui manquait les doublons de lignes adjacentes dans la même fonction. Repli sur un regroupement par compartiments de 20 lignes lorsque le contexte de la fonction est indisponible
- **Tolérance de lignes élargie pour l'ensemble IA** — la tolérance de `_findings_match_fuzzy()` passe de ±5 à ±15 lignes pour détecter les doublons dans une même fonction entre agents
- **Schéma de faux positif du constructeur atomique** — `_check_constructor_context()` détecte désormais lorsqu'un contrat est déployé (`new`/`Create2`) et initialisé (`.initialize()`) dans le même constructeur, marquant les préoccupations de front-running comme faux positifs puisque les opérations sont atomiques
- **Schéma de validation LLM n°18** — ajout de « Atomic Deployment + Initialization » à la liste de contrôle des 18 schémas de faux positifs dans l'invite de validation LLM
- **1489 tests** réussis dans 56 fichiers de test (~40 secondes), contre 1461 auparavant

### v3.5 — Moteur d'analyse approfondie
- **Pipeline d'analyse approfondie en 6 passes** — remplace les appels LLM uniques par un raisonnement structuré multi-passes : Compréhension du protocole → Cartographie de la surface d'attaque → Analyse des violations d'invariants → Interaction inter-fonctions → Modélisation adverse → Cas limites et extrêmes. Chaque passe reçoit le contexte accumulé des passes précédentes. Passes 1-2 mises en cache par hash de contenu pour des ré-audits rapides
- **Détection d'archétype de protocole** — identifie automatiquement le type de protocole (Vault ERC-4626, Pool de prêt, DEX/AMM, Pont, Staking, Gouvernance, Oracle, Place de marché NFT, Jeton, Carnet d'ordres) avec des listes de contrôle de vulnérabilités par archétype issues d'exploits réels
- **Base de connaissances des exploits** — 50+ schémas d'exploitation catégorisés dans 9 catégories (Inflation/Parts, Réentrance, Oracle, Gouvernance, Pont, Précision/Arrondi, Contrôle d'accès, Économique/DeFi, Logique) remplaçant la liste statique de 10 schémas. Chaque schéma inclut des indicateurs de code, les protections manquantes, le mécanisme d'exploitation étape par étape, des précédents réels avec montants en dollars et l'applicabilité par archétype
- **Moteur d'invariants** — extrait les invariants du protocole à partir des balises NatSpec `@invariant`, de l'analyse LLM et de 6 détecteurs de schémas courants (conservation du vault, suivi des soldes, comptabilité de l'offre, produit constant AMM, collatéralisation des prêts, récompenses de staking). Génère des suites de tests Foundry `invariant_*()` comme preuves de vérification formelle allégée
- **Calibration de sévérité contextuelle** — remplace les réductions de sévérité systématiques par des vérifications du contexte de risque. Les constats dans les blocs `unchecked{}`, près de transferts de valeur (`call{value:}`, `_mint`, `safeTransfer`), de calculs de prix ou de contextes oracle conservent leur sévérité d'origine
- **Correction de la porte de validation** — les constats `"pending"` passent désormais à l'analyse LLM avec le drapeau `needs_llm_validation`. Seuls les constats explicitement `"false_positive"` sont écartés (auparavant, tous les constats non-`"validated"` étaient silencieusement filtrés)
- **Pénalité de confiance adaptée aux spécialistes** — les constats d'un agent unique correspondant à sa spécialisation (par ex., AnthropicReasoningSpecialist + attaques économiques) reçoivent une pénalité de -0,05 ; les constats non spécialisés conservent -0,15
- **Correction de la déduplication par compartiments de lignes** — suppression du compartimentage `(line // 10) * 10` qui causait des problèmes de frontières arbitraires (lignes 9 et 11 dans des compartiments différents). La déduplication n'utilise désormais que le type de vulnérabilité normalisé, `_findings_match_fuzzy()` gérant la proximité des lignes
- **Intégration du détecteur DeFi** — `DeFiVulnerabilityDetector` (analyse sémantique de présence/absence en deux étapes) s'exécute désormais dans le moteur d'audit amélioré aux côtés de `EnhancedVulnerabilityDetector`
- **Schémas d'exploitation dynamiques dans les invites** — `enhanced_prompts.py` charge désormais les schémas de ExploitKnowledgeBase filtrés par domaine d'intérêt, avec repli sur les schémas statiques
- **1461 tests** réussis dans 55 fichiers de test (~50 secondes)

### v3.2 — Statistiques des tâches et correctifs d'interface
- **Correction des statistiques de tâche (constats/coût/LLM) qui s'affichaient toujours à zéro** — le worker d'audit capture désormais le dict de résultats de `run_audit()` pour extraire le nombre de constats ; suppression de `LLMUsageTracker.reset()` qui orphelinait les références singleton ; les 4 types de workers calculent les statistiques par tâche à partir des deltas d'instantanés
- **Correction de l'artefact de rafraîchissement de l'interface lors du changement de fenêtre** — remplacement des conteneurs défilants par un simple `Container` + `overflow: hidden` dans JobDetailScreen pour empêcher les trames de compositeur obsolètes
- **Déplacement de « Job Details » vers border_title** pour un rendu plus propre du panneau de métadonnées
- Suppression de `CLAUDE.md` du suivi git

### v3.0 — TUI Textual entièrement intégrée
- **Zéro appel `app.suspend()`** — la TUI ne retombe jamais sur un terminal brut ; chaque opération s'exécute en ligne
- **Génération de PoC en arrière-plan** — s'exécute en tant que thread daemon via `AuditRunner.start_poc_generation()` avec sortie en direct dans JobDetailScreen
- **Génération de rapports en arrière-plan** — s'exécute en tant que thread daemon via `AuditRunner.start_report_generation()` avec sortie en direct
- **Audits GitHub en arrière-plan** — sélection du périmètre via les dialogues Textual, l'audit s'exécute en tant que thread daemon via `AuditRunner.start_github_audit()`
- **ContractSelectorDialog** — modale multi-sélection filtrable quasi plein écran remplaçant `ScopeManager.interactive_select()` basé sur curses. Espace pour basculer, `a`/`n` pour tout/sélectionner aucun, taper pour filtrer, contrats déjà audités avec code couleur
- **GitHubAuditHelper** — wrapper décomposé autour de `GitHubAuditor`/`AetherDatabase` fournissant des opérations atomiques (`clone_and_discover`, `get_scope_state`, `save_new_scope`, `get_pending_contracts`, `handle_reaudit`) appelables depuis les écrans Textual
- **Paramètres intégrés** — configuration des clés API et des modèles via TextInputDialog/SelectDialog natifs, aucun assistant de configuration externe requis
- **Gestion intégrée du périmètre GitHub** — continuer, ré-auditer ou créer un nouveau périmètre via SelectDialog ; sélection des contrats via ContractSelectorDialog
- **6 écrans réécrits** — PoCScreen, ReportsScreen, SettingsScreen, NewAuditScreen, HistoryScreen, ResumeScreen — tous entièrement intégrés
- **770 tests** réussis dans 50 fichiers de test

### v2.2 — Tableau de bord TUI Textual
- TUI Textual plein écran avec application persistante, raccourcis clavier et minuteur de rafraîchissement d'une seconde
- MainScreen avec tableau des tâches en direct et barre de coût de session
- JobDetailScreen avec visualiseur de journaux en direct, barre de progression des phases et métadonnées
- Dialogues modaux (confirmation, saisie de texte, sélection, case à cocher, sélecteur de chemin) remplaçant les invites questionary
- Exécution d'audit en arrière-plan via AuditRunner avec capture de sortie ThreadDemuxWriter
- Singleton JobManager pour le registre des tâches de session
- Suivi du coût par tâche via les instantanés LLMUsageTracker

### v2.1 — Audits parallèles, suppression de Slither et nettoyage des tests
- Moteur d'audit parallèle — exécute plusieurs contrats simultanément avec `ThreadPoolExecutor`, configurable jusqu'à 8 workers parallèles
- Suivi de progression thread-safe — `ContractAuditStatus` avec verrouillage, `ThreadDemuxWriter` pour le multiplexage de stdout
- Résumé post-audit — vue consolidée des résultats après la fin des audits parallèles
- Suivi d'utilisation LLM — suivi de l'utilisation des jetons, des coûts et des appels API sur les trois fournisseurs
- Slither entièrement supprimé — toutes les dépendances, le code d'intégration et les tests supprimés (~1 200 lignes) ; les détecteurs basés sur des schémas + l'ABI Foundry + les regex sont les seuls outils d'analyse
- Nettoyage de la suite de tests — suppression de 40+ fichiers de test anciens/lents/d'intégration

### v2.0 — TUI à menu interactif
- TUI pilotée par menu interactif comme interface principale
- Assistant d'audit guidé avec sélection de la source, cases à cocher des fonctionnalités et confirmation
- Capacité de reprendre un audit pour les audits GitHub en cours
- Navigateur d'historique d'audit unifié sur les bases locales et GitHub
- Flux de travail intégrés de génération de PoC et de rapports depuis le menu
- Récupération de contrats multi-chaînes avec audit immédiat facultatif
- Gestion des paramètres depuis le menu
- Lancement/retour console depuis le menu

### v1.5 — Support LLM à trois fournisseurs et analyse améliorée
- Intégration d'Anthropic Claude (Sonnet 4.5, Opus 4.6, Haiku 4.5) comme troisième fournisseur LLM
- Ensemble IA de 6 agents spécialisés : 2 OpenAI + 2 Gemini + 2 Anthropic
- Repli automatique inter-fournisseurs pour une disponibilité maximale
- Modèles OpenAI mis à jour (GPT-5.3) et modèles Google Gemini (3.0 Flash/Pro)
- Assistant de configuration mis à jour avec configuration de la clé API Anthropic et sélection du modèle
- Correction de la commande CLI generate-foundry cassée

---

## Licence

Aether est distribué sous la **licence MIT**. Voir le fichier [LICENSE](https://github.com/l33tdawg/aether/blob/HEAD/LICENSE) pour plus de détails.

## Auteur

**Dhillon Andrew Kannabhiran** (@l33tdawg)
- Email: [email protected]
- Twitter: [@l33tdawg](https://twitter.com/l33tdawg)
- GitHub: [@l33tdawg](https://github.com/l33tdawg)

## Contribution

Les contributions sont les bienvenues ! N'hésitez pas à soumettre des issues, à forker le dépôt et à créer des pull requests.