Tâches de code

Le tableau de code transforme une consigne écrite en code fusionné avec aussi peu de cérémonie que vous le souhaitez : écrivez ce dont vous avez besoin, planifiez-le en phases relisables avec un agent de planification interactif ou traitez-le en un coup, regardez l'agent travailler dans son propre worktree git, relisez le diff avec des commentaires ancrés à la ligne, et fusionnez. Chaque étape est une colonne ; chaque tâche est une carte.

La barre latérale conserve une fine section TÂCHES près du haut — une ligne de pouls résume le tableau (9 planifiées · 1 en cours · 2 à relire) avec un badge orange comptant les cartes en attente dans Test/Revue et un badge rouge lorsqu'un agent a besoin de votre intervention. Cliquez sur le titre de la section ou sur la ligne pour ouvrir le tableau, ou appuyez sur ⇧⌘T depuis n'importe où.

Le tableau Tâches de code : Backlog avec une consigne proposant Planifier et Un coup, Plan avec deux cartes de phase numérotées (la seconde verrouillée derrière une dépendance), En cours avec une tâche en cours d'exécution, Test/Revue avec une carte affichant sa branche et un nombre de commentaires, et Terminé avec une carte fusionnée.

Colonne	Ce qui s'y trouve
Backlog	Les consignes que vous avez écrites mais pas démarrées. Chaque carte propose Planifier et Un coup.
Plan	Les cartes de phase qu'un agent planificateur a classées à partir d'une consigne — numérotées, conscientes de leurs dépendances, multi-sélectionnables.
En cours	Les phases et les tâches en un coup sur lesquelles un agent travaille activement, chacune dans son propre worktree.
Test/Revue	Le travail terminé qui vous attend : la carte ouvre la fenêtre de revue avec le diff de la branche.
Terminé	Les tâches fusionnées, transformées en pull request, ou fermées sans fusion.

Tout sur cette page fonctionne à l'identique depuis un client riche distant — le tableau, la fenêtre de planification et la fenêtre de revue sont tous reflétés via l'API de contrôle.

Écrire une tâche

+ Nouvelle tâche (ou cliquer sur une carte du backlog) ouvre l'éditeur :

Un Titre et une description rédigée en Markdown, avec une bascule Écrire / Aperçu. La consigne devient le prompt de l'agent, alors écrivez-la comme tel.
Espace de travail et Agent — la tâche s'exécute dans l'espace de travail choisi avec l'un de ses agents configurés.
Démarrer l'agent dans — un dossier à l'intérieur de l'espace de travail. Lorsqu'il s'agit d'un dépôt git à part entière, la tâche s'exécute dans un nouveau worktree et une nouvelle branche là-bas.
Créer le dossier et le dépôt git si nécessaire — pour le travail à partir de zéro : démarrer ou planifier exécute d'abord mkdir + git init (avec un commit racine vide) lorsque le dossier n'est pas déjà son propre dépôt. Laissez-le désactivé pour un dossier à l'intérieur d'un dépôt existant.

Une consigne dans le Backlog propose deux boutons :

Un coup envoie la tâche directement dans En cours : l'agent fait le tout de façon autonome et vous remet le diff dans Test/Revue.
Planifier ouvre d'abord une session de planification.

Planification

Planifier lance une session de planification visible et interactive et ouvre sa fenêtre — une vue de conversation native, sans terminal requis. La session s'ouvre sur votre consigne, rendue sous forme de carte ; l'agent explore le dépôt en lecture seule, raconte ce qu'il trouve, et pose des questions lorsque la consigne laisse de vrais choix ouverts.

Les questions arrivent sous forme de carte à onglets — un onglet par question, reflétant exactement le sélecteur que l'agent affiche dans sa propre session. Les réponses sont collectées localement et restent modifiables jusqu'à ce que vous appuyiez sur Soumettre, ce qui envoie l'ensemble d'un coup ; un clic malencontreux n'est jamais définitif. Vous pouvez aussi taper des réponses libres dans le compositeur en bas de la fenêtre, ou appuyer sur Ouvrir le terminal pour observer la session brute.

Lorsque l'agent a ce qu'il lui faut, il classe le plan sur le tableau — des cartes de phase ordonnées dans la colonne Plan, chacune représentant à peu près une pull request de travail relisable, avec des dépendances entre elles — et enregistre un aperçu du plan. La fenêtre affiche alors Le plan est prêt avec le nombre de phases et un bouton Fermer, l'onglet de la session de planification se ferme de lui-même, et la consigne quitte le Backlog (ses phases la remplacent ; supprimez-les toutes et elle revient).

La planification est surveillée : si l'espace de travail redémarre, si l'agent est quitté, ou si la session meurt avant que les phases ne soient classées, le spinner de la carte se termine par une raison précise — cliquez sur Planifier pour réessayer — au lieu de tourner indéfiniment.

La colonne Plan

Les cartes de phase sont numérotées dans l'ordre du plan et portent :

Un badge de dépendance (un cadenas avec des numéros de phase) lorsque la phase nécessite que des phases antérieures soient Terminé d'abord.
Un badge en file lorsque vous l'avez démarrée avant que ses dépendances ne soient finies — elle démarre automatiquement dès qu'elles sont toutes Terminé.
Le nom de leur consigne parente.

