Projets
Intentions
Aucune intention pour l'instant
FinOps
Chargement des logs…
Aucune donnée — clique sur ↻ pour interroger Azure.
Statistiques (30 j)
Chargement…
Lionel · Mon-Agentic
Pointe vers un dossier existant sur cette machine. Un CLAUDE.md sera détecté automatiquement.
Écris le prompt, sélectionne le projet, clique + Backlog pour la garder de côté sans la lancer.
→ Apparaît dans le sous-bloc Backlog de la carte projet, en attente
Soit clique directement ☰ Spec dans le formulaire, soit clique ☰ Spec sur une idée du Backlog (et ✕ pour l'écarter sans suite).
→ docs/specs/nom-feature.md + fichier de tracking créés · agent rédacteur lancé · badge SPEC · environnement Local
Sur la feature, lance chaque agent dans l'ordre via son badge : Arch (décisions d'architecture), puis Dev (implémentation selon l'archi), puis QA (écrit et lance les tests jusqu'à 100%). Chaque agent lit la spec et le fichier de tracking pour s'appuyer sur le travail précédent.
→ badge ● clignotant pendant l'exécution (bouton ■ Stop dans le panneau pour annuler proprement) · ✓ une fois terminé · étape suivante débloquée
▶ Staging ne s'active qu'une fois QA validé (✓ QA). Pour aller plus vite sans cliquer chaque étape, ⚡ Fast enchaîne automatiquement les agents restants (Arch → Dev → QA) et s'arrête juste avant — le push reste ensuite manuel via ▶ Staging.
→ Commit auto + push origin/staging · MINOR auto-incrémenté · badge STAGING · environnement Staging
Vérifie sur staging, clique ▶ Prod, puis 🚀 Release (section Versioning).
→ git tag vX.Y.Z + push main · badge DONE · environnement Prod
Décris le bug, choisis la sévérité, clique 🐛 Bug.
→ Apparaît dans la section Bugs de la carte (n'encombre plus la liste globale Intentions)
Clique ▶ Fixer → Claude modifie les fichiers (bouton ■ Stop disponible pour annuler en cours de route).
→ PATCH auto-incrémenté (ex: v0.0.2)
Même flow qu'une feature : ▶ Staging puis ▶ Prod / 🚀 Release.
Un seul bouton 🚀 Release Majeure dans la section Versioning → génère les release notes complètes, crée le tag vX.0.0 et pousse sur main.
Le menu à côté du formulaire choisit le provider : Anthropic (agent Claude Code, accès aux fichiers du projet) ou OpenAI / Ollama (conversation pure, sans écriture de code). ▶ Lancer, + Backlog, ☰ Spec et 🐛 Bug exigent Anthropic et se désactivent sous OpenAI/Ollama ; le chat (mode 💡 Idéation) accepte les 3 providers.
Bascule le formulaire en fenêtre de discussion libre (historique + champ de saisie unique) pour réfléchir ou poser une question sans toucher au code — ne crée aucune intention dans l'historique. Le bouton 🚀 Livrer liste les idées distinctes de la conversation : coche celles à développer, un item de backlog est rédigé par idée, puis la chaîne spec → arch → dev → qa s'enchaîne sans autre clic (bandeau Chaîne Livrer sur la carte du projet). Coche Backlog seulement, sans lancer pour ne créer que les items. Si une étape passe en erreur ou en « Tests KO », la chaîne attend ↻ Relancer le restant ou Stop dans le bandeau Fast Track. ⚙️ Implémentation ramène le formulaire habituel (Backlog/Bug/Lancer/Spec).
Le rond de statut en tête de carte fait défiler le statut manuellement. ↺ Relancer apparaît si l'intention est en erreur. ■ Stop arrête un agent en cours proprement. × supprime la carte. Si le forfait Claude est atteint en cours de route, la carte passe en attente avec l'heure de relance affichée (▶ Relancer maintenant / ✕ Annuler pour reprendre la main).
Le bouton ▼ / ▶ à côté du titre « Intentions » replie l'historique (seule une intention en cours reste visible) ; l'état choisi est mémorisé. 🗑 Purger supprime réellement toutes les réponses affichées (hors intention en cours), comme un clic sur × répété sur chaque carte.
Enchaîne automatiquement, projet par projet, toutes les intentions en Backlog (celles créées via + Backlog) sans intervention manuelle entre chaque étape. Un panneau de progression suit l'avancement, avec ■ Stop pour interrompre et ↻ Reprendre / ↻ Relancer le restant si la file a été arrêtée ou mise en pause par une limite de forfait.
La feature avance côté code (spec → arch → dev → qa) mais n'a encore jamais été poussée sur une branche staging/prod.
Un vrai git push sur la branche staging a eu lieu (bouton ▶ Staging). Si le projet n'a aucun environnement Staging déclaré dans projects.json, le bouton s'affiche ▶ Staging ⚠ : le push git fonctionne quand même, mais rien n'est réellement hébergé derrière.
Un vrai git push sur main a eu lieu (bouton ▶ Prod). Même règle : sans environnement Prod déclaré pour le projet, le bouton devient ▶ Prod ⚠ — push git réel, déploiement inexistant.
Status done/archived posé manuellement (pas via un push). À ne pas confondre avec le badge vert Prod : ça ne prouve aucun déploiement réel. Le bouton ↺ Rollback ne s'affiche que si le projet a un vrai environnement Prod configuré — sinon il n'a rien à annuler.
Feature abandonnée volontairement via ✕ Annulé — jamais livrée, peu importe où elle en était.
Grand écran (≥ 1440 px) : dashboard et aperçu côte à côte, séparation déplaçable (double-clic : 1/3), bouton ▣ Rendu pour masquer/afficher. Écran plus étroit (téléphone via Tailscale) : bascule Dashboard │ Rendu en haut à droite.
Le projet affiché est celui du sélecteur d'intention (le sélecteur de l'aperçu est son miroir). Le bouton 👁 d'une carte projet le sélectionne et ouvre l'aperçu. Local │ Staging, ↻ recharger, ↗ ouvrir dans un onglet (secours si le staging refuse l'affichage intégré).
Front local arrêté : Démarrer lance Back puis Front et l'aperçu se charge tout seul dès que le front répond. Pastille jaune clignotante = une intention tourne sur ce projet ; pastille grise = front local arrêté. Via Tailscale, le front doit être lancé avec --host et appeler son API en relatif (/api + proxy Vite).
Le hub n'écrit jamais de code lui-même : il reçoit ton intention (navigateur local, téléphone via Tailscale ou WhatsApp), puis lance Claude Code CLI comme processus enfant, dans le dossier du projet. C'est Claude Code qui lit, modifie et teste les fichiers ; le hub se contente de récupérer sa sortie et de la streamer dans la carte d'intention.
Toi : navigateur local · Tailscale · WhatsApp
│
┌─────────────────────────────▼──────────────────────────────┐
│ HUB (__hub, :3001) │
│ Front : HTML/CSS/JS vanilla (intentions, statuts, │
│ backlog, bugs, discussion) │
│ Back : server.js (Node http) │
│ ├─ API /api/status, /api/intentions │
│ ├─ data/projects.json, intentions.json │
│ └─ spawn(claude.exe, --dangerously-skip- │
│ permissions --print [--continue], │
│ cwd = dossier du projet) │
└─────────────────────────────┬──────────────────────────────┘
│ processus enfant (stdout → logs)
┌─────────────────────────────▼──────────────────────────────┐
│ CLAUDE CODE CLI (le « harness ») ──HTTPS──► API │
│ (détail à l'étape 2) Anthropic │
└─────────────────────────────┬──────────────────────────────┘
│ lit/écrit les fichiers, lance les commandes
┌──────────────┬──────┴───────┬──────────────┐
hockey-tournoi cardegall MonASOCFoot App4RCHC …
(dépôts git, CLAUDE.md, back NestJS / front Vite)
OLLAMA (:11434) + Qwen / Phi-4 ← à part : seulement pour le
chat 💡 Idéation, sans accès aux fichiers
→ Un projet = un dossier avec son CLAUDE.md, déclaré dans data/projects.json · chaque intention = un spawn avec cwd = ce dossier
Claude Code est un harness : il assemble le contexte, l'envoie au modèle, exécute les outils que le modèle demande, renvoie les résultats… et recommence jusqu'à ce que le modèle déclare avoir fini.
┌─────────────────── Claude Code CLI ─────────────────────────┐
│ │
│ ① Assemblage du contexte │
│ prompt système + CLAUDE.md (hub + projet) + mémoire │
│ + historique de la session (--continue) │
│ │
│ ② BOUCLE AGENT │
│ ┌──► envoie le contexte au modèle ──────────────────┐ │
│ │ le modèle répond : du texte OU un appel d'outil│ │
│ │ ◄──────────────────────────────────────────────┘ │
│ │ exécute l'outil → renvoie le résultat au modèle │
│ └─── recommence jusqu'à « fini » │
│ │
│ ③ Outils : Read · Edit · Write · Grep · Glob · Bash │
│ · WebFetch · Task (sous-agents) · MCP │
│ │
│ ④ Garde-fous : permissions (désactivées par │
│ --dangerously-skip-permissions), hooks │
│ │
│ ⑤ Gestion du contexte : résumé automatique quand ça │
│ déborde, sessions reprenables │
└──────────────────────────┬──────────────────────────────────┘
│ HTTPS (forfait Claude Pro)
┌─────────────▼─────────────────┐
│ Modèles Anthropic (cloud) │
│ • principal : au choix │
│ Sonnet 5 · Opus 5.5 · │
│ Fable 5.1 │
│ • léger : Haiku 4.5 pour les │
│ tâches annexes (résumés, │
│ certains sous-agents) │
└───────────────────────────────┘
Le harness ne « code » pas lui-même : c'est une boucle qui transmet des outils à un modèle. L'intelligence vient du modèle ; la fiabilité et la sécurité viennent du harness.
→ Chaque tour de boucle renvoie tout le contexte au modèle : c'est pourquoi une seule intention peut consommer des centaines de milliers de tokens en quelques tours seulement
OpenCode se place exactement au même niveau que Claude Code CLI : c'est un deuxième moteur, à côté du premier, qui fait tourner la même boucle agent autour d'un modèle local.
┌──────────────────────── HUB (:3001) ──────────────────────────┐
│ Front : sélecteur de moteur par intention │
│ [ Claude ] [ Local (Qwen) ] [ Plan Claude → Qwen ] │
│ Back : server.js → ROUTEUR DE MOTEUR │
└────────────┬──────────────────────────────┬───────────────────┘
│ spawn claude.exe │ spawn « opencode run »
│ │ (plus tard : HTTP vers
│ │ « opencode serve »)
┌────────────▼────────────┐ ┌─────────────▼─────────────────────┐
│ CLAUDE CODE CLI │ │ OPENCODE │
│ harness propriétaire │ │ harness open source : même boucle │
│ modèle imposé │ │ agent, mêmes types d'outils, │
│ │ │ AGENTS.md, opencode.json │
└────────────┬────────────┘ └─────────────┬─────────────────────┘
│ HTTPS │ HTTP local, API OpenAI
▼ ▼
API Anthropic (cloud) ┌──────────────────────────────┐
│ OLLAMA (:11434) │
│ ├─ qwen2.5-coder:7b (code) │
│ └─ phi-4 (raisonnement) │
│ GTX 1060, 6 Go VRAM │
└──────────────────────────────┘
│ │
└──────────────┬───────────────┘
▼
Instances projets (branche feature/, tests, lint)
Dans ce schéma :
• Ollama devient un simple serveur de modèles, l'équivalent local de l'API Anthropic. Il n'a pas de boucle agent et ne touche à aucun fichier.
• OpenCode fournit la boucle agent et les outils autour de Qwen. C'est lui qui lit et modifie les fichiers.
• Le hub ne change presque pas : il lance déjà un processus avec un cwd et récupère sa sortie. Il suffit d'ajouter une branche if (engine === 'local').
• Le mode mixte « Plan Claude → Qwen » : Claude découpe le travail en petites tâches, OpenCode + Qwen exécute chaque tâche, puis le hub lance les tests.
→ Répartition la plus rentable avec le matériel actuel : l'intelligence cloud pour planifier, le GPU local pour exécuter
▌
La commande de connexion ouvre une fenêtre de navigateur sur la machine qui héberge le hub — si tu es connecté à distance sans accès physique à cette machine, la connexion ne peut pas aboutir ici.
▌
La chaîne enchaîne spec → arch → dev → qa. Si une étape passe en erreur ou en “Tests KO”, elle attend jusqu'à “Relancer le restant” ou Stop dans le bandeau Fast Track. Si le projet est occupé, elle attend son tour.