Sélectionnez plusieurs phases avec les cases à cocher et la barre de sélection apparaît : Démarrer N sélectionnées traite chacune en un coup (les phases sous condition de dépendance se mettent en file), Effacer abandonne la sélection, et Supprimer retire toute la sélection derrière une seule confirmation. Modifier une phase affiche sa liste Dépend de — chaque phase sœur avec une case à cocher, afin que les dépendances puissent être retravaillées à la main.

Les phases s'exécutent de façon totalement autonome — aucune intervention interactive n'est attendue une fois démarrées.

En cours

Une tâche démarrée démarre l'espace de travail si nécessaire, crée un nouveau worktree du dépôt, et lance l'agent avec la consigne comme prompt. La carte affiche un point d'état d'agent en direct, son heure de démarrage, et Nécessite votre intervention en rouge si l'agent est bloqué sur une question — cliquer sur la carte saute à la session en direct. Le badge TÂCHES de la barre latérale les compte pour que vous n'en manquiez jamais une.

Lorsque l'agent signale la fin, la tâche passe à Test/Revue, et son onglet de terminal se ferme de lui-même — une session terminée n'est pas laissée à squatter la barre d'onglets. Si l'agent plante au lieu de cela, la carte devient rouge plutôt que de faire semblant de travailler.

Test/Revue

La carte Test/Revue ouvre la fenêtre de revue : le diff complet de la branche par rapport à son parent, lu en direct depuis la VM, avec des dépliants par fichier, des décomptes d'ajouts/suppressions, et tout plan que l'agent a enregistré.

Relisez comme une pull request :

Commentaires par ligne : survolez toute ligne ajoutée ou de contexte et cliquez sur la bulle de marge pour attacher un commentaire à cette ligne exacte ; les commentaires ancrés s'affichent sous leurs lignes. Les commentaires au niveau du fichier et généraux fonctionnent aussi.
Renvoyer dans En cours livre chaque commentaire rédigé à l'agent — formaté comme Dans foo.js, ligne 196 : utilisez une autre méthode — et la tâche retourne dans En cours pour un nouveau tour. L'agent reprend sur le même worktree et la même branche.
Fusionner — l'action par défaut du bouton scindé fusionne dans la branche parente ; maintenez-le pour Écraser et fusionner, Créer une pull request… (lorsque l'espace de travail dispose d'un jeton GitHub), ou fusionner dans toute autre branche. Une fusion propre ferme son propre onglet de terminal ; les conflits ouvrent plutôt une session de résolution.
Fermer sans fusionner abandonne le tour tout en conservant l'enregistrement dans Terminé.

Astuce : Le même flux de commentaires par ligne existe en dehors du tableau : lorsque l'onglet actif exécute un agent de code, le volet de diff de l'explorateur de fichiers fait pousser les mêmes bulles de marge, et Envoyer à l'agent regroupe vos commentaires directement dans cette session — de la revue de code sans jamais créer de tâche.

Retirer des cartes

Chaque carte fait pousser un ✕ au survol (et une entrée de menu contextuel Retirer du tableau), derrière une confirmation. Pour les cartes ayant un vrai travail derrière elles, la boîte de dialogue offre un choix : Arrêter l'agent et supprimer le worktree (En cours) ou Supprimer le worktree et la branche (Test/Revue) démolit tout, tandis que Retirer la carte uniquement laisse la session et la copie de travail intactes dans l'espace de travail.

Stockage et API

Les tâches persistent dans un seul fichier à côté du magasin de l'espace de travail, avec des écritures atomiques et des dates ISO-8601 :

~/Library/Application Support/BromureAC/tasks.json

Tout le tableau est reflété sur le socket de contrôle de l'application pour les clients riches et les scripts :

Point de terminaison	Rôle
`GET /tasks`	Lister toutes les tâches.
`POST /tasks`	Créer ou mettre à jour (upsert) un document de tâche.
`POST /tasks/<id>/start`	La démarrer (worktree + agent).
`POST /tasks/<id>/plan`	Lancer la session de planification.
`POST /tasks/<id>/comment`	Ajouter un commentaire de revue (`text`, `file` et `line` facultatifs).
`POST /tasks/<id>/send-back`	Livrer les commentaires non envoyés et renvoyer la tâche dans En cours.
`POST /tasks/<id>/merge`	Fusionner (`squash`, `target` facultatif).
`POST /tasks/<id>/open-pr`	Créer une pull request au lieu de fusionner.
`POST /tasks/<id>/to-testing`, `/to-in-progress`	La déplacer à la main.
`POST /tasks/<id>/destroy`	Arrêter l'agent, supprimer le worktree et la branche, retirer la carte.
`DELETE /tasks/<id>`	Retirer la carte uniquement.

Sous le capot, les agents de planification et de tâche répondent au tableau via un serveur MCP de tableau par session (vsock, côté hôte) : board_get_task, board_set_plan, board_create_subtasks et board_ready_for_review sont la manière dont les phases sont classées et dont une tâche terminée s'annonce — sans interrogation, sans scraping. Les outils sont câblés automatiquement pour chaque agent pris en charge : Claude Code charge une config MCP par branche, Codex reçoit des surcharges mcp_servers par invocation, et Grok lit un .grok/settings.json à portée du projet écrit dans la copie de travail de la session (et exclu de son diff).